API support matrix

What each Sail inference API supports today, and what’s coming soon

Sail provides inference endpoints compatible with the OpenAI Responses API, the OpenAI Chat Completions API, and the Anthropic Messages API. All three inference APIs accept the same models and completion windows.

Sail also offers a Batch API for running large numbers of Responses API requests efficiently in one asynchronous job.

API	Endpoint	Maturity
OpenAI Responses	POST /v1/responses	Stable
OpenAI Chat Completions	POST /v1/chat/completions	Stable
Anthropic Messages	POST /v1/messages	Beta
Batch	POST /v1/batches	Stable

---

Responses API

RecommendedOpenAI SDK compatible

API reference →

Supported features

Feature	Details
Core parameters	model, input (string or message array), max_output_tokens, temperature, top_p, user, prompt_cache_key
Instructions	instructions is prepended to the input as a system message.
Structured outputs	text.format with type: "text" or type: "json_schema"
Reasoning	reasoning.effort (none / minimal / low / medium / high / xhigh / max; max selects the same top tier as xhigh), reasoning.generate_summary (auto / concise / detailed)
Function tools	tools with type: "function" (client-side function calling with name, description, parameters, strict)
Custom tools	Custom tools (tools with type: "custom") are unavailable on asap. Setting metadata.completion_window: "asap" on a request with a custom tool will return HTTP 400 with error code unsupported_asap_request.
Tool choice	tool_choice: "none", "auto", "required", or a specific function/custom tool
Background mode	background: true works with balanced and flex. Setting metadata.completion_window: "asap" on a background request will return HTTP 400 with error code unsupported_asap_request. Accepted requests return 202. Retrieve the result by polling GET /v1/responses/{id} or using a webhook.
Streaming	stream: true on foreground requests returns Server-Sent Events using OpenAI Responses event names.
Prompt cache routing	prompt_cache_key is an optional routing hint for requests that share a large prompt prefix
Supercache	metadata.supercache_write stores a reusable prompt prefix for 24 hours. Matching reads are automatic.
Image input	input_image content blocks on multimodal models. Non-multimodal models accept text only.
Video input	input_video content blocks on models that declare video input support. The video_url value can be a URL string or an object with url and model-specific controls.
PDF input	input_file content blocks with the PDF inline in file_data, for example data:application/pdf;base64,.... Works on every model. See PDF input.
Output logprobs	include: ["message.output_text.logprobs"] returns per-token logprobs. Set top_logprobs (0-20, default 0) to also get the highest-scoring alternative tokens at each position. It requires the include opt-in. Larger values return HTTP 400 with error code invalid_value.

Prompt cache routing

For Responses and Chat Completions, reuse the same prompt_cache_key on requests to the same model that share a prompt prefix. This routing hint also applies to ASAP requests, with or without streaming. Available capacity and current load can override the hint, so it does not guarantee a cache hit.

Supercache usage

When Supercache accounting data is available, completed Responses include metadata.supercached_input_tokens and metadata.supercache_write_input_tokens as decimal strings. Both fields are included when their value is zero. usage.input_tokens_details.cached_tokens includes tokens read from Supercache. Both metadata keys are reserved and cannot be set in a request.

Response status and output validation

Treat completed, incomplete, failed, and cancelled as terminal statuses when polling a background response.

• completed means the response finished normally.
• incomplete means generation stopped early. A reason of "max_output_tokens" is Sail’s normalized truncation/cap reason: it is reported whenever generation stops because of a length-based limit, such as the request’s max_output_tokens, the model’s context window, or another provider length signal. It does not by itself prove the request’s output limit alone was reached. A reason of "content_filter" means generation stopped because of a content filter. When present, usage is preserved. A response limited by max_output_tokens can include partial output. Tokens reported in usage are billed normally. An incomplete response is not an API error.
• failed includes generations that Sail rejects because the result does not satisfy the request after its retry attempts are exhausted. A request with tool_choice: "required" can fail with error.code: "server_error" and the message "The model did not return a tool call required by the request." A generation with no visible text, refusal, or tool call can fail with error.code: "server_error" and the message "The model did not return visible text, a refusal, or a tool call." instead of returning an empty completed response.
• cancelled means no further output will be produced.

