> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.beatapi.io/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.beatapi.io/_mcp/server. # Muse Chat Completions POST https://direct.beatapi.io/v1/chat/completions Content-Type: application/json Call Muse Wonder through one OpenAI Chat Completions endpoint with a BeatAPI key.- One endpoint, `POST /v1/chat/completions`, for Muse Wonder. - Text and image input, streaming and function calling, with a 1M-token context window. - Works with the OpenAI SDK: change the base URL and use a BeatAPI key. - The same models also answer on [OpenAI Responses](/text-api/muse/responses) and [Anthropic Messages](/text-api/muse/messages).Use `https://direct.beatapi.io` as the base URL for text requests: it is not subject to Cloudflare's 100-second limit, so a long non-streaming request is not cut off. `https://api.beatapi.io` also works and is the fallback if `direct.beatapi.io` is unreachable from your network. The key, models and prices are the same on both. Image and video APIs use `https://api.beatapi.io` only.POST/v1/chat/completionsTry itOpens this endpoint in the API Explorer. Enter your BeatAPI API key and send: the call is real and is billed to your own balance.## ModelsSend this ID as `model`.| Model ID | Context (tokens) | Max output (tokens) | Positioning | Input, USD per 1M tokens | Output, USD per 1M tokens | Notes | | ------------- | ---------------- | ------------------- | ------------------------------------------------------------------------------------------------ | ------------------------ | ------------------------- | ----------------------------------------------------------------------------------------------------------- | | `muse-wonder` | 1,048,576 | 131,072 | Meta Muse Wonder: a frontier reasoning model for complex personal and professional agentic work. | \$4.00 | \$20.00 | Meta's frontier reasoning model for complex personal and professional agentic work. Needs a funded account. |- Prices are the base tier, discount already applied. A long-context tier, cached-input rates and cache writes are not in this table; see the [price table](https://beatapi.io/pricing). - `—` means the catalogue does not publish the number.## Quick startInstall the `openai` package on your server, keep the key in `BEATAPI_API_KEY`, and never put it in browser code. These are request examples, not recorded model outputs.Read the answer from `choices[0].message.content`, then check `finish_reason` and `usage`. An HTTP 200 alone does not prove the answer satisfies your task: validate it in your application. Text requests return directly; do not poll `/v1/tasks` for them.```bash title="cURL" curl --request POST \ --url https://direct.beatapi.io/v1/chat/completions \ --header "Authorization: Bearer $BEATAPI_API_KEY" \ --header 'Content-Type: application/json' \ --data '{ "model": "muse-wonder", "max_tokens": 2000, "messages": [ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ] }' ``````python title="Python" import os from openai import OpenAI client = OpenAI(api_key=os.environ["BEATAPI_API_KEY"], base_url="https://direct.beatapi.io/v1") completion = client.chat.completions.create( model="muse-wonder", max_tokens=2000, messages=[ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ], ) print(completion.choices[0].message.content) ``````javascript title="JavaScript" import OpenAI from "openai"; const client = new OpenAI({ apiKey: process.env.BEATAPI_API_KEY, baseURL: "https://direct.beatapi.io/v1" }); const completion = await client.chat.completions.create({ "model": "muse-wonder", "max_tokens": 2000, "messages": [ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ] }); console.log(completion.choices[0].message.content); ```## Endpoint and authentication`POST https://direct.beatapi.io/v1/chat/completions`Authorization string Required`Bearer `. The key works with or without the `sk-` prefix.## Request parametersStandard OpenAI Chat Completions fields are accepted. Request-format compatibility does not mean every model-specific option is supported, so test the options you rely on.model string RequiredThe exact model ID.**Allowed values**: `muse-wonder`- Each ID is a separate model, not an alias of another. - Call `GET /v1/models` with your key to confirm which models are enabled for it.messages object[] RequiredThe conversation, oldest message first. Each message has a `role` (`system`, `user`, `assistant` or `tool`) and `content`.max_tokens integer OptionalUpper bound on the generated tokens, reasoning included.- The gateway does not compare your value with the model's max output from the table above. Keep it at or below that number. - `max_tokens` is also used to estimate how much balance a request needs. A very large value can be refused with `402 insufficient_credits` even when the real output would be small. Set it to what you need.A reasoning model writes its reasoning first. If `max_tokens` is too small, the reasoning can use all of it: `content` comes back empty and `finish_reason` is `length`. Leave room for both, and raise the value when you see `length`.stream boolean OptionalDefault: falseReturn the answer as server-sent events. See the Streaming section below.**Default**: `false`temperature number OptionalSampling temperature. Change this or `top_p`, not both.top_p number OptionalNucleus sampling threshold.stop string | string[] OptionalOne or more sequences at which generation stops.tools object[] OptionalFunction definitions the model may call. The model answers with `tool_calls`; return each result in a following `tool` message that carries the matching `tool_call_id`.tool_choice string | object OptionalWhether the model may, must or must not call a tool. Test the value you rely on with your model.## ResponseA non-streaming call returns one JSON object. This is an abbreviated example.```json { "id": "chatcmpl-example", "object": "chat.completion", "created": 1791993600, "model": "muse-wonder", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Retry with exponential backoff and jitter, and make every handler idempotent." }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 19, "completion_tokens": 16, "total_tokens": 35 } } ```### Response fields| Field | Type | Description | | ------------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------ | | `id` | `string` | The completion ID. Log it, together with the request ID, for support and billing audits. | | `model` | `string` | The model that answered. | | `choices[].message.content` | `string` | The answer text. | | `choices[].message.reasoning_content` | `string` | The reasoning text, on models that reason. It is billed as output. | | `choices[].message.tool_calls` | `object[]` | Function calls the model asks you to run. Present when `finish_reason` is `tool_calls`. | | `choices[].finish_reason` | `string` | `stop` for a complete answer, `tool_calls` for a tool request, `length` when `max_tokens` was reached. | | `usage` | `object` | Token counts. Calls are metered from actual token usage. |## StreamingSet `"stream": true`. The answer arrives as `chat.completion.chunk` events and ends with `data: [DONE]`.- The response is `text/event-stream`; without streaming it is `application/json`. - Text arrives in `choices[0].delta.content`. A reasoning model sends its reasoning in `delta.reasoning_content` first. - A failure before the model is called is returned as a normal JSON error with an HTTP status, not as a stream event. - Set explicit timeouts and reconnect a streamed response safely.```text data: {"id":"chatcmpl-example","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":"Retry"},"finish_reason":null}]} data: {"id":"chatcmpl-example","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" with backoff"},"finish_reason":null}]} data: {"id":"chatcmpl-example","object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]} data: [DONE] ```## Errors| Error or symptom | Cause | Fix | | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | | `content` is empty and `finish_reason` is `length` | A reasoning model used the whole `max_tokens` budget on reasoning. | Raise `max_tokens`, within the model max output. | | `402 insufficient_credits` | Balance below the price of the request, often because `max_tokens` is very large. | Top up, or lower `max_tokens`. | | `403 forbidden` | The account is on free credit and the model is not on the free list, or the model is outside the key's group. | Top up, use a free model, or use a key whose group can reach the model. | | `404 not_found` | Unknown model ID, or not enabled for this key. | List the enabled models with `GET /v1/models`. | | `429 rate_limit_exceeded` | Account or free-model limit reached. | Wait `Retry-After`, then retry. |### HTTP errors at a glanceAuthentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).| HTTP status | Code | What to do | | ----------- | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------- | | 400 | `bad_request`, `content_policy_violation` | Fix the request or the input; do not resend it unchanged. | | 401 | `missing_api_key`, `invalid_api_key` | Check the key. Do not retry. | | 402 | `insufficient_credits` | Top up, or raise the key's limit. A very large `max_tokens` can trigger it. | | 403 | `forbidden` | The model is outside the key's group or IP allowlist, or free credit cannot call this model. | | 404 | `not_found` | Unknown model: list the enabled ones with `GET /v1/models`. | | 429 | `rate_limit_exceeded` | Wait `Retry-After` or `retry_after_seconds`, then retry with backoff. | | 500 | `internal_error`, `temporary_error` | Retry once or twice with backoff. | | 503 | `model_unavailable`, `upstream_timeout`, `temporary_error` | Retry with backoff, or use another model. |Full code table and retry policy: [Errors](/errors#text-endpoints).## Notes- Muse also answers on [OpenAI Responses](/text-api/muse/responses) and [Anthropic Messages](/text-api/muse/messages). - `muse-wonder` requires a funded account. An account that only holds free credit cannot call it. - Muse Wonder reasons before it answers. Reasoning counts as output tokens and is billed as output. - Send images as `image_url` content parts in `messages[].content`. - Keep API keys on trusted servers, log the response request ID, and retry only `429`, `500` and `503`. Reference: https://docs.beatapi.io/api-reference/text-api/muse-chat-completions ## Authentication - `Authorization` header (bearer token, required) — Send your API key as `Authorization: Bearer `. ## Servers - `https://direct.beatapi.io` (Direct, default) - `https://api.beatapi.io` (API) ## Request ### Body (application/json) This endpoint expects an object. - `model` (enum, required) — The exact model ID. Each ID is a separate model, not an alias of another. Call `GET /v1/models` with your key to confirm which models are enabled for it. `muse-wonder` - Allowed values: `muse-wonder` - `messages` (list of V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItems, required) — The conversation, oldest message first. Each message has a `role` (`system`, `user`, `assistant` or `tool`) and `content`. - `max_tokens` (integer, optional) — Upper bound on the generated tokens, reasoning included. The gateway does not compare your value with the model's max output from the table above. Keep it at or below that number. `max_tokens` is also used to estimate how much balance a request needs. A very large value can be refused with `402 insufficient_credits` even when the real output would be small. Set it to what you need. A reasoning model writes its reasoning first. If `max_tokens` is too small, the reasoning can use all of it: `content` comes back empty and `finish_reason` is `length`. Leave room for both, and raise the value when you see `length`. - `stream` (boolean, optional, default: false) — Return the answer as server-sent events. See the Streaming section below. - `temperature` (double, optional) — Sampling temperature. Change this or `top_p`, not both. - `top_p` (double, optional) — Nucleus sampling threshold. - `stop` (V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaStop, optional) — One or more sequences at which generation stops. - `tools` (list of V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaToolsItems, optional) — Function definitions the model may call. The model answers with `tool_calls`; return each result in a following `tool` message that carries the matching `tool_call_id`. - `tool_choice` (V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaToolChoice, optional) — Whether the model may, must or must not call a tool. Test the value you rely on with your model. ## Response ### 200 A non-streaming call returns one JSON object. This is an abbreviated example. - `id` (string, optional) — The completion ID. Log it, together with the request ID, for support and billing audits. - `model` (string, optional) — The model that answered. - `choices` (list of V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItems, optional) - `usage` (V1ChatCompletionsPostResponsesContentApplicationJsonSchemaUsage, optional) — Token counts. Calls are metered from actual token usage. ## Errors ### 400 Bad Request Error `bad_request`, `content_policy_violation` Fix the request or the input; do not resend it unchanged. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 401 Unauthorized Error `missing_api_key`, `invalid_api_key` Check the key. Do not retry. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 402 Payment Required Error `insufficient_credits` Top up, or raise the key's limit. A very large `max_tokens` can trigger it. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 403 Forbidden Error `forbidden` The model is outside the key's group or IP allowlist, or free credit cannot call this model. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 404 Not Found Error `not_found` Unknown model: list the enabled ones with `GET /v1/models`. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 429 Too Many Requests Error `rate_limit_exceeded` Wait `Retry-After` or `retry_after_seconds`, then retry with backoff. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 500 Internal Server Error `internal_error`, `temporary_error` Retry once or twice with backoff. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ### 503 Service Unavailable Error `model_unavailable`, `upstream_timeout`, `temporary_error` Retry with backoff, or use another model. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints). - `map from string to any` ## Types ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItems - `role` (string, required) - `content` (V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItemsContent, optional, nullable) - `name` (string, optional) - `tool_call_id` (string, optional) - `tool_calls` (list of V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItemsToolCallsItems, optional) ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaStop One or more sequences at which generation stops. ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaToolsItems ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaToolChoice Whether the model may, must or must not call a tool. Test the value you rely on with your model. ### V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItems - `message` (V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItemsMessage, optional) - `finish_reason` (string, optional) — `stop` for a complete answer, `tool_calls` for a tool request, `length` when `max_tokens` was reached. ### V1ChatCompletionsPostResponsesContentApplicationJsonSchemaUsage Token counts. Calls are metered from actual token usage. ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItemsContent ### V1ChatCompletionsPostRequestBodyContentApplicationJsonSchemaMessagesItemsToolCallsItems ### V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItemsMessage - `content` (string, optional) — The answer text. - `reasoning_content` (string, optional) — The reasoning text, on models that reason. It is billed as output. - `tool_calls` (list of V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItemsMessageToolCallsItems, optional) — Function calls the model asks you to run. Present when `finish_reason` is `tool_calls`. ### V1ChatCompletionsPostResponsesContentApplicationJsonSchemaChoicesItemsMessageToolCallsItems ## Examples **Request** ```json { "model": "muse-wonder", "messages": [ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ], "max_tokens": 2000 } ``` **Response** ```json { "id": "chatcmpl-example", "model": "muse-wonder", "choices": [ { "message": { "content": "Retry with exponential backoff and jitter, and make every handler idempotent.", "role": "assistant" }, "finish_reason": "stop", "index": 0 } ], "usage": { "completion_tokens": 16, "prompt_tokens": 19, "total_tokens": 35 }, "created": 1791993600, "object": "chat.completion" } ``` **SDK Code** ```python Quick start import requests url = "https://direct.beatapi.io/v1/chat/completions" payload = { "model": "muse-wonder", "messages": [ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ], "max_tokens": 2000 } headers = { "Authorization": "Bearer ", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.json()) ``` ```javascript Quick start const url = 'https://direct.beatapi.io/v1/chat/completions'; const options = { method: 'POST', headers: {Authorization: 'Bearer ', 'Content-Type': 'application/json'}, body: '{"model":"muse-wonder","messages":[{"role":"user","content":"Design a resilient webhook retry strategy for a payments API."}],"max_tokens":2000}' }; try { const response = await fetch(url, options); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } ``` ```go Quick start package main import ( "fmt" "strings" "net/http" "io" ) func main() { url := "https://direct.beatapi.io/v1/chat/completions" payload := strings.NewReader("{\n \"model\": \"muse-wonder\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Design a resilient webhook retry strategy for a payments API.\"\n }\n ],\n \"max_tokens\": 2000\n}") req, _ := http.NewRequest("POST", url, payload) req.Header.Add("Authorization", "Bearer ") req.Header.Add("Content-Type", "application/json") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := io.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```ruby Quick start require 'uri' require 'net/http' url = URI("https://direct.beatapi.io/v1/chat/completions") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true request = Net::HTTP::Post.new(url) request["Authorization"] = 'Bearer ' request["Content-Type"] = 'application/json' request.body = "{\n \"model\": \"muse-wonder\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Design a resilient webhook retry strategy for a payments API.\"\n }\n ],\n \"max_tokens\": 2000\n}" response = http.request(request) puts response.read_body ``` ```java Quick start import com.mashape.unirest.http.HttpResponse; import com.mashape.unirest.http.Unirest; HttpResponse response = Unirest.post("https://direct.beatapi.io/v1/chat/completions") .header("Authorization", "Bearer ") .header("Content-Type", "application/json") .body("{\n \"model\": \"muse-wonder\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Design a resilient webhook retry strategy for a payments API.\"\n }\n ],\n \"max_tokens\": 2000\n}") .asString(); ``` ```php Quick start request('POST', 'https://direct.beatapi.io/v1/chat/completions', [ 'body' => '{ "model": "muse-wonder", "messages": [ { "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." } ], "max_tokens": 2000 }', 'headers' => [ 'Authorization' => 'Bearer ', 'Content-Type' => 'application/json', ], ]); echo $response->getBody(); ``` ```csharp Quick start using RestSharp; var client = new RestClient("https://direct.beatapi.io/v1/chat/completions"); var request = new RestRequest(Method.POST); request.AddHeader("Authorization", "Bearer "); request.AddHeader("Content-Type", "application/json"); request.AddParameter("application/json", "{\n \"model\": \"muse-wonder\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Design a resilient webhook retry strategy for a payments API.\"\n }\n ],\n \"max_tokens\": 2000\n}", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```swift Quick start import Foundation let headers = [ "Authorization": "Bearer ", "Content-Type": "application/json" ] let parameters = [ "model": "muse-wonder", "messages": [ [ "role": "user", "content": "Design a resilient webhook retry strategy for a payments API." ] ], "max_tokens": 2000 ] as [String : Any] let postData = JSONSerialization.data(withJSONObject: parameters, options: []) let request = NSMutableURLRequest(url: NSURL(string: "https://direct.beatapi.io/v1/chat/completions")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "POST" request.allHTTPHeaderFields = headers request.httpBody = postData as Data let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error as Any) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ```