Available Models

The OpenAI-compatible API provides access to 19 models from Anthropic, Amazon, Meta, OpenAI, Qwen, NVIDIA, and Moonshot AI. Every model listed on this page is available through the API.

The tables below give the facts you need to pick one: context window, supported input types, and reasoning support. Context windows are the values published on the corresponding Amazon Bedrock model cards.

Image input means the model accepts JPEG, PNG, GIF, and WebP images. Document input means the model accepts file attachments (PDF, CSV, DOC, DOCX, XLS, XLSX, HTML, TXT, MD). Reasoning means the model is listed as reasoning-capable. You ask for reasoning with reasoning_effort; see Reasoning Mode.

Table of Contents

Capability Cards

How to use this: if you rely on temperature, top_p or top_k to change a model’s output, check the sampling parameter table first. The OpenAI-compatible endpoint accepts all three on every model and returns 200, but on some models a setting is accepted and has no effect. 7 of the 19 models drop all three. The verdicts were measured by composing the real request for each model and asking the endpoint’s own parameter check which of the three arrived as sent. On 8 models — every Claude model — sending reasoning_effort applies temperature as 2.0 whatever you sent. When a setting does not arrive as sent, the response says so in the X-Parameter-Notice header, and X-Reasoning-Notice reports what a request did with reasoning_effort; see Response Headers.

Per-model cards

Hover, focus or tap a model to open its card, and press Escape to close it. The verdict words on each card are defined under Sampling parameter support.

Every fact on a card also appears in a table on this page, so nothing here is reachable only by hovering. That duplication is deliberate: with JavaScript disabled a card can be revealed by hover or keyboard focus but is not announced as a disclosure, so the tables are the accessible route to the same facts.

Context windows are the values published on the corresponding Amazon Bedrock model cards. Models are listed in platform catalog order. Output is capped at 64,000 tokens per request for every model, so a larger max_tokens is rejected whichever model you pick.

Document input — whether a model accepts file attachments — is supported by 12 of the 19 models. The remaining 7 do not accept file attachments: amazon-nova-micro, moonshotai-kimi-k3, nvidia-nemotron-super-3-120b, openai-gpt-6-luna, openai-gpt-oss-120b, openai-gpt-oss-20b, qwen3-32b.

Sampling parameter support

What the three settings do:

temperature

Controls how random or varied the output is. Sent as a number from 0.0 to 2.0.

top_p

Limits the model to the most likely words whose probabilities add up to this fraction. Sent as a number from 0.0 to 1.0.

top_k

Limits the model to its K most likely words. Sent as a whole number, 0 or more.

The last column, With reasoning_effort, shows the same three settings on a request that also carries reasoning_effort (low, medium or high). For some models, adding it changes the result.

Each cell holds one verdict. A verdict records what was observed on the composed request, not why. The examples use the values the measurement sent.

Honored

The value you send is the value applied. Send temperature 0.5 and 0.5 is applied.

Ignored

The request still succeeds, but this setting is not applied, so changing it has no effect. Send top_k 200 or top_k 5 and neither is applied.

Clamped to 128

Values above 128 are applied as 128; values of 128 or less are applied as sent. Send top_k 200 and 128 is applied; send top_k 5 and 5 is applied.

Forced to 2.0

2.0 is applied whatever you send. Send temperature 1.0 or temperature 0.5 and 2.0 is applied.

Unchanged from default

Last column only. With reasoning_effort set, the three settings have the same verdicts as in the first three columns.

Reasoning not applied

Last column only. When a request to this model carries reasoning_effort, the request composed for the model does not ask it to reason. The three settings then have the same verdicts as in the first three columns. The X-Reasoning-Notice response header reports this on each request; see Response Headers.

Claude Models (Anthropic)

All eight Claude models accept text, images, and documents, and all support reasoning mode.

Amazon Nova Models

Amazon’s own models. None of them support reasoning mode.

Llama Models (Meta)

Open-weight mixture-of-experts models with the largest context windows available here. Neither supports reasoning mode.

Both Llama 4 models are marked Legacy in their Amazon Bedrock lifecycle, with an end-of-life date of March 30, 2027. Prefer a currently active model for new work.

OpenAI Models

All three support reasoning mode. The two gpt-oss models are open-weight and text-only.

Other Models

None of these three accept document attachments. For qwen3-32b, the sampling parameter table reports Reasoning not applied when a request carries reasoning_effort, although the table below lists the model as reasoning-capable.

Choosing the Right Model