Sail cannot currently guarantee tool_choice: "required" for openai/gpt-oss-* models. Choose another model when every successful response must contain a tool call.

Not yet supported

Feature	Notes
Conversation chaining	previous_response_id and conversation are not supported. Send the full input each request.
Prompt templates	The prompt parameter is not supported.
Server-side tools	web_search, web_search_preview, and image_generation tools are accepted for OpenAI-client compatibility and removed from the request. The model has no such tool to call. file_search, code_interpreter, computer_use, mcp, shell, and apply_patch are not supported.
Multimodal input	Audio input blocks are not supported. File input is supported only as an inline PDF (see above). Image and video input are supported on models that declare those input modalities.
Include	Accepted for compatibility when it is an array of strings. reasoning.encrypted_content is accepted for OpenAI-client compatibility, but reasoning items are returned without encrypted content. Requests that include web_search_call.action.sources, code_interpreter_call.outputs, computer_call_output.output.image_url, or file_search_call.results are rejected.
Truncation	Only "disabled" is accepted. Custom truncation strategies are not supported.
Parallel tool calls	parallel_tool_calls is accepted for compatibility. Models decide their own tool-call cadence, so the field has no effect.
json_object format	text.format.type: "json_object" is not supported. Use "json_schema" instead.
Service tier	Only "auto" is accepted. Use metadata.completion_window to control response timing instead.
Delete / cancel	DELETE /v1/responses/{id} and cancel endpoints are not implemented.

---

Chat Completions API

OpenAI SDK compatible

API reference →

Supported features

Feature	Details
Core parameters	model, messages, max_completion_tokens, temperature, top_p, user, prompt_cache_key
Message roles	system, user, assistant, tool, function (deprecated), developer
Structured outputs	response_format with type: "text", "json_object", or "json_schema"
Reasoning	reasoning_effort (none / minimal / low / medium / high / xhigh / max; max selects the same top tier as xhigh)
Function tools	tools with type: "function" (standard {type, function: {name, description, parameters, strict}} format)
Custom tools	Custom tools (tools with type: "custom") are unavailable on asap. Setting metadata.completion_window: "asap" on a request with a custom tool will return HTTP 400 with error code unsupported_asap_request.
Tool choice	tool_choice: "none", "auto", "required", or a specific function/custom tool
Parallel tool calls	parallel_tool_calls is passed through
Metadata	metadata with string key-value pairs, including completion_window and completion_webhook
Prompt cache routing	prompt_cache_key is an optional routing hint for requests that share a large prompt prefix
Supercache	metadata.supercache_write stores a reusable prompt prefix for 24 hours. Matching reads are automatic.
Streaming	stream: true returns Server-Sent Events (chat.completion.chunk). stream_options.include_usage adds a final usage chunk. Reasoning uses reasoning_content deltas.
Image input	image_url content parts on multimodal models. Non-multimodal models accept text only.
Video input	video_url content parts on models that declare video input support. URL objects and model-specific controls such as num_frames and fps are preserved.
PDF input	file content parts with the PDF inline in file.file_data. Works on every model. See PDF input.

Not yet supported

Feature	Notes
Multiple choices	n must be 1.
Multimodal content	Audio (input_audio) content parts are not supported. file parts are supported only when they carry an inline PDF in file.file_data (see above).
Sampling controls	frequency_penalty, presence_penalty, logit_bias, stop, seed, top_logprobs, logprobs, verbosity are not supported.
Audio modality	audio and modalities: ["audio"] are not supported.
Predicted output	prediction is not supported.
Web search	web_search_options is not supported.
Service tier	Only "auto" is accepted.
CRUD endpoints	GET, POST, DELETE on stored completions are not implemented.
Deprecated fields	max_tokens, functions, function_call are rejected. Use their modern replacements.

Response notes

• Responses always contain exactly one choice (n=1).
• finish_reason reflects the provider result when available, including "stop", "tool_calls", "length", and "content_filter".
• system_fingerprint and service_tier are not included in responses.
• logprobs is always null.

---

Messages API

Anthropic Messages formatAnthropic SDK compatible

API reference →

The Messages API is Anthropic-compatible for agentic use: system prompts, tool calling, and streaming (SSE) are supported. Prompt caching is automatic, so you don’t need cache_control breakpoints.

Supported features

Feature	Details
Core parameters	model, max_tokens, messages
System prompt	The top-level system parameter (string or array of text blocks)
Sampling	temperature (0 to 1), top_p (0 to 1)
Tools	tools and tool_choice ("auto", "any", "tool", "none"). The model calls tools; responses include tool_use blocks, and text tool_result blocks round-trip. Tool results with is_error: true retain an error signal for the model.
Extended thinking	thinking is translated to the model’s reasoning
Streaming	stream: true returns Anthropic Server-Sent Events (message_start, content_block_delta, message_stop, …) as output becomes available. Some request types deliver content only after completion.
Structured outputs	output_config.format with type: "json_schema"
Metadata	metadata with string key-value pairs, including completion_window and completion_webhook
Image input	image content blocks on multimodal models. Non-multimodal models accept text only.
PDF input	document content blocks with a base64 source and media_type: "application/pdf", including inside tool_result. Works on every model. See PDF input.
Request routing	routing.allowed_countries: ["US"] restricts that request to United States capacity. US-only inference is available on Pro and Enterprise.
Token counting	POST /v1/messages/count_tokens returns the request’s input token count without running the model
Prompt caching	Automatic, by prompt prefix, as on every Sail API. cache_control is accepted at the top level and on content blocks, and has no effect. Cache reads are reported in usage.cache_read_input_tokens and billed at the cached input rate (see Pricing).

Not yet supported

Feature	Notes
Stop sequences	stop_sequences is not supported.
Top-K sampling	top_k is not supported.
Multimodal content	document blocks with a url, file, text, or content source are not supported. Image input is supported on multimodal models (see above).
Tool result images	Images inside tool_result are replaced with [Image omitted: Sail does not yet support images inside tool results.]. The request still succeeds.
Redacted thinking	Replayed redacted_thinking blocks are accepted so conversations can continue, but the opaque reasoning is not forwarded to the model.
Service tier	service_tier is not supported.
Inference geo	inference_geo is not supported.
Batches	POST /v1/messages/batches and related endpoints are not implemented.

Response notes

• stop_reason reflects the outcome. Sail returns "end_turn" normally, "tool_use" for tool calls, "max_tokens" for token limits, and "refusal" when the provider reports a refusal. Sail returns "model_context_window_exceeded" when the provider reports that the model’s context window was exceeded.
• Responses contain text content blocks, plus tool_use blocks when the model calls a tool.
• usage follows Anthropic’s accounting. input_tokens counts only the part of the prompt that was not read from cache, and cache_read_input_tokens counts the part that was. The full prompt is their sum. cache_creation_input_tokens is always 0: Sail has no separate charge for writing the cache, so every uncached prompt token is in input_tokens.
• Thinking output does not include an Anthropic cryptographic signature. thinking.budget_tokens is approximated as medium reasoning effort unless output_config.effort provides an explicit effort.
• thinking.type: "disabled" uses the selected model’s none reasoning control. Sail returns 400 when the selected model does not support disabling reasoning. The exact effect follows that model’s none contract, so disabled does not bypass a model-specific lowest-effort approximation. output_config.effort overrides the effort level. A non-disabling override preserves thinking output requested by thinking.type: "enabled" or "adaptive". An effort whose model mapping disables reasoning can remove it.
• When reasoning is present, Messages content begins with a thinking block before the text block. Select content by block type rather than assuming content[0] is text. The Chat Completions response exposes the same reasoning through reasoning_content.
• Token counting applies the same replay-block policy as message creation: redacted thinking is omitted and tool-result images count as the replacement text marker.