Model quality depends on your prompts and your task, so rather than rank the models we list the properties you can filter on. Start from the constraint that actually binds you, then pick from the models that satisfy it.

By constraint

• Largest context: llama-4-scout-17b-instruct (10M). Ten other models offer 1M: seven of the eight Claude models, llama-4-maverick-17b-instruct, openai-gpt-6-luna, and moonshotai-kimi-k3.
• Needs image input: all eight Claude models, amazon-nova-pro, amazon-nova-lite, llama-4-scout-17b-instruct, moonshotai-kimi-k3, and openai-gpt-6-luna.
• Needs document attachments: all eight Claude models, amazon-nova-pro, amazon-nova-lite, and both Llama 4 models.
• Needs reasoning mode: thirteen of the 19 models are listed as reasoning-capable — see Reasoning Mode. For qwen3-32b the sampling parameter table reports Reasoning not applied.
• Needs temperature to take effect: 12 of the 19 models honor it — the three Amazon Nova models, both Llama 4 models, qwen3-32b, both gpt-oss models, nvidia-nemotron-super-3-120b, claude-v4.5-haiku, claude-v4.6-sonnet, and claude-v4.6-opus. The other seven ignore it.
• Needs top_p to take effect: nine models honor it — the three Amazon Nova models, both Llama 4 models, qwen3-32b, both gpt-oss models, and nvidia-nemotron-super-3-120b. No Claude model honors top_p.
• Needs top_k to take effect: six models — claude-v4.5-haiku, claude-v4.6-sonnet and claude-v4.6-opus honor it as sent; the three Amazon Nova models clamp it to 128.
• Needs sampling control and reasoning mode: with reasoning_effort set, both gpt-oss models still honor temperature and top_p. No Claude model does — with reasoning_effort set, every Claude model applies temperature as 2.0 whatever you sent and ignores top_p and top_k. See Sampling parameter support for every model.

Reasonable defaults

Reasoning Mode

On the OpenAI-compatible endpoint you ask for reasoning with the reasoning_effort request field: "low", "medium" or "high". Any other value, including OpenAI’s "minimal", is rejected with 422. See the OpenAI API Reference for the full request fields.

What a request did with reasoning_effort is reported in the X-Reasoning-Notice response header; see Response Headers.

Models listed as reasoning-capable

Thirteen of the 19 models are listed as reasoning-capable:

• claude-v5.5-opus
• claude-v5-opus
• claude-v4.6-opus
• claude-v5.5-sonnet
• claude-v5-sonnet
• claude-v4.6-sonnet
• claude-v5.5-haiku
• claude-v4.5-haiku
• openai-gpt-6-luna
• openai-gpt-oss-120b
• openai-gpt-oss-20b
• moonshotai-kimi-k3
• qwen3-32b

The three Amazon Nova models, both Llama 4 models, and nvidia-nemotron-super-3-120b are not listed as reasoning-capable. For these six models, and for qwen3-32b, the last column of the sampling parameter table reports Reasoning not applied: the request composed for the model does not ask it to reason.

The two gpt-oss models reason on every request. If you send no reasoning_effort to one of them, the endpoint chooses a level for you.

Example Request

from openai import OpenAI

client = OpenAI(
    base_url="YOUR_BASE_URL",
    api_key="your-api-key",
)

response = client.chat.completions.create(
    model="claude-v5.5-opus",
    messages=[
        {"role": "user", "content": "Solve this complex problem step by step"}
    ],
    reasoning_effort="medium",
)
print(response.choices[0].message.content)

The response is a standard chat completion, as shown in the OpenAI API Reference.

Model Selection Example

One client, a different model per task. temperature is sent only to models that honor it; see Sampling parameter support.

from openai import OpenAI

client = OpenAI(
    base_url="YOUR_BASE_URL",
    api_key="your-api-key",
)

def ask(model, prompt, **options):
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        **options,
    )
    return response.choices[0].message.content

# For the hardest analysis tasks (claude-v5.5-opus ignores temperature)
def analyze_with_opus(text):
    return ask("claude-v5.5-opus", text)

# For quick customer service responses
def quick_response(text):
    return ask("claude-v5.5-haiku", text, max_tokens=500)

# For creative writing (claude-v4.6-sonnet honors temperature, 0.0 to 2.0)
def creative_writing(prompt):
    return ask("claude-v4.6-sonnet", prompt, temperature=1.4)

# For high-volume classification
def classify(text):
    return ask("amazon-nova-micro", text, temperature=0.0, max_tokens=16)