Compatibility notes

• Sail accepts both the Anthropic x-api-key header and Authorization: Bearer <key>. If both are present, Authorization takes precedence.

Python

from anthropic import Anthropic

client = Anthropic(
    api_key="YOUR_SAIL_API_KEY",
    base_url="https://api.sailresearch.com",
)

• The Anthropic Python and TypeScript SDKs type metadata with only user_id. Sail also accepts completion_window. Keep the additional cast or type assertion scoped to the metadata value:

from typing import cast

from anthropic.types import MetadataParam

metadata = cast(MetadataParam, {"completion_window": "balanced"})

metadata: {
  completion_window: "balanced",
} as Anthropic.Messages.Metadata & { completion_window: string },

• The anthropic-version header is not required or checked.
• Errors use the Anthropic envelope {"type":"error","error":{"type":"...","message":"..."},"request_id":"..."} and Anthropic error types such as invalid_request_error, rate_limit_error, and overloaded_error.

---

Batch API

The Batch API runs large numbers of Responses API requests asynchronously. Every item targets /v1/responses. Batching /v1/chat/completions or /v1/messages is not currently supported. You can submit up to 100,000 requests in one POST /v1/batches call, then poll GET /v1/batches/{id} for progress and inline results when the batch finishes. For batches above the inline size limit, fetch results by custom_id.

See Sending requests at scale for the end-to-end workflow and the Batch API reference for the request and response schemas.

---

Cross-API behavior

These behaviors apply across the inference API surfaces:

• Streaming: The Chat Completions API supports stream: true, returning Server-Sent Events (chat.completion.chunk). Set stream_options.include_usage for a final usage chunk. The Messages API supports stream: true, returning Anthropic SSE events as output becomes available. The Responses API supports foreground stream: true, returning OpenAI Responses SSE events. Accepted background requests return 202 immediately and cannot be streamed. Use polling or webhooks for long-running background work. A queued foreground request can stream once generation starts. Some request types deliver content only after completion. Streaming does not yet continue across a failed execution attempt.
• Completion windows: Express latency tolerance in exchange for lower token costs. See Flex request requirements and Pricing.
• Context windows: For each text request, Sail reserves at least 512 tokens, or 0.5% on larger windows, from the model’s published context window. The input token count plus the requested maximum output must fit in the remaining budget. This allowance covers model-specific request formatting that can add tokens when the request runs. On the non-batch Responses endpoint (POST /v1/responses), requests that provide raw_prompt_tokens skip text formatting and use the exact raw-token count without this reserve, requiring the raw token count plus max_output_tokens to fit within the model’s context window. The Batch API does not yet apply this raw_prompt_tokens admission arithmetic.
• Webhooks: Set metadata.completion_webhook to receive a POST when processing finishes. See Webhooks.
• Response storage: store: false is accepted for OpenAI compatibility, but does not change Sail’s normal temporary request/response storage for processing, retries, polling, and idempotency. Customer Data remains governed by Sail’s DPA retention and deletion terms.

PDF input

Sail reads the text of each page of a PDF and sends that text to the model in place of the file. PDF input therefore works on every model, including models that accept only text. The model does not see page images, so charts, figures, and scanned pages are not visible to it.

Each page’s text is labeled with its page number. When the request includes a filename (Responses and Chat Completions) or title (Messages), the PDF is labeled with it as well. The extracted text counts toward input tokens and the model’s context window, and token counting endpoints count it the same way.

These requests are rejected with HTTP 400:

• A password-protected PDF.
• A PDF with no text layer, such as a scanned document. Send its pages as images to a multimodal model instead.
• A PDF with more than 1,000 pages.
• More than 50 MB of PDF files in one request.
• More than 16 MB of extracted text in one request.
• A PDF referenced by file ID or URL. Send the file inline as base64.
• Any file input in a Batch API request.