# Create custom voice
Source: https://docs.aireserve.com/api-reference/audio/create-custom-voice

/api-reference/openapi.json post /v1/custom-voices
Create a custom voice clone from reference audio (`multipart/form-data`). Required fields: `name`, `language`, `file` (audio upload, max 31 MB / 120 s), `consent_attestation=true`. Requires `customVoicesEnabled` org gate and an xAI Enterprise contract. US only, except Illinois. Creation is subject to the shared xAI team capacity.



# Delete custom voice
Source: https://docs.aireserve.com/api-reference/audio/delete-custom-voice

/api-reference/openapi.json delete /v1/custom-voices/{voice_id}
Delete a custom voice. Removes the voice model from xAI and soft-deletes the AI Reserve ownership record. Subsequent TTS or realtime session calls referencing this voice ID return `404`. Idempotent — an xAI 404 is treated as a successful delete.



# Get custom voice
Source: https://docs.aireserve.com/api-reference/audio/get-custom-voice

/api-reference/openapi.json get /v1/custom-voices/{voice_id}
Read the live upstream state of a custom voice owned by your organization. Returns `404` for unknown IDs and for IDs owned by other organizations — voice existence is never confirmed cross-tenant.



# List built-in voices
Source: https://docs.aireserve.com/api-reference/audio/list-built-in-voices

/api-reference/openapi.json get /v1/voices
Returns the catalog of built-in text-to-speech voices across both providers: the xAI voices (`provider: "grok"`, for `grok-tts`) and the ElevenLabs library (`provider: "elevenlabs"`, for the `eleven-*` models). Each voice lists the `models` it can be synthesized with. Available to all callers — no org gate required. Each provider's list is cached server-side for 5 minutes and a stale catalog is served during an upstream outage rather than an error; an outage at one provider never hides the other's voices. Use the returned `voice_id` values (or, for ElevenLabs, the voice `name`) in `POST /v1/audio/speech` or `POST /v1/realtime/sessions`.



# List custom voices
Source: https://docs.aireserve.com/api-reference/audio/list-custom-voices

/api-reference/openapi.json get /v1/custom-voices
List custom voice clones owned by your organization. Requires the `customVoicesEnabled` org gate. Served from AI Reserve's ownership map — voices belonging to other organizations are never visible regardless of their xAI voice ID.



# Synthesize speech
Source: https://docs.aireserve.com/api-reference/audio/synthesize-speech

/api-reference/openapi.json post /v1/audio/speech
Synthesize speech from text. Models: `grok-tts` (xAI; max 4,096 characters, `mp3` only) and the ElevenLabs models `eleven-v4` (10,000 characters), `eleven-v3` (5,000), `eleven-multilingual-v2` (10,000) and `eleven-flash-v2-5` (40,000), which also accept `opus`, `pcm` and `wav` output and a `speed` of 0.7–1.2. Synchronous — returns raw audio bytes (`audio/mpeg` by default). Billed per Unicode code point at the model's rate. Use a built-in voice ID or ElevenLabs voice name from `GET /v1/voices`, or a custom voice ID from `GET /v1/custom-voices` (custom voices are `grok-tts` only).



# Transcribe audio
Source: https://docs.aireserve.com/api-reference/audio/transcribe-audio

/api-reference/openapi.json post /v1/audio/transcriptions
Transcribe audio. `model` form field: scribe-v2 dispatches to ElevenLabs Scribe v2 via fal.ai; anything else (gpt-4o-mini-transcribe, the default) forwards the multipart to OpenAI verbatim



# Update custom voice
Source: https://docs.aireserve.com/api-reference/audio/update-custom-voice

/api-reference/openapi.json patch /v1/custom-voices/{voice_id}
Update metadata for a custom voice owned by your organization. At least one field must be provided. Patchable fields: `name`, `description`, `gender`, `accent`, `age`, `language`, `use_case`, `tone`.



# Converse (Bedrock wire format)
Source: https://docs.aireserve.com/api-reference/bedrock/converse-bedrock-wire-format

/api-reference/openapi.json post /model/{modelId}/converse
Bedrock Converse wire format for unmodified boto3 / AWS SDK clients. Accepts AI Reserve model IDs and supported AWS model ids / inference-profile ARNs.



# Converse stream (Bedrock wire format)
Source: https://docs.aireserve.com/api-reference/bedrock/converse-stream-bedrock-wire-format

/api-reference/openapi.json post /model/{modelId}/converse-stream
Bedrock ConverseStream wire format — responses are real AWS binary event streams (application/vnd.amazon.eventstream) with per-frame CRC32 checksums.



# Create chat completion
Source: https://docs.aireserve.com/api-reference/chat/create-chat-completion

/api-reference/openapi.json post /v1/chat/completions
OpenAI-compatible chat completions. Every gateway model — GPT, Claude, Gemini, Grok, and more — answers the same call; streaming responses are server-sent events terminated by `data: [DONE]`.



# Configuration
Source: https://docs.aireserve.com/api-reference/configuration

SDK configuration options — API key, base URL, timeouts, and retries — with consistent semantics everywhere.

| Option | Environment variable | Default |
| - | - | - |
| API key | `AIRESERVE_API_KEY` | — (required) |
| Base URL | `AIRESERVE_BASE_URL` | `https://api.aireserve.com` |
| Timeout (per attempt) | — | 120 s |
| Max retries | — | 2 (up to 3 attempts) |

> [!NOTE]
>
> SDK 0.6.0+ prefers the `AIRESERVE_*` names shown above and still honors the
> legacy `AUDACITY_API_KEY` / `AUDACITY_BASE_URL` variables, so existing setups
> keep working without changes.

Timeout semantics are consistent everywhere: the timeout bounds connection + headers (and,
for non-streaming `Converse`, the full body read). For `ConverseStream`
it applies only until headers arrive — **the stream body is never bounded**, so
long generations are never cut off mid-stream.

```python Python theme={"dark"}
client = Audacity(
    api_key="aireserve_api_…",
    base_url="https://api.aireserve.com",
    timeout=60.0,
    max_retries=3,
)
```

```typescript TypeScript theme={"dark"}
const client = new AudacityRuntimeClient({
  apiKey: "aireserve_api_...",
  baseUrl: "https://api.aireserve.com",
  timeoutMs: 30_000,
  maxRetries: 3,
});

// Every operation also accepts an abortSignal (AWS SDK v3 parity),
// which cancels an in-flight stream:
const aborter = new AbortController();
const { stream } = await client.send(
  new ConverseStreamCommand({ modelId, messages }),
  { abortSignal: aborter.signal },
);
```

```go Go theme={"dark"}
client := audacityruntime.New(audacityruntime.Options{
    APIKey:     "aireserve_api_…",         // falls back to AIRESERVE_API_KEY
    BaseURL:    "https://…",              // falls back to AIRESERVE_BASE_URL, then default
    HTTPClient: &http.Client{},           // custom transport / TLS config
    MaxRetries: 3,                        // audacityruntime.NoRetries disables retries
    Timeout:    60 * time.Second,         // audacityruntime.NoTimeout disables it
})

// If you provide a custom HTTPClient, leave its Timeout unset — an
// http.Client timeout bounds the whole body and would kill long streams.
```

```java Java theme={"dark"}
var client = AudacityRuntimeClient.builder()
    .apiKey("aireserve_api_…")
    .baseUrl("https://api.aireserve.com")
    .timeout(Duration.ofSeconds(60))
    .maxRetries(3)
    .build();
```

```rust Rust theme={"dark"}
use std::time::Duration;

let config = audacity_sdk::Config::builder()
    .api_key("aireserve_api_…")
    .base_url("https://api.aireserve.com")
    .timeout(Duration::from_secs(120))
    .max_retries(2)   // 3 total attempts
    .build()?;

let client = audacity_sdk::Client::new(&config)?;
```


# Customer keys
Source: https://docs.aireserve.com/api-reference/customer-keys

Mint an API key per end customer (and per customer organization) so spend splits per customer without per-request tagging. Create, list, and revoke them over the API.

A **customer key** is an AI Reserve API key that belongs to your organization but is bound to
one of **your** customers. Every request made with it is billed to you and reported under that
customer — the gateway stamps the customer id on the usage record itself, so the caller never
has to send `x-aireserve-customer` or `user`. Hand one to each customer (or to each integration
you run on a customer's behalf) and *Spend by Customer* splits on its own.

A customer key can also carry the customer's **organization / sub-account**. That makes it a
**sub key**: usage lands under the customer *and* that organization, so one customer who runs
several workspaces, regions, or business units gets a second level of split. Organization ids
mean whatever they mean in your product; AI Reserve treats them as opaque strings.

| | Customer key | Sub key |
| - | - | - |
| Bound to | one customer id | one customer id **and** one organization id |
| Reported as | `cust_8f3a2b` | `cust_8f3a2b › emea` |
| Created with | `POST /v1/customers/{customerId}/keys` | the same, with `org_id` in the body |

> [!NOTE]
>
> Customer keys are the recommended way to attribute spend when the requests are made by the
> customer's own systems. Keep the [per-request tags](/capabilities/customer-attribution) for
> traffic your own backend sends on behalf of many customers through one key. A customer key's
> binding always wins over a per-request tag; the optional `x-aireserve-feature` tag is still
> honored on both.

## Authentication

Call these endpoints with one of your organization's **own, organization-level** API keys —
the kind an enterprise admin creates on the portal's **Keys** page with scope *Organization*.
Other keys are refused with `403`:

| Key used | Result |
| - | - |
| Organization-level key | Allowed |
| Customer key or sub key | `403 customer_key_not_allowed` — a customer's key can never manage customers |
| Team key or personal key | `403 organization_key_required` |

The customer id in the path is URL-encoded, exactly as you want it reported — 1 to 128
printable characters, no control characters. Use the opaque id your own system uses for the
customer (`cust_8f3a2b`, a UUID, a tenant slug), never an email or a name: it appears in
Analytics, exports, and these responses.

Enterprise admins can create the same keys by hand on the Keys page: **Create key → One of
your customers**.

## Create a key

`POST /v1/customers/{customerId}/keys`

| Body field | Type | Notes |
| - | - | - |
| `name` | string, optional | 1–255 characters. Defaults to the customer id, or `<customer> › <org>` for a sub key. Names are unique among your organization's active keys. |
| `org_id` | string, optional | 1–128 printable characters. Makes the key a sub key for this organization of the customer. |

Returns `201` with the key object **plus `key`, the plaintext secret** — it is shown in this
response only. Store it before you respond to whatever asked for it; AI Reserve keeps only a
hash and cannot show it again.

```bash curl theme={"dark"}
# A key for the customer
curl -X POST "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Acme production"}'

# A sub key for one of the customer's organizations
curl -X POST "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"org_id": "emea"}'
```

```python Python theme={"dark"}
import os, requests
from urllib.parse import quote

BASE = "https://api.aireserve.com/v1/customers"
headers = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

customer_id = "cust_8f3a2b"
created = requests.post(
    f"{BASE}/{quote(customer_id, safe='')}/keys",
    json={"org_id": "emea"},
    headers=headers,
)
created.raise_for_status()
secret = created.json()["key"]  # shown once — store it now
```

```typescript TypeScript theme={"dark"}
const headers = {
  Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}`,
  "Content-Type": "application/json",
};

const customerId = "cust_8f3a2b";
const res = await fetch(
  `https://api.aireserve.com/v1/customers/${encodeURIComponent(customerId)}/keys`,
  { method: "POST", headers, body: JSON.stringify({ org_id: "emea" }) },
);
if (!res.ok) throw new Error(`create failed: ${res.status}`);
const { key: secret } = await res.json(); // shown once — store it now
```

```json theme={"dark"}
{
  "id": "0c0b8b5e-3e6b-4f3f-9a2e-6d8c2f1a4b70",
  "name": "cust_8f3a2b › emea",
  "customer_id": "cust_8f3a2b",
  "org_id": "emea",
  "key_prefix": "aireserve_api_9f1",
  "key_suffix": "c2d7e1",
  "status": "active",
  "created_at": "2026-10-06T09:14:02.000Z",
  "last_used_at": null,
  "revoked_at": null,
  "key": "aireserve_api_9f1…c2d7e1"
}
```

The customer then uses `key` exactly like any other AI Reserve key — same base URL, same
endpoints, same rate limits as your organization. No header or body field is needed; if the
customer's code does send `x-aireserve-customer` or `user`, the key's customer still wins.

## List a customer's keys

`GET /v1/customers/{customerId}/keys`

Returns every key bound to the customer, newest first, revoked keys included. Secrets are
never returned — only the prefix and suffix you need to tell keys apart.

```bash theme={"dark"}
curl "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

```json theme={"dark"}
{
  "customer_id": "cust_8f3a2b",
  "keys": [
    {
      "id": "0c0b8b5e-3e6b-4f3f-9a2e-6d8c2f1a4b70",
      "name": "cust_8f3a2b › emea",
      "customer_id": "cust_8f3a2b",
      "org_id": "emea",
      "key_prefix": "aireserve_api_9f1",
      "key_suffix": "c2d7e1",
      "status": "active",
      "created_at": "2026-10-06T09:14:02.000Z",
      "last_used_at": "2026-10-06T11:40:19.000Z",
      "revoked_at": null
    },
    {
      "id": "7a4d1c22-5b0e-4a9f-8e31-2f6b9d0c5e18",
      "name": "Acme production",
      "customer_id": "cust_8f3a2b",
      "org_id": null,
      "key_prefix": "aireserve_api_4bd",
      "key_suffix": "a81f03",
      "status": "revoked",
      "created_at": "2026-09-30T16:02:45.000Z",
      "last_used_at": "2026-10-05T22:11:08.000Z",
      "revoked_at": "2026-10-06T08:00:00.000Z"
    }
  ]
}
```

| `status` | Meaning |
| - | - |
| `active` | Serves requests |
| `paused` | Stopped by a spending guardrail or an admin; can be resumed from the portal's Keys page |
| `revoked` | Permanent. Requests with the key are refused with `401` |

## Revoke a key

`DELETE /v1/customers/{customerId}/keys/{keyId}`

Revocation is immediate and permanent: the next request made with the key is refused. The
call is idempotent — revoking an already-revoked key returns the same `200`. A `keyId` that
does not belong to this customer (or to your organization) returns `404`, so a key can never
be revoked through the wrong customer's path.

```bash theme={"dark"}
curl -X DELETE "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys/7a4d1c22-5b0e-4a9f-8e31-2f6b9d0c5e18" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

```json theme={"dark"}
{
  "id": "7a4d1c22-5b0e-4a9f-8e31-2f6b9d0c5e18",
  "customer_id": "cust_8f3a2b",
  "org_id": null,
  "status": "revoked",
  "revoked_at": "2026-10-06T08:00:00.000Z"
}
```

To rotate, create the new key first, move the customer over, then revoke the old one.

## Errors

All three endpoints share your organization's API rate limit and return the standard
[error shape](/api-reference/errors).

| Status | `code` | When |
| - | - | - |
| `400` | `invalid_customer_id` | The path segment is empty, longer than 128 characters, or contains control characters |
| `400` | `invalid_body`, `invalid_json`, `invalid_org_id` | The body is not a JSON object, has unknown fields, or `name` / `org_id` fail validation |
| `400` | `invalid_key_id` | `keyId` is not a UUID |
| `401` | — | Missing or unknown API key |
| `403` | `customer_key_not_allowed` | The caller is a customer key or sub key |
| `403` | `organization_key_required` | The caller is a team or personal key |
| `404` | `key_not_found` | No such key for this customer in your organization |
| `409` | `name_taken` | An active key of yours already has that `name` |
| `429` | `rate_limit_exceeded` | Your organization's API rate limit; honor `Retry-After` |

Full request and response schemas are under *Customer keys* in the
[API reference](/api-reference).


# Create a customer key
Source: https://docs.aireserve.com/api-reference/customer-keys/create-a-customer-key

/api-reference/openapi.json post /v1/customers/{customerId}/keys
Mint an API key for one of your end customers. Every request made with the key is billed to your organization and reported under this customer — in Analytics, in `GET /v1/customers/usage`, and in exports — with no per-request tagging. Pass `org_id` to mint a **sub key** for one of the customer's own organizations or sub-accounts; its usage is reported under both the customer and that organization. The plaintext `key` is returned once, in this response only.



# List a customer's keys
Source: https://docs.aireserve.com/api-reference/customer-keys/list-a-customers-keys

/api-reference/openapi.json get /v1/customers/{customerId}/keys
Every key minted for this end customer — customer-level keys and sub keys (`org_id` set) — newest first, revoked keys included with `status: "revoked"`. Never returns key material: only the prefix and suffix you would use to tell keys apart.



# Revoke a customer key
Source: https://docs.aireserve.com/api-reference/customer-keys/revoke-a-customer-key

/api-reference/openapi.json delete /v1/customers/{customerId}/keys/{keyId}
Revoke one of the customer's keys. Requests made with it are rejected immediately; usage already recorded stays attributed to the customer. Idempotent: revoking an already-revoked key answers 200 with the original `revoked_at`. A key that does not belong to this customer (or to your organization) is `404`.



# Usage and billable amounts per end customer
Source: https://docs.aireserve.com/api-reference/customers/usage-and-billable-amounts-per-end-customer

/api-reference/openapi.json get /v1/customers/usage
What each of your end customers used in the period, what it cost your organization (`cost_usd`), and — when your organization has pricing rules for its customers — what the customer owes (`billable_usd`) and your margin. Customers are the opaque ids you tagged requests with via `x-aireserve-customer` (or the OpenAI `user` field). Requests with no tag are reported once as `untagged`, cost only. Failed requests are never billed and are not counted in `requests`.



# Usage for one end customer, by feature or day
Source: https://docs.aireserve.com/api-reference/customers/usage-for-one-end-customer-by-feature-or-day

/api-reference/openapi.json get /v1/customers/{customerId}/usage
The same figures for a single end customer, broken down by the `x-aireserve-feature` tag (default) or by UTC day — the call to make when a customer asks what they owe. Customer ids are opaque: an id you have never tagged simply returns zeros, so ids cannot be probed.



# Discover data endpoints
Source: https://docs.aireserve.com/api-reference/data-endpoints/discover-data-endpoints

/api-reference/openapi.json post /v1/monid/discover
Search monid.ai's marketplace of third-party data endpoints (web scrapers, contact and company enrichment, search) in natural language. Free — no run is executed. The response is monid's own discover body: each result names the `provider`, `endpoint`, and `price` you pass to inspect or run.



# Get data endpoint run
Source: https://docs.aireserve.com/api-reference/data-endpoints/get-data-endpoint-run

/api-reference/openapi.json get /v1/monid/runs/{run_id}
Poll an async data endpoint run by its AI Reserve `job_id`. Runs are scoped to your organization — other organizations' run ids answer `404`. The response is the completed monid run body plus the `aireserve` envelope; `aireserve.status` is `succeeded` or `failed` once terminal.



# Inspect data endpoint
Source: https://docs.aireserve.com/api-reference/data-endpoints/inspect-data-endpoint

/api-reference/openapi.json post /v1/monid/inspect
Return a data endpoint's input schema, documentation, and price. Free — no run is executed. Pass the returned `price` object into `POST /v1/monid/run` to size the wallet reserve exactly.



# Run data endpoint
Source: https://docs.aireserve.com/api-reference/data-endpoints/run-data-endpoint

/api-reference/openapi.json post /v1/monid/run
Execute a data endpoint with your AI Reserve key; the run is billed to your AI Reserve wallet at monid's published price for that endpoint. Sync providers answer inline with the run body and the brokered provider's own HTTP status (200 data, 404 no match, 429 …, all with `status: "COMPLETED"`); async providers answer **202** with `status: "READY"`. Every answer carries an `aireserve` envelope whose `job_id` is what you poll at `GET /v1/monid/runs/{run_id}` — monid's own `runId` is an upstream identifier and is not accepted there.



# Typed decision (yes/no, choice, score)
Source: https://docs.aireserve.com/api-reference/decisions/typed-decision-yesno-choice-score

/api-reference/openapi.json post /v1/decisions
Send a state (text, JSON, or images) and a schema of typed questions — `noul` (yes/no), `choice` (pick one of your options), `score` (rate against an ordered rubric) — and get a calibrated probability for every allowed answer in one forward pass. No free-form text, no reasoning tokens. Jev / System One compatible. Billed per input token under `clef` (27B, 64K context) or `clef-flash` (9B, 24K context); output tokens are free.



# Create embeddings
Source: https://docs.aireserve.com/api-reference/embeddings/create-embeddings

/api-reference/openapi.json post /v1/embeddings
OpenAI-compatible embeddings.



# Errors & retries
Source: https://docs.aireserve.com/api-reference/errors

Every SDK raises the same Bedrock-named exceptions, with the same retryability semantics you already handle.

Every SDK raises the **same Bedrock-named exceptions**, so your existing
error-handling paths — including catch-and-backoff logic keyed on
`ThrottlingException` — port over unchanged. Every server-derived error carries
`message`, `statusCode`, `errorCode`, `requestId`
(quote it to support), `retryAfterSeconds`, and the raw response body.

| Exception | Retried automatically | Typical cause |
| - | - | - |
| `ValidationException` | no | Malformed or oversized request (HTTP 400/413/422) |
| `AccessDeniedException` | no | Bad or missing key; model not allowed (401/403) |
| `ResourceNotFoundException` | no | Unknown model (404) |
| `ServiceQuotaExceededException` | no | Budget, wallet or usage cap exhausted (402) |
| `ThrottlingException` | yes | Rate limited (429) — honors `Retry-After` |
| `ModelTimeoutException` | yes | The model or the gateway timed out (408/504) |
| `ModelErrorException` | no | Model-level failure; also a model not yet fully onboarded on AI Reserve (422 `MODEL_NOT_CONFIGURED`) |
| `ModelStreamErrorException` | no | Stream interrupted after the first byte |
| `ServiceUnavailableException` | yes | Provider or gateway temporarily unavailable (502/503/529) — honors `Retry-After` |
| `InternalServerException` | yes | Unexpected gateway error (500 and any other 5xx) — you were not charged |
| `MissingApiKeyError` | — | No key resolved; fails before any network call |
| `SdkError` | network only | Connection / decode failure |

```python Python theme={"dark"}
from audacity.exceptions import SdkError

try:
    response = client.converse(modelId="gpt-5.4-mini", messages=[…])
except client.exceptions.ThrottlingException as e:
    print(f"Rate limited: {e.message}, retry after {e.retry_after_seconds}s")
except client.exceptions.AccessDeniedException as e:
    print(f"Auth error [{e.status_code}]: {e.message}")
except client.exceptions.ServiceQuotaExceededException as e:
    print(f"Budget exhausted: {e.message}")
except SdkError as e:
    print(f"Network/decode error: {e.message}")
```

```typescript TypeScript theme={"dark"}
import {
  AccessDeniedException,
  ThrottlingException,
  MissingApiKeyError,
  AudacityError,
} from "@audacity/sdk";

try {
  const res = await client.send(new ConverseCommand({ /* … */ }));
} catch (err) {
  if (err instanceof MissingApiKeyError) {
    console.error("No API key configured");
  } else if (err instanceof AccessDeniedException) {
    console.error("Auth failed:", err.message, "requestId:", err.requestId);
  } else if (err instanceof ThrottlingException) {
    console.error("Rate limited. Retry after:", err.retryAfterSeconds, "s");
  } else if (err instanceof AudacityError) {
    // All SDK errors are instances of AudacityError
    console.error(err.name, err.statusCode, err.errorCode);
  }
}
```

```go Go theme={"dark"}
_, err := client.Converse(ctx, input)
switch {
case err == nil:
    // success
case errors.Is(err, &types.MissingAPIKeyError{}):
    log.Fatal("set AIRESERVE_API_KEY")
default:
    var throttle *types.ThrottlingException
    var quota *types.ServiceQuotaExceededException
    var accessDenied *types.AccessDeniedException

    switch {
    case errors.As(err, &throttle):
        fmt.Printf("rate limited (retry-after=%v)\n", throttle.RetryAfterSeconds)
    case errors.As(err, &quota):
        fmt.Println("budget exhausted — will not retry")
    case errors.As(err, &accessDenied):
        fmt.Println("check your API key")
    default:
        log.Fatal(err)
    }
}
```

```java Java theme={"dark"}
try {
    ConverseResponse resp = client.converse(request -> request
        .modelId("gpt-5.4-mini")
        .messages(Message.builder()
            .role(ConversationRole.USER)
            .content(ContentBlock.fromText("Hi"))
            .build()));
} catch (ThrottlingException e) {
    System.err.printf("Rate limited. Retry-After: %s s%n", e.retryAfterSeconds());
} catch (AccessDeniedException e) {
    System.err.println("Auth failed: " + e.getMessage());
} catch (ServiceQuotaExceededException e) {
    System.err.println("Budget or quota exceeded — not retried");
} catch (AudacityException e) {
    System.err.printf("SDK error [%d] %s%n", e.statusCode(), e.getMessage());
}
```

```rust Rust theme={"dark"}
use audacity_sdk::Error;

match client.converse().model_id("m").messages(msg).send().await {
    Ok(resp) => { /* use resp */ }
    Err(Error::Throttling(d)) => {
        eprintln!("Rate limited (retry after {:?}s): {}", d.retry_after_seconds, d.message);
    }
    Err(Error::AccessDenied(d)) => {
        eprintln!("Access denied [{}]: {}", d.error_code.unwrap_or_default(), d.message);
    }
    Err(Error::MissingApiKey) => {
        eprintln!("Set AIRESERVE_API_KEY");
    }
    Err(e) => eprintln!("Other error: {e}"),
}
```

## Retry policy (Bedrock standard-mode analog)

* Attempts = `maxRetries + 1`; the default is 2 retries (3 total attempts).
* Retried: network errors, HTTP 429, 500, 502, 503, 504, and 408 — with full-jitter exponential backoff capped at 20 s, honoring any `Retry-After` header.
* Never retried: auth failures, validation errors, unknown models, and **budget exhaustion** (`BUDGET_EXCEEDED`) — spending errors must never silently retry.
* Streaming: retries apply only until response headers arrive. Once the first byte of the stream is consumed, a drop surfaces as `ModelStreamErrorException` — a partial generation is never silently replayed.

## What every error tells you

Every error the gateway answers, in any dialect, says three things:

* **What happened** — `message`, in plain language. When a model provider is
  involved, the message names the provider; when the fault is ours, it says
  so and confirms you were not charged.
* **Who has to act** — `source`:
  * `client`: change the request, key, model, or budget. Retrying the same
    request will fail the same way.
  * `provider`: the upstream model provider failed or throttled the request.
    Retry shortly or switch models.
  * `platform`: an AI Reserve component failed. A request that never reached
    the model is not billed; the message says so when that is the case. Retry
    shortly; if it persists, contact support with the request id.
* **How to find it** — `request_id` in the body and the `X-Request-ID`
  response header. `/v1/messages` answers it as `request-id` (the header the
  Anthropic SDKs surface as `request_id`); the Bedrock-compatible routes as
  `x-amzn-RequestId`. Quote it to support.

`hint`, when present, is a one-line next step (for example, set
`"stream": true` for long generations that hit the gateway's first-byte
budget).

### Wire shapes

```json OpenAI-compatible routes theme={"dark"}
// /v1/chat/completions, /v1/responses, /v1/embeddings, /v1/models, ...
{
  "success": false,
  "error": {
    "code": "SERVICE_UNAVAILABLE",
    "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged.",
    "request_id": "7a0c1e0e-…",
    "source": "platform",
    "hint": "AI Reserve could not reach its inference engine. You were not charged. Retry shortly.",
    "details": { "upstream_error": { "…": "sanitized provider body, when one exists" } }
  }
}
```

```json Spend caps on OpenAI-compatible routes theme={"dark"}
// 402 — the one error these routes answer in the OpenAI error shape
{
  "error": {
    "message": "Team budget reached for Platform. Contact your administrator to raise the limit.",
    "type": "usage_cap_error",
    "param": null,
    "code": "usage_cap_exceeded"
  }
}
```

```json Anthropic-compatible route theme={"dark"}
// /v1/messages — the Anthropic envelope; `type` follows the HTTP status,
// the request id travels in the request-id header
{
  "type": "error",
  "error": {
    "type": "api_error",
    "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged."
  }
}
```

```json Bedrock-compatible routes theme={"dark"}
// /model/{modelId}/converse — `__type` also travels in the x-amzn-ErrorType
// header, the request id in x-amzn-RequestId (boto3: ResponseMetadata.RequestId)
{
  "__type": "ServiceUnavailableException",
  "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged."
}
```

### Status codes and error codes

Every status/code pair the gateway answers. Every 429 rate limit and every
503 AI Reserve answers itself carries `Retry-After` on every dialect; spend
caps never do (they do not lift on their own), and provider 429/503s are
relayed with the provider's status.

| HTTP | `code` | `source` | When | Retry? |
| - | - | - | - | - |
| 400 | `VALIDATION_ERROR` | client | Malformed body, unknown parameter, unsupported combination | no |
| 400 | `CONTENT_BLOCKED_BY_POLICY` | client | Your organization's content policy blocked the input | no |
| 400 | `ASSISTANT_PREFILL_UNSUPPORTED` | client | Trailing assistant turn sent to a model that rejects prefill | no |
| 401 | `AUTHENTICATION_ERROR` | client | Missing, malformed, revoked or expired API key | no |
| 401 / 403 | `BYOK_KEY_INVALID` | client | Your own provider key was rejected by the provider | no |
| 402 | `WALLET_INSUFFICIENT_FUNDS` | client | Your AI Reserve credit is exhausted — top up | no |
| 402 | `WALLET_NOT_ENABLED` | client | Billing is not enabled for your organization | no |
| 402 | `BUDGET_EXCEEDED` (`usage_cap_exceeded` on OpenAI-compatible routes) | client | An admin spend cap (organization, team or member) is reached | no |
| 402 | `SESSION_BUDGET_EXCEEDED` | client | Your own per-session budget is reached | no |
| 402 | `BYOK_BALANCE_EXHAUSTED` | client | Your own provider account is out of credit | no |
| 403 | `AUTHORIZATION_ERROR` | client | The key is valid but may not do this (inactive user, scope, IP/country screen) | no |
| 403 | `MODEL_NOT_ALLOWED` | client | Model not allowed for your organization, key, or jurisdiction policy | no |
| 403 | `INTEGRATION_BLOCKED` | client | Your team has blocked this coding tool | no |
| 404 | `MODEL_NOT_FOUND` | client | Unknown model id — the message suggests close matches | no |
| 404 | `NOT_FOUND` | client | Unknown resource (file, job, voice, endpoint) | no |
| 408 | `TIMEOUT_ERROR` | provider | The provider's own request timeout, relayed | yes, or switch models |
| 413 | `VALIDATION_ERROR` | client | Request body over the size limit, or a prompt over the model's context window | no |
| 422 | `MODEL_NOT_CONFIGURED` | platform | The model exists but is not fully onboarded (no pricing) — you were not charged | switch models |
| 429 | `RATE_LIMIT_EXCEEDED` | client | Your organization's or key's rate limit; `Retry-After` is the window reset | yes |
| 429 | `RATE_LIMIT_EXCEEDED` | provider | The provider is rate-limiting this model | yes, or switch models |
| 429 | `BYOK_RATE_LIMITED` | client | Your own provider key is rate-limited by the provider | yes |
| 500 | `INTERNAL_ERROR` | platform | An AI Reserve component failed; the message says what happened and whether you were charged (you were not, unless a finished generation could not be stored) | yes |
| 500 | `STREAM_ERROR` | platform / provider | The engine returned no body, or the stream failed before the first byte | yes |
| 502 | `UPSTREAM_ERROR` | provider | The provider returned an error we could not recover from | yes, or switch models |
| 503 | `SERVICE_UNAVAILABLE` | platform | AI Reserve could not reach its inference engine, an enforcement component or its file storage — you were not charged | yes (`Retry-After`) |
| 503 | `UPSTREAM_ERROR` | provider | The provider is unavailable | yes, or switch models |
| 503 | `provider_insufficient_balance` | platform | AI Reserve's own account with the provider is out of credit — not your credit, you were not charged | yes, or switch models |
| 503 | `provider_account_unavailable` | platform | The provider has suspended AI Reserve's account — you were not charged | yes, or switch models |
| 504 | `TIMEOUT_ERROR` | platform | The gateway gave up waiting for the engine (request budget or first-byte ceiling) — you were not charged | yes; stream long generations |
| 504 | `TIMEOUT_ERROR` | provider | The provider did not answer in time (pinned serving groups report the provider by name) | yes, or switch models |

### Errors inside a stream

Once a stream has started the HTTP status is already `200`, so a failure
arrives as a terminal frame instead:

* OpenAI-compatible routes write one last `data:` line with the error
  envelope — `{"error":{"message","type":"api_error","code":"stream_error","source","hint"}}` —
  and end the stream. No `[DONE]` follows.
* `/v1/messages` writes an Anthropic `event: error` block —
  `{"type":"error","error":{"type","message","source","hint"}}`.
* `/model/{modelId}/converse-stream` writes an `exception` event
  (`internalServerException`, `modelStreamErrorException`, …) in the
  Bedrock event-stream encoding.

A partial generation is never billed as a complete one, and the SDKs raise
`ModelStreamErrorException` rather than replaying it.


# Typed extraction (text, number, date, list, estimate, forecast)
Source: https://docs.aireserve.com/api-reference/extractions/typed-extraction-text-number-date-list-estimate-forecast

/api-reference/openapi.json post /v1/extractions
Send text and/or up to 4 images plus a schema of typed fields — `text` (a span of the input), `number`, `date` / `time` / `datetime`, `duration`, `list`, `estimate` (a distribution over a range), `forecast` (per-step estimates) — and get a value, calibrated confidence and null probability for every field in one forward pass. No free-form text, no reasoning tokens; a field the input does not determine comes back null. Billed per input token under `clairic` (64K context); output tokens are free.



# Create file upload slot
Source: https://docs.aireserve.com/api-reference/files/create-file-upload-slot

/api-reference/openapi.json post /v1/files
Create a presigned upload slot for a video file



# Get file upload status
Source: https://docs.aireserve.com/api-reference/files/get-file-upload-status

/api-reference/openapi.json get /v1/files/{file_id}
Check upload status of a file



# Add registry credential
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/add-registry-credential

/api-reference/openapi.json post /v1/gpu/registries
Save an encrypted container registry credential for private images. The password is never echoed back. Requires compute `manage` access.



# Add SSH key
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/add-ssh-key

/api-reference/openapi.json post /v1/gpu/ssh-keys
Register an SSH public key. Validated, type-checked, and stored with its SHA-256 fingerprint. Requires compute `manage` access.



# Create pod (legacy)
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/create-pod-legacy

/api-reference/openapi.json post /v1/gpu/pods
Legacy provider-shaped launch. New integrations should use `POST /v1/gpu/instances`, which performs placement and pricing internally. This route requires a quote and explicit disk/public-port acknowledgements. Requires compute `manage` access.



# Create template
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/create-template

/api-reference/openapi.json post /v1/gpu/templates
Save a private organization template. Env values are encrypted at rest. Requires compute `manage` access.



# Create volume
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/create-volume

/api-reference/openapi.json post /v1/gpu/volumes
Create a persistent volume. Provider-hidden form: `name`, `sizeGb`, `region`, optional `acceleratorHint` (AI Reserve places the volume where that accelerator has stock and persistent storage is sold, so a later launch can mount it; when no such location exists in the region the request answers `409 no_capacity` with `reason: no_persistent_storage` and the regions where it would work, and nothing is created) and `storageBillingAcknowledged: true`; the price is fixed at accept and returned on the volume. Legacy form: `dataCenterId` plus a `quoteId` from `POST /v1/gpu/quotes`. Storage bills hourly until the volume is deleted, independent of any instance. Requires compute `manage` access.



# Delete registry credential
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/delete-registry-credential

/api-reference/openapi.json delete /v1/gpu/registries/{registryId}
Delete a credential. Blocked while an active pod references it. Requires compute `manage` access.



# Delete template
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/delete-template

/api-reference/openapi.json delete /v1/gpu/templates/{templateId}
Delete a private template. Curated templates cannot be deleted. Requires compute `manage` access.



# Delete volume
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/delete-volume

/api-reference/openapi.json delete /v1/gpu/volumes/{volumeId}
Delete a network volume with no attached pod. Ends storage accrual. Irreversible. Requires compute `manage` access.



# Get GPU cluster
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-gpu-cluster

/api-reference/openapi.json get /v1/gpu/clusters/{clusterId}
The cluster with its read-only member nodes. `degraded` means some nodes have left `running`; billing continues until terminate. Requires compute `read` access.



# Get GPU cluster connections
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-gpu-cluster-connections

/api-reference/openapi.json get /v1/gpu/clusters/{clusterId}/connections
SSH for the primary node and every member, plus each node's address on the private interconnect. Empty until the cluster is running. Requires compute `manage` access.



# Get GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-gpu-instance

/api-reference/openapi.json get /v1/gpu/instances/{instanceId}
Retrieve normalized lifecycle, runtime profile, storage, price, and capabilities without provider placement identifiers or connection credentials. Requires compute `read` access.



# Get GPU instance connections
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-gpu-instance-connections

/api-reference/openapi.json get /v1/gpu/instances/{instanceId}/connections
Return structured SSH and HTTP connection details when the instance is running. Requires compute `manage` access.



# Get operation
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-operation

/api-reference/openapi.json get /v1/gpu/operations/{operationId}
Poll an asynchronous operation. Terminal statuses: `succeeded`, `failed`, `cancelled`. Requires compute `read` access.



# Get pod
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-pod

/api-reference/openapi.json get /v1/gpu/pods/{podId}
Current state of a pod. `404` for unknown IDs and for pods owned by other organizations. Requires compute `read` access.



# Get pod connections
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-pod-connections

/api-reference/openapi.json get /v1/gpu/pods/{podId}/connections
SSH command and public proxy URLs for a running pod. `{ available: false }` until running. Requires compute `manage` access.



# Get template
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-template

/api-reference/openapi.json get /v1/gpu/templates/{templateId}
A curated or organization-owned template. Requires compute `read` access.



# Get volume
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/get-volume

/api-reference/openapi.json get /v1/gpu/volumes/{volumeId}
State, size, billing status, and any active delinquency episode. Requires compute `read` access.



# Grow volume
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/grow-volume

/api-reference/openapi.json patch /v1/gpu/volumes/{volumeId}
Increase a volume's size. Growth only; volumes cannot shrink. Requires a `quoteId` for the new size. Requires compute `manage` access.



# Launch GPU cluster
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/launch-gpu-cluster

/api-reference/openapi.json post /v1/gpu/clusters
Launch a cluster from a `quoteId`, or from the full request with `accelerator`, `nodes` and a `maxHourlyPrice` ceiling on the whole cluster. Every node gets the same image, env, ports and SSH keys, plus `MASTER_ADDR`, `NODE_RANK` and `NCCL_SOCKET_IFNAME` for the interconnect. `orchestrator: slurm` or `ray` provisions a managed controller/head and workers; `none` leaves bare nodes for your own launcher. Accepted with `202`; poll the operation, then `GET /v1/gpu/clusters/{clusterId}`. If the provider cannot place every node together, the operation fails with `no_capacity` after a few retries and nothing is billed. A cluster cannot be stopped: it bills from the moment every node is verified running until you terminate it. Requires compute `manage` access.



# Launch GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/launch-gpu-instance

/api-reference/openapi.json post /v1/gpu/instances
Launch GPU infrastructure from requirements. AI Reserve selects eligible capacity internally; the request never names a provider or data center. Pass a `quoteId` from `POST /v1/gpu/instances/quote` to launch exactly what was quoted (workload fields such as `env`, `sshPublicKey` and `ports` may be added), or send the full request with a `maxHourlyPrice` ceiling. Persistent storage: `storage.persistentGb` creates a volume next to the GPU in the same operation; `volumeId` mounts an existing volume and pins placement to its location. Defaults: one GPU, 50 GiB ephemeral root disk, any eligible region, and a maintained PyTorch/CUDA image. Requires compute `manage` access.



# List data centers
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-data-centers

/api-reference/openapi.json get /v1/gpu/catalog/datacenters
Data centers available for on-demand pods and network volumes. Requires compute `read` access.



# List GPU clusters
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-gpu-clusters

/api-reference/openapi.json get /v1/gpu/clusters
Every multi-node cluster in the organization, newest first, including terminated ones. Requires compute `read` access.



# List GPU instances
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-gpu-instances

/api-reference/openapi.json get /v1/gpu/instances
List GPU infrastructure without exposing the provider selected by AI Reserve. Requires compute `read` access.



# List GPU types
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-gpu-types

/api-reference/openapi.json get /v1/gpu/catalog
Alias of `/v1/gpu/catalog/gpus`. Requires compute `read` access.



# List GPU types
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-gpu-types-1

/api-reference/openapi.json get /v1/gpu/catalog/gpus
Available GPU models, per-data-center availability, and current list prices for the on-demand pool. Browsing does not reserve capacity; availability and price are rechecked at quote time. Requires compute `read` access.



# List pods
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-pods

/api-reference/openapi.json get /v1/gpu/pods
All pods owned by your organization, including terminated ones. Requires compute `read` access.



# List registry credentials
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-registry-credentials

/api-reference/openapi.json get /v1/gpu/registries
Credential metadata. Secrets are never returned. Requires compute `read` access.



# List SSH keys
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-ssh-keys

/api-reference/openapi.json get /v1/gpu/ssh-keys
SSH public keys registered for your organization. Requires compute `read` access.



# List templates
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-templates

/api-reference/openapi.json get /v1/gpu/templates
Curated AI Reserve templates plus your organization's private templates. Requires compute `read` access.



# List usage and charges
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-usage-and-charges

/api-reference/openapi.json get /v1/gpu/usage
Immutable compute and storage billing windows for your organization. Requires compute `read` access.



# List volumes
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/list-volumes

/api-reference/openapi.json get /v1/gpu/volumes
All network volumes owned by your organization. Requires compute `read` access.



# Quote GPU cluster
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/quote-gpu-cluster

/api-reference/openapi.json post /v1/gpu/clusters/quote
Price a multi-node cluster before launching it: `nodes` identical machines (2–8) of `gpusPerNode` GPUs (1–8) on a private interconnect in one location. Runs the same placement as a launch: an existing `volumeId` pins the cluster to where that volume lives, and inline `storage` prices one shared volume beside it, mounted at the same path on every node. Answers with the whole-cluster hourly price (inter-node networking included), what survives terminate, and a `quoteId` to launch exactly this. `availability` is the stock signal for one node; whether every node can be placed together is confirmed only at launch. A request that cannot be satisfied answers `409 no_capacity` with a reason and alternatives, before anything is created or charged. Larger clusters are arranged through sales. Quotes expire after 120 seconds. Requires compute `read` access.



# Quote GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/quote-gpu-instance

/api-reference/openapi.json post /v1/gpu/instances/quote
Price an instance request before launching it. Runs the same placement as a launch: an existing `volumeId` pins placement to where that volume lives, and inline `storage` is priced in and placed with the GPU. Answers with the all-in hourly price, what survives stop and terminate, what keeps billing, and a `quoteId` to launch exactly this. A request that cannot be satisfied answers `409 no_capacity` with a reason and alternatives, before anything is created or charged. Nothing is reserved; quotes expire after 120 seconds. Requires compute `read` access.



# Recover GPU cluster now
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/recover-gpu-cluster-now

/api-reference/openapi.json post /v1/gpu/clusters/{clusterId}/recover
Make one recovery attempt right now on every node that is not running, regardless of the policy's cooldown and cap. Counts toward the current episode. `409 operation_conflict` when every node is running, the cluster never came up, or another operation is in flight. Poll the operation, then read `recovery.lastOutcome` and `nodes[].status`. Requires compute `manage` access.



# Recover GPU instance now
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/recover-gpu-instance-now

/api-reference/openapi.json post /v1/gpu/instances/{instanceId}/recover
Make one recovery attempt right now, regardless of the policy's cooldown and cap, for an instance that was running and stopped on its own. Counts toward the current episode. `409 operation_conflict` when the instance is running, was never admitted, or another operation is in flight. Poll the operation, then read `recovery.lastOutcome`. Requires compute `manage` access.



# Request a price quote
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/request-a-price-quote

/api-reference/openapi.json post /v1/gpu/quotes
Validate a candidate pod or volume spec against live capacity and return a signed price quote. Pass the returned `quoteId` in the following create or grow request. Quotes expire after 120 seconds; the price is rechecked at accept time and a changed price fails with `409 price_changed`. Requires compute `read` access.



# Revoke SSH key
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/revoke-ssh-key

/api-reference/openapi.json delete /v1/gpu/ssh-keys/{keyId}
Revoke a key. Excluded from subsequent pod starts; existing sessions on running pods persist until restart. Requires compute `manage` access.



# Rotate registry credential
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/rotate-registry-credential

/api-reference/openapi.json patch /v1/gpu/registries/{registryId}
Replace the credential's secret (and optionally username) in place. Blocked while an active pod references the credential. Requires compute `manage` access.



# Set GPU cluster recovery policy
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/set-gpu-cluster-recovery-policy

/api-reference/openapi.json put /v1/gpu/clusters/{clusterId}/recovery
Choose what happens when a cluster goes `degraded`. `mode: none` (default) keeps it degraded and billing until you terminate. `mode: restart` lets AI Reserve bring the lost nodes back one by one through the provider's own restart/start, leaving healthy nodes, the shared volume and the rate untouched, up to `maxAttempts` times per episode (default 3, max 10) with `cooldownMinutes` between attempts (default 5, max 120). Immediate: the operation is already `succeeded` when accepted. Requires compute `manage` access.



# Set GPU instance recovery policy
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/set-gpu-instance-recovery-policy

/api-reference/openapi.json put /v1/gpu/instances/{instanceId}/recovery
Choose what happens when a running instance stops on its own. `mode: none` (default) leaves it stopped for you. `mode: restart` lets AI Reserve restart it in place or start it again, up to `maxAttempts` times per episode (default 3, max 10) and no more often than every `cooldownMinutes` (default 5, max 120). Never relaunches on different hardware, never re-quotes, never changes the rate. Takes effect on the next health pass; the current attempt counter is untouched. Immediate: the operation is already `succeeded` when accepted. Requires compute `manage` access.



# Start GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/start-gpu-instance

/api-reference/openapi.json post /v1/gpu/instances/{instanceId}/start
Start a stopped instance when its capabilities permit it. Capacity is rechecked and not guaranteed. Requires compute `manage` access.



# Start pod
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/start-pod

/api-reference/openapi.json post /v1/gpu/pods/{podId}/start
Start a stopped pod after the wallet and spend gates are rechecked. Restart capacity is not guaranteed. Requires compute `manage` access.



# Stop GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/stop-gpu-instance

/api-reference/openapi.json post /v1/gpu/instances/{instanceId}/stop
Stop an instance and release its accelerator. Inspect `capabilities.stopPreservesRootDisk` before relying on root-disk persistence. Requires compute `manage` access.



# Stop pod
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/stop-pod

/api-reference/openapi.json post /v1/gpu/pods/{podId}/stop
Stop a running pod. Usage accrues through the confirmed stop time; the ephemeral container disk is lost and the network volume is preserved. Requires compute `manage` access.



# Stream GPU cluster node logs
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/stream-gpu-cluster-node-logs

/api-reference/openapi.json get /v1/gpu/clusters/{clusterId}/logs
Server-sent event stream of one node's transient workload logs. AI Reserve stores no workload log archive. Requires compute `manage` access.



# Stream GPU instance logs
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/stream-gpu-instance-logs

/api-reference/openapi.json get /v1/gpu/instances/{instanceId}/logs
Server-sent event stream of transient workload logs. AI Reserve stores no workload log archive. Requires compute `manage` access.



# Stream pod logs
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/stream-pod-logs

/api-reference/openapi.json get /v1/gpu/pods/{podId}/logs
Server-sent event stream of container logs relayed live from the provider. No log archive is stored. Requires compute `manage` access.



# Terminate GPU cluster
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/terminate-gpu-cluster

/api-reference/openapi.json delete /v1/gpu/clusters/{clusterId}
Release every node and stop billing. Always accepted, even mid-provision. The shared persistent volume (if any) is detached and kept; delete it separately to stop its storage bill. Requires compute `manage` access.



# Terminate GPU instance
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/terminate-gpu-instance

/api-reference/openapi.json delete /v1/gpu/instances/{instanceId}
Permanently destroy the instance and release its accelerator. Attached persistent volumes are not deleted. Requires compute `manage` access.



# Terminate pod
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/terminate-pod

/api-reference/openapi.json delete /v1/gpu/pods/{podId}
Permanently destroy the pod and release its GPU. The attached network volume is not deleted and keeps billing until you delete it. Irreversible. Requires compute `manage` access.



# Update template
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/update-template

/api-reference/openapi.json patch /v1/gpu/templates/{templateId}
Update a private template. Curated templates are read-only. Running pods are unaffected; each pod snapshots its launch config at creation. Requires compute `manage` access.



# Update template (deprecated alias)
Source: https://docs.aireserve.com/api-reference/gpu-infrastructure/update-template-deprecated-alias

/api-reference/openapi.json put /v1/gpu/templates/{templateId}
Deprecated alias of `PATCH`. Removed after one release. Requires compute `manage` access.



# Generate images
Source: https://docs.aireserve.com/api-reference/images/generate-images

/api-reference/openapi.json post /v1/images/generations
Generate images. Synchronous — multi-image or high-quality generations can take tens of seconds, so set client timeouts accordingly.



# Wire protocol
Source: https://docs.aireserve.com/api-reference/index

Understand the OpenAI wire protocol used by the official inference SDKs and find generated endpoint schemas.

The official inference SDKs translate their Bedrock-shaped interface onto one
OpenAI-compatible HTTP endpoint. If you prefer to integrate directly—or want to
audit exactly what inference traffic looks like—the endpoint is:

```bash theme={"dark"}
POST https://api.aireserve.com/v1/chat/completions
Authorization: Bearer aireserve_api_…
Content-Type: application/json
```

The body is OpenAI chat-completions compatible; streaming responses are standard server-sent
events terminated by `data: [DONE]`, with a final usage chunk always included.
The SDKs translate between this wire format and the Bedrock Converse shapes:

| You write (Bedrock shape) | The SDK sends (OpenAI wire) |
| - | - |
| `modelId`, `inferenceConfig.maxTokens` | `model`, `max_tokens` |
| `system` blocks | A single leading `system` message |
| `toolConfig.tools[].toolSpec` | `tools[].function` with JSON Schema parameters |
| `toolResult` blocks | `role: "tool"` messages keyed by `tool_call_id` |
| `image` blocks (bytes or URL) | `image_url` content parts (bytes become base64 data URLs) |
| Stream events (`messageStart` … `metadata`) | Translated from OpenAI SSE chunks by a per-block state machine |

The full normative chat mapping—every field, edge case, SSE state transition,
and error code—lives in the cross-language specification (`SPEC.md`) that all
five inference SDKs are tested against.

GPU infrastructure is a separate REST surface under `/v1/gpu/*`. Start with the
[GPU Infrastructure overview](/gpu-infrastructure) for the task-oriented flow,
then use the generated endpoint pages for exact request and response schemas.

## Endpoints & playground

Every public route is documented under **Endpoints** in the sidebar, generated from the
gateway's OpenAPI specification — each page includes an interactive playground that sends
real requests to `https://api.aireserve.com` with **your own API key** (paste it into the
Authorization field; [get one here](https://portal.aireserve.com/keys)).

The spec is exported straight from the gateway service's route schemas:

```bash theme={"dark"}
bun run apps/docs/scripts/export-openapi.ts
```


# Count tokens
Source: https://docs.aireserve.com/api-reference/messages/count-tokens

/api-reference/openapi.json post /v1/messages/count_tokens
Anthropic-shape token counting. Free — no inference is performed.



# Create message
Source: https://docs.aireserve.com/api-reference/messages/create-message

/api-reference/openapi.json post /v1/messages
Anthropic-compatible Messages endpoint. Claude Code, the Claude Agent SDK, and the Anthropic SDK connect here — and every gateway model answers, not just Claude.



# List models
Source: https://docs.aireserve.com/api-reference/models/list-models

/api-reference/openapi.json get /v1/models
Returns the OpenAI-shaped model list. Treat it as the source of truth for available model IDs.



# Mint realtime voice session
Source: https://docs.aireserve.com/api-reference/realtime/mint-realtime-voice-session

/api-reference/openapi.json post /v1/realtime/sessions
Mint a short-lived WebSocket credential for a realtime speech-to-speech session with xAI Grok Voice. Authenticates the caller, checks the `realtimeVoiceEnabled` org gate, resolves voice ownership, reserves worst-case session funds from the wallet, and returns `wss_url` plus an `ephemeral_key`. The key is an HMAC-SHA-256 signed opaque one-use relay ticket (valid 5 minutes); it encodes only expiry and a nonce — the authorized voice is stored in the session record, keyed by the ticket's SHA-256 hash. The relay verifies the HMAC, reads the session record by hash, and injects the authorized voice server-side at WebSocket open; the client cannot change the voice mid-session. Only audio I/O events are accepted; text output, transcription, tools, and session resumption are not supported in this release.



# Create response (Responses API)
Source: https://docs.aireserve.com/api-reference/responses/create-response-responses-api

/api-reference/openapi.json post /v1/responses
OpenAI Responses API — the wire format the Codex SDK and Codex CLI speak.



# OpenAI & Anthropic formats — native in the AI Reserve SDKs
Source: https://docs.aireserve.com/api-reference/sdk-wire-formats

All five AI Reserve SDKs speak all three gateway wire formats from one client — verbatim pass-throughs, no shape translation.

All five AI Reserve SDKs — Python, TypeScript, Go, Java, and Rust — speak all three of the gateway's wire formats
from one client: the Bedrock Converse surface you've seen above, plus **verbatim
pass-throughs of the OpenAI and Anthropic formats**. Same API key, same retries and
[exception taxonomy](/api-reference/errors), no extra dependency — and no shape translation:
requests go out exactly as you write them, responses come back exactly as the gateway
returns them. Both formats work with **every** gateway model; the gateway
bridges the wire format (GPT models answer Anthropic-format calls and vice versa).

| Surface | Endpoint | Wire format |
| - | - | - |
| `client.chat.completions.create(…)` | `POST /v1/chat/completions` | OpenAI Chat Completions |
| `client.messages.create(…)` | `POST /v1/messages` | Anthropic Messages (Claude Code's format) |
| `client.messages.count_tokens(…)` / `countTokens(…)` | `POST /v1/messages/count_tokens` | Anthropic Messages (free — no inference) |

## OpenAI format

```python Python theme={"dark"}
from audacity import Audacity

client = Audacity()   # reads AIRESERVE_API_KEY

response = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    max_tokens=256,
)
print(response["choices"][0]["message"]["content"])

# stream=True returns a generator of raw OpenAI chunks
for chunk in client.chat.completions.create(
    model="claude-sonnet-4-6",   # any gateway model
    messages=[{"role": "user", "content": "Write a haiku."}],
    stream=True,
):
    delta = chunk["choices"][0]["delta"] if chunk.get("choices") else {}
    print(delta.get("content", ""), end="", flush=True)
```

```typescript TypeScript theme={"dark"}
import { Audacity } from "@audacity/sdk";

const client = new Audacity(); // reads AIRESERVE_API_KEY

const response = await client.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "Hello!" }],
  max_tokens: 256,
});
console.log(response.choices[0]?.message?.content);

// stream: true switches the return type to an AsyncIterable of raw chunks
const stream = await client.chat.completions.create({
  model: "claude-sonnet-4-6", // any gateway model
  messages: [{ role: "user", content: "Write a haiku." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
}
```

```go Go theme={"dark"}
resp, err := client.Chat.Completions.Create(ctx, &audacityruntime.ChatCompletionCreateParams{
    Model:     "gpt-5.4-mini",
    Messages:  []map[string]interface{}{{"role": "user", "content": "Hello!"}},
    MaxTokens: audacity.Int32(256),
    Extra:     map[string]interface{}{"seed": 7}, // any other OpenAI field
})
if err != nil { log.Fatal(err) }
fmt.Println(resp.Raw["choices"])

// CreateStream returns raw chunk events; ends at data: [DONE]
stream, err := client.Chat.Completions.CreateStream(ctx, &audacityruntime.ChatCompletionCreateParams{
    Model:    "claude-sonnet-4-6", // any gateway model
    Messages: []map[string]interface{}{{"role": "user", "content": "Write a haiku."}},
})
if err != nil { log.Fatal(err) }
defer stream.Close()
for event := range stream.Events() {
    fmt.Print(event)
}
if err := stream.Err(); err != nil { log.Fatal(err) }
```

```java Java theme={"dark"}
Map<String, Object> resp = client.chat().completions().create(p -> p
    .model("gpt-5.4-mini")
    .addMessage("user", "Hello!")
    .maxTokens(256)
    .put("reasoning_effort", "low"));   // any field the gateway supports

// Streaming yields raw OpenAI chunks; ends at data: [DONE].
// The iterator holds a connection — use try-with-resources.
try (var stream = client.chat().completions().createStreaming(p -> p
        .model("claude-sonnet-4-6") // any gateway model
        .addMessage("user", "Write a haiku."))) {
    stream.forEachRemaining(System.out::println);
}
```

```rust Rust theme={"dark"}
let response = client.chat_completions().create(json!({
    "model": "gpt-5.4-mini",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 256,
})).await?;
println!("{}", response["choices"][0]["message"]["content"]);

// create_stream yields raw chunk objects; ends at data: [DONE]
let mut stream = client.chat_completions().create_stream(json!({
    "model": "claude-sonnet-4-6", // any gateway model
    "messages": [{"role": "user", "content": "Write a haiku."}],
})).await?;
while let Some(chunk) = stream.recv().await? {
    if let Some(delta) = chunk["choices"][0]["delta"]["content"].as_str() {
        print!("{delta}");
    }
}
```

## Anthropic format

```python Python theme={"dark"}
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response["content"][0]["text"])

# stream=True yields raw Anthropic events (message_start … message_stop)
for event in client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[{"role": "user", "content": "Write a haiku."}],
    stream=True,
):
    if event["type"] == "content_block_delta":
        print(event["delta"].get("text", ""), end="", flush=True)

# Free token counting
count = client.messages.count_tokens(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "How many tokens is this?"}],
)
print(count["input_tokens"])
```

```typescript TypeScript theme={"dark"}
const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(message.content[0]?.["text"]);

// stream: true yields raw Anthropic events (message_start … message_stop)
const events = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 256,
  messages: [{ role: "user", content: "Write a haiku." }],
  stream: true,
});
for await (const event of events) {
  if (event.type === "content_block_delta") {
    process.stdout.write((event["delta"] as { text?: string }).text ?? "");
  }
}

// Free token counting
const count = await client.messages.countTokens({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: "How many tokens is this?" }],
});
console.log(count.input_tokens);
```

```go Go theme={"dark"}
msg, err := client.Messages.Create(ctx, &audacityruntime.MessageCreateParams{
    Model:     "claude-sonnet-4-6",
    MaxTokens: audacity.Int32(256),
    Messages:  []map[string]interface{}{{"role": "user", "content": "Hello!"}},
})
if err != nil { log.Fatal(err) }
fmt.Println(msg.Raw["content"])

// Free token counting
count, err := client.Messages.CountTokens(ctx, &audacityruntime.CountTokensParams{
    Model:    "claude-sonnet-4-6",
    Messages: []map[string]interface{}{{"role": "user", "content": "How many tokens?"}},
})
if err != nil { log.Fatal(err) }
fmt.Println(count.Raw["input_tokens"])
```

```java Java theme={"dark"}
Map<String, Object> msg = client.messages().create(p -> p
    .model("claude-sonnet-4-6")
    .maxTokens(256)
    .addMessage("user", "Hello!"));

// Streaming yields raw Anthropic events (message_start … message_stop)
try (var events = client.messages().createStreaming(p -> p
        .model("claude-sonnet-4-6")
        .maxTokens(256)
        .addMessage("user", "Write a haiku."))) {
    events.forEachRemaining(System.out::println);
}

// Free token counting
Map<String, Object> count = client.messages().countTokens(p -> p
    .model("claude-sonnet-4-6")
    .addMessage("user", "How many tokens?"));
System.out.println(count.get("input_tokens"));
```

```rust Rust theme={"dark"}
let message = client.messages().create(json!({
    "model": "claude-sonnet-4-6",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}],
})).await?;
println!("{}", message["content"][0]["text"]);

// Streaming yields raw Anthropic events (message_start … message_stop)
let mut events = client.messages().create_stream(json!({
    "model": "claude-sonnet-4-6",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Write a haiku."}],
})).await?;
while let Some(event) = events.recv().await? {
    if event["type"] == "content_block_delta" {
        print!("{}", event["delta"]["text"].as_str().unwrap_or(""));
    }
}

// Free token counting
let count = client.messages().count_tokens(json!({
    "model": "claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "How many tokens?"}],
})).await?;
println!("{}", count["input_tokens"]);
```

> [!NOTE]
>
> **Pass-through means future-proof.** The SDK never renames or strips request
> fields, so any parameter the gateway supports — including ones added after your SDK
> version shipped — works immediately. Streaming follows each provider's own protocol:
> OpenAI streams end at `data: [DONE]`; Anthropic streams end with a
> `message_stop` event. Mid-stream errors raise
> `ModelStreamErrorException`, and standard HTTP errors map through the same
> [taxonomy](/api-reference/errors) as Converse calls (429 retried with backoff, budget errors
> never retried).

Available in all five SDKs from v0.5.0: `audacity-sdk` (Python),
`@audacity/sdk` (TypeScript), `audacity-sdk-go` (Go),
`com.audacityinvestments:audacity-sdk` (Java), and `audacity-sdk`
(Rust). Prefer no new dependency at all? Point the official
`openai`/`anthropic` packages at the gateway
([guide](/connect)).


# Live data and web search
Source: https://docs.aireserve.com/api-reference/search/live-data-and-web-search

/api-reference/openapi.json post /v1/search
Search Tako's curated knowledge graph (finance, macro, companies, sports, weather) and the live web in one call. Returns knowledge cards — interactive, embeddable data visualizations with named sources — plus web results, with no LLM in the loop. Billed per search (`tako-search`; `deep` effort as `tako-search-deep`). Nothing calls Tako unless you call this route; register it as a tool and let the model decide when a turn needs live data.



# Versioning & support
Source: https://docs.aireserve.com/api-reference/versioning-and-support

Semantic versioning, cross-language conformance, request IDs, and licensing for the AI Reserve SDKs.

* **Versioning.** All SDKs follow semantic versioning from `0.1.x`. The Bedrock-parity surface (`Converse`, `ConverseStream`, content blocks, exceptions) is treated as stable; additions are backwards-compatible.
* **Conformance.** Every release of every SDK passes the shared cross-language conformance suite — request mapping, stream-event ordering, both server error shapes, retry behavior, SSE edge cases (split UTF-8 runes, oversized lines, comment frames) — fully offline and deterministic.
* **Request IDs.** Every server error carries a `requestId`. Include it when contacting us and we can trace the exact request through the gateway.
* **License.** The SDKs are source-available under a proprietary license. © 2026 Audacity Advisory Corp. AI Reserve is a trade name of Audacity Advisory Corp. All rights reserved.

Ready to start? [Get an API key](https://portal.aireserve.com/keys),
install the SDK for your language, and your first Converse call is five lines away.


# Get video generation job
Source: https://docs.aireserve.com/api-reference/videos/get-video-generation-job

/api-reference/openapi.json get /v1/videos/generations/{job_id}
Read the status/result of a video-generation job



# Submit video generation job
Source: https://docs.aireserve.com/api-reference/videos/submit-video-generation-job

/api-reference/openapi.json post /v1/videos/generations
Create an async video-generation job



# Bring your own key (BYOK)
Source: https://docs.aireserve.com/capabilities/byok

Run some or all of your traffic on your organization's own provider API keys — billed by the provider directly, with AI Reserve governance intact.

Your organization can bring its own provider API keys. When an admin saves a
key for a supported provider, every request your organization sends to that
provider's models — from any AI Reserve API key, coding tool, or web chat —
is dispatched on **your** key, so the provider bills your account directly.
Everything else about the platform keeps working: per-user attribution,
analytics, quotas and access controls, team governance, and audit logging.

Providers you have not configured are untouched: their traffic keeps running
on platform keys with standard billing. BYOK is opt-in, per provider, and
reversible at any time.

## Supported providers

| Provider | Models it covers | Notes |
| - | - | - |
| OpenAI | `gpt-*` (direct API) | |
| Anthropic | `claude-*` served on Anthropic's API | `-bedrock` / `-vertex` variants are AWS/Google-billed and stay on platform keys |
| xAI (Grok) | `grok-*` | |
| DeepSeek | DeepSeek's own API legs (`deepseek-chat`, `deepseek-reasoner`, `deepseek-v4-pro-deepseek`) | Aggregator-served DeepSeek models (e.g. `deepseek-v4-flash` on Fireworks) stay on platform keys |
| Moonshot (Kimi) | `kimi-*` / `moonshot-*` served on Moonshot's API | Aggregator-served Kimi variants stay on platform keys |

A model is covered exactly when the provider **bills** for it. Models served
through aggregators (Together, Fireworks, DeepInfra, …), AWS Bedrock, Google
Vertex, or Azure are different billing relationships and are not covered by a
maker key — the platform serves them as usual. Google Gemini is not yet
supported: large file attachments are platform-managed in a way that is
incompatible with customer keys today.

Coverage applies to chat traffic on all three API surfaces —
`/v1/chat/completions`, `/v1/messages` (Claude Code and Anthropic SDKs), and
`/v1/responses` (Codex) — plus web chat. Embeddings, image, video, and audio
endpoints stay on platform keys for now.

## Billing

Requests served on your own key record **\$0** in AI Reserve usage — the
provider bills your account directly, and charging our standard rate on top
would double-bill you. The requests stay fully visible in analytics (tokens,
models, users, teams) and are marked as BYOK in the usage ledger, so your
spend reporting can separate platform-billed from provider-billed traffic.

> [!NOTE]
>
> A platform fee for traffic served on customer keys is an **open pricing
> decision** — v1 deliberately charges \$0 and does not invent one. If a fee is
> introduced it will be announced explicitly; nothing in the current behavior
> implies or precludes it.

Spend caps and budget alerts operate on platform-billed cost, so \$0 BYOK
usage does not consume them — and, by the same token, an organization-wide
spend cap does **not** limit BYOK traffic: use your provider account's own
limits to cap provider-billed spend. Request-level quotas, model access
rules, and team controls apply to BYOK traffic exactly as before.

## Security

* Keys are encrypted at rest with AES-256-GCM (the same envelope scheme that
  protects other platform-held secrets) and decrypted only inside the
  gateway at the moment of dispatch.
* After saving, a key is displayed only as its last 4 characters — it is
  never shown, exported, or included in API responses again.
* Keys are never written to logs, error records, or analytics rows.
* Saving, replacing, and removing keys are admin-only actions, recorded in
  both audit trails (the internal audit log and your organization's
  Activity page).

## Behavior details

* **Fail-safe.** No key configured for a provider, or a key that cannot be
  decrypted, means traffic serves on platform keys exactly as today — never
  an error.
* **No cross-provider fallbacks.** Requests on your key never fall back to a
  different provider (that would either move your traffic somewhere your key
  doesn't apply or send your key where it doesn't belong). If the provider
  has an outage, those requests return the provider's real error. Remove the
  key to restore platform serving — including configured fallback chains —
  at any time. One caveat: when the platform's own provider health checks
  reroute traffic away from a degraded provider before your key is applied,
  the rerouted requests may serve on a fallback provider you have no key
  for — those requests run on platform keys at standard platform rates,
  never on your key.
* **Your key, your rate limits.** Traffic on your key runs under your
  provider account's rate limits and quotas, not the platform's pooled
  capacity.
* **Key problems surface honestly, and say so.** If your provider rejects
  the key (for example after you revoke it upstream), runs out of credit, or
  rate-limits your account, requests to that provider fail until you fix the
  key, top up, or remove the key — the platform does not silently switch you
  back to platform billing. The error names your key, the provider, and both
  fixes, and carries a stable code: `BYOK_KEY_INVALID` (401/403),
  `BYOK_BALANCE_EXHAUSTED` (402), or `BYOK_RATE_LIMITED` (429), with
  `details.byok: true` and `details.provider`. Any other upstream error on a
  request that used your key keeps the provider's status and opens with
  "This request used your organization's own … API key".
* **Auto model routing.** Requests with `model: "auto"` pick the best model
  first and check keys second — auto can select a provider you have no key
  for, and those requests serve on platform keys at standard platform rates.
  Pin a covered provider's model when a request must ride your key.
* **Propagation.** Saving, replacing, or removing a key applies within about
  a minute.

## Set it up

1. In the portal, open your organization's admin console and go to the
   **API Keys** tab.
2. Under **Provider keys**, choose **Add key** next to a provider and paste
   an API key from that provider's console.
3. Verify with a request to one of that provider's models — the usage row
   records \$0 and is marked BYOK.

Replace a key in place at any time (for rotation), or remove it to return
that provider's traffic to platform keys and standard billing.


# Chat specialists
Source: https://docs.aireserve.com/capabilities/chat-specialists

Optional expert modes your team can attach to individual web-chat conversations — off by default, enabled per organization by an admin.

Web chat starts every conversation with a standard, general-purpose
assistant. **Specialists** are optional expert modes a user can attach to an
individual conversation: attaching one adds focused instructions and extra
tools for that conversation only. Nothing changes for anyone else, and
nothing changes by default.

## Available specialists

| Specialist | What it adds |
| - | - |
| Investment Advisor | Investment-grade research on private companies and funds: company, fund, contact, and team lookups across AI Reserve's market datasets (including contact details enriched from third-party data providers), comparable analysis, and diligence questions. |

The catalog is maintained by AI Reserve and grows over time; there is no
custom specialist editor today.

## Turning specialists on (admins)

Specialists are **off for every organization until an enterprise admin
enables them**, one by one:

1. Open **Admin → your organization → Privacy**.
2. In the **Web chat** section (specialists require web chat to be enabled),
   check each specialist you want to make available.

Unchecking a specialist takes effect within about a minute: conversations
that had it attached fall back to the standard assistant on their next
message — nothing breaks and no history is lost.

Turning web chat off hides specialists everywhere along with it. Your
selection is remembered, so re-enabling chat brings back the same
specialists without setting them up again.

## Using a specialist (everyone)

1. In the chat composer, open the **Specialist** picker next to the model
   picker (it only appears when your organization has at least one
   specialist enabled).
2. Pick a specialist — or **None** for the standard assistant, which is
   always the default.

The choice sticks to that conversation and applies from your next message. An
active specialist shows as a chip at the top of the conversation, so it is
never ambiguous which mode you are in. Switching back to **None** at any
point returns that conversation to the standard assistant.

## Privacy and billing

Specialists change the assistant's instructions and available tools —
nothing else. Model choice, data-source toggles, content-retention settings,
usage metering, and billing are all unchanged.

Two things worth knowing before enabling a specialist:

* **Tools reach shared datasets.** A specialist's lookup tools query AI
  Reserve's market datasets, which draw on third-party data providers —
  including contact details such as emails and phone numbers. The admin
  checkbox for each specialist describes exactly what it adds.
* **Tool lookups are separate from model usage.** Specialist tool calls hit
  data providers directly and do not appear on the model-usage meter; only
  the assistant's model responses are metered as usual.
* **Contact enrichment is capped.** Lookups that enrich contact details from
  third-party providers are limited to 15 per conversation and 200 per day
  across your organization. When a cap is reached the assistant says so in
  the conversation and keeps working with what it already found — start a new
  conversation, or wait for the daily reset (midnight UTC), to run more.


# Managed content moderation
Source: https://docs.aireserve.com/capabilities/content-moderation

Screen your organization's traffic against a managed content policy at the gateway — one policy, every covered model, no code changes.

> [!NOTE]
>
> Managed content moderation is **available on request**. Contact AI Reserve to
> define your organization's policy and have it enabled — nothing changes for
> your traffic until you do.

Managed content moderation screens the user-authored input of your
organization's requests against a content policy the platform provisions and
operates for you. When the policy blocks a request, the caller gets a clean,
stable error instead of a model response — before the request ever reaches a
model provider.

You cannot attach your own AWS Bedrock guardrail to gateway requests
(guardrails are account-scoped AWS resources, so a `guardrailConfig` in a
Converse request is rejected honestly rather than silently ignored). Managed
moderation is the supported path: AI Reserve provisions and manages the
policy in its own infrastructure and applies it to your traffic at the
gateway — so on the covered endpoints, one policy applies to every model you
route through them, not just Bedrock-served ones.

## How a block looks

On `/v1/chat/completions`, blocked requests answer `400` with a stable error
code your integration can branch on:

```json theme={"dark"}
{
  "success": false,
  "error": {
    "code": "CONTENT_BLOCKED_BY_POLICY",
    "message": "Your organization's content policy blocked this request. Rephrase and try again, or contact your administrator if you believe this is a mistake.",
    "details": {
      "reason": "content_blocked_by_policy",
      "categories": ["HATE"]
    }
  }
}
```

`categories` names the policy classes that fired (for example `VIOLENCE`,
`PROMPT_ATTACK`, or `topic:<your denied topic>`) — never the content itself.

On the Bedrock Converse surface, blocks arrive in the AWS error dialect your
SDK already understands: a `400 ValidationException` whose message is the
same block copy shown above. The `CONTENT_BLOCKED_BY_POLICY` code and
`categories` detail are not carried in the AWS wire shape — if your
integration needs to branch on them, use `/v1/chat/completions`.

## Behavior details

* **Off by default.** Moderation runs only for organizations that requested
  it. Everyone else's requests are untouched — no added latency, no policy
  calls.
* **Input screening, before dispatch.** The user-authored text of a request
  is screened before any model call, wallet charge, or content logging —
  blocked input is never sent to a provider or persisted. Streaming requests
  are blocked before the stream opens; served streams are never interrupted.
* **Coverage.** `/v1/chat/completions` and the Bedrock Converse surface
  (streaming and non-streaming). The Anthropic-native (`/v1/messages`) and
  Responses (`/v1/responses`) endpoints are not yet screened — if your
  traffic uses them, tell us when you request enablement and we'll scope
  them in.
* **Fails open, loudly.** If the moderation backend is unreachable, requests
  serve unmoderated rather than failing — availability first — and each
  degradation window is recorded in the platform's audit log.
* **Content-free audit trail.** Blocks are logged as policy category +
  organization + request id. The screened text itself is never written to
  moderation logs.

## Set it up

1. Contact AI Reserve (your account contact, or the address on the portal's
   Help page) and describe the policy you need — denied topics, content
   filters, and how strict each should be.
2. We provision the policy, enable it for your organization, and confirm.
3. Verify with a request that violates the policy — it should answer `400
   CONTENT_BLOCKED_BY_POLICY`.

Policy changes (adding a topic, relaxing a filter) go through the same
channel and apply without any change on your side.


# Customer attribution
Source: https://docs.aireserve.com/capabilities/customer-attribution

Tag each request with your own customer (and optionally a feature) to see spend per customer in Analytics — no change to routing, billing, or auth.

If you build a product on top of AI Reserve, your usage rolls up to one organization — but
you usually want to know what each of **your** customers costs you. Customer attribution lets
you tag every request with your own customer id (and, optionally, the feature that made the
call). The gateway records both on the usage record for that request, and the portal's
Analytics page breaks spend down by customer.

Tags are reporting-only. They never change which model serves a request, what it costs, or
whether it is allowed. Requests without a tag behave exactly as before.

There are two ways to get the customer id onto a request: tag each request yourself (the three
options below, best when your own backend calls AI Reserve for many customers through one key),
or hand each customer a [customer key](#option-c-customer-keys-recommended) that carries the id
for them.

## Three ways to tag a request

The gateway reads the customer id from the first of these that is present, in this order:

| Where | Field | Works on |
| - | - | - |
| Request header | `x-aireserve-customer: <id>` | Every endpoint |
| OpenAI-compatible body | `"user": "<id>"` | `/v1/chat/completions`, `/v1/responses`, `/v1/images/generations` |
| Anthropic body | `"metadata": {"user_id": "<id>"}` | `/v1/messages` |

If you already pass `user` to the OpenAI SDK or `metadata.user_id` to the Anthropic SDK, you
are done — the gateway picks those up with no code change and still forwards the fields to
the provider unchanged. The header is for everything else (Bedrock-style `/model/…/converse`,
text-to-speech, GPU endpoints) and for when you want one mechanism across every SDK.

```bash curl theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "x-aireserve-customer: cust_8f3a2b" \
  -H "x-aireserve-feature: draft-email" \
  -d '{
    "model": "gpt-5.5",
    "messages": [{"role": "user", "content": "Draft a follow-up to the Acme call."}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

# Option A — the OpenAI `user` field; no header needed.
res = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Draft a follow-up to the Acme call."}],
    user="cust_8f3a2b",
)

# Option B — headers; add the optional feature tag too.
res = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Draft a follow-up to the Acme call."}],
    extra_headers={
        "x-aireserve-customer": "cust_8f3a2b",
        "x-aireserve-feature": "draft-email",
    },
)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

// Option A — the OpenAI `user` field; no header needed.
await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "Draft a follow-up to the Acme call." }],
  user: "cust_8f3a2b",
});

// Option B — headers; add the optional feature tag too.
await client.chat.completions.create(
  {
    model: "gpt-5.5",
    messages: [{ role: "user", content: "Draft a follow-up to the Acme call." }],
  },
  {
    headers: {
      "x-aireserve-customer": "cust_8f3a2b",
      "x-aireserve-feature": "draft-email",
    },
  },
);
```

On the Anthropic surface the SDK's own `metadata.user_id` is enough:

```python theme={"dark"}
message = anthropic_client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Draft a follow-up to the Acme call."}],
    metadata={"user_id": "cust_8f3a2b"},
)
```

## Option C: customer keys (recommended)

When the requests come from the customer's own systems — a reseller integration, a tenant you
onboard with their own credentials — give that customer a **customer key** instead of asking
them to tag anything. A customer key is one of your organization's API keys bound to one
customer id: every request made with it is billed to you and reported under that customer,
with nothing to add to the request. Add the customer's **organization / sub-account** and the
key becomes a **sub key** that also splits the customer's spend by their organizations
(`cust_8f3a2b › emea`).

Create them in the portal — **Keys → Create key → One of your customers** (enterprise admins)
— or over the API with one of your organization-level keys:

```bash curl theme={"dark"}
# A key for the customer
curl -X POST "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Acme production"}'

# A sub key for one of the customer's organizations
curl -X POST "https://api.aireserve.com/v1/customers/cust_8f3a2b/keys" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"org_id": "emea"}'
```

```python Python theme={"dark"}
import os, requests
from urllib.parse import quote

headers = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}
customer_id = "cust_8f3a2b"

created = requests.post(
    f"https://api.aireserve.com/v1/customers/{quote(customer_id, safe='')}/keys",
    json={"org_id": "emea"},
    headers=headers,
).json()
secret = created["key"]  # shown once — hand it to the customer and store it
```

```typescript TypeScript theme={"dark"}
const customerId = "cust_8f3a2b";
const created = await fetch(
  `https://api.aireserve.com/v1/customers/${encodeURIComponent(customerId)}/keys`,
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ org_id: "emea" }),
  },
).then((r) => r.json());
const secret = created.key; // shown once — hand it to the customer and store it
```

The response carries the plaintext key exactly once. The customer then calls AI Reserve with it
like any other key — same base URL, endpoints, and limits as your organization. A customer
key's binding always wins: if the customer's code also sends `x-aireserve-customer` or `user`,
the key's customer is what gets reported. The `x-aireserve-feature` tag below still works on a
customer key.

Each customer key on the Keys page carries a *Customer* badge and a **Spend for this customer**
link straight into Analytics, where a customer with sub keys expands into its organizations in
the *Spend by Customer* card. Listing and revoking keys, the error codes, and the full schemas
are on the [Customer keys](/api-reference/customer-keys) reference page.

## The optional feature tag

`x-aireserve-feature` names the feature or action inside your product that made the call —
`draft-email`, `summarize-thread`, `nightly-sync`. It is recorded next to the customer id on
every usage record and comes along in exports, so you can later split one customer's spend by
what they used. It is header-only and entirely optional.

## Limits and validation

| Tag | Header | Max length | Allowed characters |
| - | - | - | - |
| Customer id | `x-aireserve-customer` | 128 | Printable characters (no control characters) |
| Feature | `x-aireserve-feature` | 64 | Printable characters (no control characters) |

Values are trimmed of surrounding whitespace. A tag that is empty, too long, or contains
control characters is **ignored** — the request is served and billed normally, it just lands
as untagged. Tagging never produces an error response. When the header is invalid but the body
carries a valid `user` / `metadata.user_id`, the body value is used.

> [!WARNING]
>
> **Use opaque ids, never emails or names.** Send the identifier your own system uses for the
> customer (`cust_8f3a2b`, a UUID, a tenant slug). Tags are stored on usage records and appear
> in Analytics and in exports; personal data does not belong there.

## Where it shows up

* **Analytics → Spend by Customer.** The portal's Analytics page gains a *Spend by Customer*
  card listing your top 25 customers in the selected date range by spend, with requests,
  tokens, and each customer's share of spend. An *(untagged)* row holds every request that
  carried no customer id, so the table always reconciles with the period total. The card
  appears only once at least one request in the range carried a customer id; it follows the
  same date range and team/member filters as every other card.
* **CSV / JSON download.** Each card downloads its own rows (`endCustomerId`, `requests`,
  `tokens`, `spendUsd`, `spendShare`), and the page-level *Download all data (JSON)* includes
  the same breakdown.
* **The API.** `GET /v1/customers/usage` returns the same figures per customer — plus, once
  your organization has [pricing rules](#pricing-you-charge), what each customer owes and your
  margin — and `GET /v1/customers/{customerId}/usage` drills into one customer. See
  [Check the amount](#check-the-amount-api).

> [!NOTE]
>
> Requests whose results are produced by a background job after the call returns — image
> edits and video generation — are not attributed to a customer yet. Everything served inline
> (chat, messages, responses, image generation, speech, Bedrock-style converse, GPU chat
> completions) is.

## Pricing you charge

Spend by Customer tells you what each customer **cost you**. Pricing rules add what each
customer **owes you**: a rule is the price your organization charges for a slice of its tagged
usage, and every matched request is priced with it, so revenue and margin sit next to cost in
the [usage API](#check-the-amount-api). Each rule has a *scope* (which customers and features
it covers), a *kind* (how the amount is computed), and an *effective window* (the period of
usage it prices).

| Kind | What the customer is charged |
| - | - |
| Markup | Your cost plus a percentage — a 20% markup bills a request that cost you $0.010 at $0.012 |
| Per request | A fixed amount for every successful request |
| Per token | Your own rate card: a price per 1M prompt tokens and a price per 1M completion tokens |
| Monthly flat | A fixed fee for every UTC calendar month in which the customer made at least one matched request |

| Scope | Applies to |
| - | - |
| All customers | Every tagged request — your default price |
| One customer | Every request tagged with that customer id |
| One feature | Every tagged request carrying that `x-aireserve-feature` tag, whoever the customer |
| One customer and one feature | Exactly that pair |

When several rules cover a request, the **most specific scope wins**: customer and feature,
then customer only, then feature only, then all customers. Within one scope, the rule whose
window covers the request's UTC day and has the latest *effective from* wins, so a price change
is a new rule with a later start — the old one keeps pricing the usage it covered. A window may
start in the future (a scheduled price) and may be closed with an end date; closing it never
rewrites history. Usage that no rule covers is reported **at cost** and flagged `priced: false`,
so a gap in your price list shows up as a visible zero margin rather than a quietly wrong total.

How the amounts come together:

* Markup, per-request, and per-token rules are applied to each successful request and summed.
  A monthly flat fee is booked once per customer per UTC month, on the first day in that month
  with matched usage, and is never pro-rated.
* **Failed requests are never billed to a customer.** They are left out of `requests` and the
  token counts. Their cost still counts toward `cost_usd`, so your cost reconciles with the
  rest of Analytics.
* Amounts are USD with six decimals, rounded half away from zero once per request. Margin is
  `billable − cost`; margin percent is `margin ÷ billable × 100`, two decimals, and `null` when
  nothing was billable.
* As soon as one rule applies to the period, every report row carries `billable_usd`,
  `margin_usd`, and `margin_pct` next to `cost_usd` (`has_pricing_rules: true`). The `untagged`
  bucket stays cost-only — nothing can be billed to a customer you did not name.

> [!NOTE]
>
> Pricing rules are reporting-only, like the tags themselves. They never change what AI
> Reserve charges your organization, and AI Reserve does not invoice your customers for you —
> the figures are there for you to bill from.

### In the portal

Organization admins manage rules under **Analytics → Customer pricing** (also reachable from
*Set prices* on the Spend by Customer card). The list shows every rule's scope, price, window
and status — *Active*, *Scheduled*, or *Ended*. *Add rule* asks who the price is for, then how
you charge, and reads the rule back in one sentence before saving. *Change price* starts a new
version and ends the current one where it begins; *End* stops a rule from now, or removes one
that has not started yet.

Once one rule covers the selected range, the **Spend by Customer** card adds **Revenue** and
**Margin** (amount and percent) to every customer row, to each organization under it, and in a
totals line; a *By feature* view breaks the same figures down by `x-aireserve-feature` tag. A
negative margin is labelled *Loss*, a gross margin under 20% *Low margin*, usage that no rule
covers *No rule* (shown at cost, with a link to add one), and a group where only some usage was
priced *Partly priced*. The card's CSV gains `costUsd`, `revenueUsd`, `marginUsd`, `marginPct`
and `priced` columns. The figures are the ones `GET /v1/customers/usage` returns for the same
range: the same engine prices both, so the portal and the API never disagree. Margin is an
organization-wide figure — it is computed for the whole organization, not for a team or member
filter — and, like the API, for ranges of up to 92 days.

## Check the amount (API)

Two read endpoints return usage, cost, and — with pricing rules — billable amount and margin per
customer, so your own billing or support tooling can answer "what does this customer owe?".
Both take your AI Reserve API key and are scoped to the organization that owns it.

| Endpoint | Returns |
| - | - |
| `GET /v1/customers/usage` | Every customer in the period, plus an `untagged` bucket and totals |
| `GET /v1/customers/{customerId}/usage` | One customer, broken down by feature (`group_by=feature`, the default) or by UTC day (`group_by=day`), plus any monthly flat fees booked |

`start` is inclusive and `end` exclusive; both accept a UTC date (`2026-10-01`) or an RFC 3339
timestamp. Leave them out for the last 30 days. A period may span at most 92 days — longer
ranges and malformed dates return `400`. The customer id in the path is URL-encoded, exactly as
you tagged it; an id you never tagged returns zeros, not `404`.

```bash curl theme={"dark"}
# Every customer, last 30 days
curl "https://api.aireserve.com/v1/customers/usage" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"

# One customer, September, by feature
curl "https://api.aireserve.com/v1/customers/cust_8f3a2b/usage?start=2026-09-01&end=2026-10-01" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

```python Python theme={"dark"}
import os, requests
from urllib.parse import quote

headers = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

# Every customer, last 30 days
report = requests.get("https://api.aireserve.com/v1/customers/usage", headers=headers).json()
for row in report["customers"]:
    print(row["customer_id"], "cost", row["cost_usd"], "owes", row.get("billable_usd"))

# One customer, September, by feature
customer_id = "cust_8f3a2b"
statement = requests.get(
    f"https://api.aireserve.com/v1/customers/{quote(customer_id, safe='')}/usage",
    params={"start": "2026-09-01", "end": "2026-10-01", "group_by": "feature"},
    headers=headers,
).json()
print(statement["totals"]["billable_usd"])
```

```typescript TypeScript theme={"dark"}
const headers = { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` };

// Every customer, last 30 days
const report = await fetch("https://api.aireserve.com/v1/customers/usage", { headers }).then((r) => r.json());
for (const row of report.customers) {
  console.log(row.customer_id, "cost", row.cost_usd, "owes", row.billable_usd);
}

// One customer, September, by feature
const customerId = "cust_8f3a2b";
const params = new URLSearchParams({ start: "2026-09-01", end: "2026-10-01", group_by: "feature" });
const statement = await fetch(
  `https://api.aireserve.com/v1/customers/${encodeURIComponent(customerId)}/usage?${params}`,
  { headers },
).then((r) => r.json());
console.log(statement.totals.billable_usd);
```

A per-customer response for an organization with two rules — a 20% markup on this customer's
`draft-email` feature, and a \$99 monthly flat fee for everything else the customer does:

```json theme={"dark"}
{
  "customer_id": "cust_8f3a2b",
  "period": { "start": "2026-09-01T00:00:00.000Z", "end": "2026-10-01T00:00:00.000Z" },
  "currency": "USD",
  "has_pricing_rules": true,
  "truncated": false,
  "group_by": "feature",
  "groups": [
    {
      "feature": "draft-email",
      "requests": 1240,
      "prompt_tokens": 2810400,
      "completion_tokens": 611200,
      "cost_usd": "18.421300",
      "billable_usd": "22.105560",
      "margin_usd": "3.684260",
      "margin_pct": 16.67,
      "priced": true
    },
    {
      "feature": null,
      "requests": 35,
      "prompt_tokens": 40100,
      "completion_tokens": 9800,
      "cost_usd": "0.312400",
      "billable_usd": "99.000000",
      "margin_usd": "98.687600",
      "margin_pct": 99.68,
      "priced": true
    }
  ],
  "totals": {
    "requests": 1275,
    "prompt_tokens": 2850500,
    "completion_tokens": 621000,
    "cost_usd": "18.733700",
    "billable_usd": "121.105560",
    "margin_usd": "102.371860",
    "margin_pct": 84.53,
    "priced": true
  },
  "monthly_flat_charges": [{ "month": "2026-09", "day": "2026-09-01", "amount_usd": "99.000000" }]
}
```

The flat fee is booked on the customer's first matched usage of the month and included in that
row's `billable_usd`; requests under a monthly flat rule add nothing per request. Had a feature
matched no rule at all, its row would show `billable_usd` equal to `cost_usd` and
`priced: false`.

| Field | Meaning |
| - | - |
| `cost_usd` | What the usage cost your organization — your billed AI Reserve cost. A six-decimal USD string, never a float. |
| `billable_usd` | What the customer owes under your price list. Present only when `has_pricing_rules` is `true`. |
| `margin_usd`, `margin_pct` | `billable − cost`, and that as a percentage of `billable` (two decimals, `null` when nothing was billable). Present only with pricing rules. |
| `priced` | `true` when every request in the row matched a rule. `false` when some usage was counted at cost. |
| `has_pricing_rules` | Whether any rule of yours applies to the period. When `false`, the billable and margin fields are omitted everywhere — there is no price list to apply. |
| `untagged` | Org-wide endpoint only: requests that carried no customer id, cost only, so the report reconciles with your period total. |
| `monthly_flat_charges` | Per-customer endpoint only: each monthly fee booked in the period. Already included in `billable_usd`. |
| `truncated` | `true` when the period held more usage rows than one response carries. Narrow the period or query one customer. |

Both endpoints share your organization's API rate limit and return the standard
[error shape](/api-reference/errors) — `401` for a missing key, `403` when a screen rejects
it, `429` with `Retry-After`. Full request and response schemas are under *Customers* in the
[API reference](/api-reference).


# Data endpoints
Source: https://docs.aireserve.com/capabilities/data-endpoints

Discover and run third-party data endpoints — web scrapers, contact and company enrichment, search — through monid.ai, on your AI Reserve key and wallet.

The gateway brokers [monid.ai](https://monid.ai)'s marketplace of pay-per-run **data
endpoints** under `/v1/monid`, with the same API key, rate limits, wallet, and spend caps
as every other route. You never create a monid account or hold a monid key: AI Reserve
holds one workspace, every run is billed to your AI Reserve wallet at monid's published
price for that endpoint, and each run appears in your usage analytics under the model
`monid:<provider><endpoint>`.

Three verbs, mirroring monid's own API so their published request and response shapes
apply unchanged:

1. `POST /v1/monid/discover` — search endpoints in natural language. Free.
2. `POST /v1/monid/inspect` — read one endpoint's input schema and price. Free.
3. `POST /v1/monid/run` — execute an endpoint. Billed. Sync providers answer inline;
   async providers answer **202** and you poll `GET /v1/monid/runs/{job_id}`.

> [!NOTE]
>
> **Availability.** The surface answers `503` with code `SERVICE_UNAVAILABLE` until the
> platform's monid workspace is provisioned in your environment. Discover and inspect are
> free upstream and never touch your wallet.

## Quickstart

```bash theme={"dark"}
# 1) Discover — free
curl -s https://api.aireserve.com/v1/monid/discover \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "recent tweets about a topic", "limit": 5}'

# 2) Inspect — free; read the input schema and price
curl -s https://api.aireserve.com/v1/monid/inspect \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider": "apify", "endpoint": "/apidojo/tweet-scraper"}'

# 3) Run — billed to your wallet
RUN=$(curl -s -w '\n%{http_code}' https://api.aireserve.com/v1/monid/run \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "apify",
    "endpoint": "/apidojo/tweet-scraper",
    "input": {"searchTerms": ["AI"], "maxItems": 10}
  }')
BODY=$(echo "$RUN" | sed '$d'); CODE=$(echo "$RUN" | tail -n1)

# 4) Async providers answer 202 — poll by the AI Reserve job id
if [ "$CODE" = "202" ]; then
  JOB_ID=$(echo "$BODY" | jq -r .aireserve.job_id)
  while :; do
    BODY=$(curl -s "https://api.aireserve.com/v1/monid/runs/$JOB_ID" \
      -H "Authorization: Bearer $AIRESERVE_API_KEY")
    case "$(echo "$BODY" | jq -r .aireserve.status)" in succeeded|failed) break ;; esac
    sleep 3
  done
fi
echo "$BODY" | jq .
```

## Run request

| Field | Required | Description |
| - | - | - |
| `provider` | yes | Provider slug from discover/inspect (e.g. `apify`, `pdl`) |
| `endpoint` | yes | Endpoint path from discover/inspect (e.g. `/apidojo/tweet-scraper`) |
| `input` | no | Parameters matching the endpoint's `input` schema from inspect. Defaults to `{}` |
| `price` | no | The `price` object returned by discover/inspect for this endpoint. Optional; when supplied it sizes the submit-time wallet reserve exactly. The final charge always comes from monid's reported cost |

## Run response

The body is monid's run object, with one AI Reserve addition:

```json theme={"dark"}
{
  "runId": "01HXYZ1234567890ABCDEF",
  "provider": "pdl",
  "endpoint": "/person/enrich",
  "status": "COMPLETED",
  "output": { "full_name": "…" },
  "providerResponse": { "httpStatus": 200 },
  "price": { "type": "PER_CALL", "amount": { "value": 0.003, "currency": "USD" } },
  "billedUnits": 1,
  "aireserve": {
    "job_id": "0b2f9f7e-1111-4a5b-9c3d-abcdefabcdef",
    "status": "succeeded",
    "created_at": 1789700000,
    "completed_at": 1789700001,
    "error": null
  }
}
```

* `aireserve.job_id` is the identifier you poll and the `request_id` of the run in your
  usage analytics. monid's `runId` is an upstream identifier and is **not** accepted by
  `GET /v1/monid/runs/{job_id}`.
* **HTTP status mirrors the brokered provider on sync runs.** A `404` with
  `status: "COMPLETED"` and `providerResponse.httpStatus: 404` means the run finished and
  the provider found no match — that is a result, not a gateway error, and monid does not
  charge for it (`billedUnits: 0`, and nothing is debited from your wallet). Check
  `aireserve.status` for the run lifecycle and `providerResponse.httpStatus` for the
  provider's answer.
* `202` means the provider executes asynchronously; `aireserve.status` is `queued` or
  `running` until you poll a terminal state. Most runs complete within 1–120 seconds.

## Billing

* **Price** — monid's published price for the endpoint (`PER_CALL` flat, or `PER_RESULT`
  with an optional base fee), shown in every discover, inspect, and run response. There is
  no markup: you pay what monid charges.
* **Reserve, then settle** — a run reserves the endpoint's per-call price (or base fee plus
  one result) against your wallet at submit and settles the actual charge from monid's
  reported cost at completion. Runs the provider errored on settle at `$0`.
* **Analytics** — one usage row per run: model `monid:<provider><endpoint>`, provider
  `monid`, `media_kind: "data"`, `media_count` = units billed. Team, user, and key
  attribution and spend caps apply exactly as for chat.
* **Caps** — runs count against your per-client rate limits, and in-flight runs are capped
  per organization (25 concurrent, \$25 estimated in flight) to bound a runaway loop.

## Data handling

monid is a broker: the `input` you send is forwarded by monid to the third-party data
endpoint you selected, whose own terms apply. AI Reserve keeps only the billing skeleton of
a completed run (endpoint identity, price, units) — never the input or output content. See
the [data-handling matrix](https://privacy.aireserve.com/data-handling#providers) for the
monid.ai row.

## Errors

| Status | Code | Meaning |
| - | - | - |
| `400` | `VALIDATION_ERROR` | Body failed schema validation, or monid rejected the discover/inspect body |
| `402` | `WALLET_INSUFFICIENT_FUNDS` | Your wallet cannot cover the reserve |
| `404` | `NOT_FOUND` | Unknown `job_id` (or another organization's), or monid knows no such endpoint on inspect |
| `429` | `RATE_LIMIT_EXCEEDED` / plain `{ error }` | Per-client rate limit, or the in-flight run cap |
| `502` | `UPSTREAM_ERROR` | monid rejected the run before executing it; you were not charged |
| `503` | `SERVICE_UNAVAILABLE` / `provider_account_unavailable` | Surface not provisioned, or monid is unavailable; you were not charged |

Not proxied: monid's account, workspace, and wallet endpoints — those describe the
platform's workspace, not yours. Your balance is your AI Reserve wallet.


# Decisions
Source: https://docs.aireserve.com/capabilities/decisions

Ask a model a typed question and get a calibrated probability back — yes/no, pick-one, or score — with Cloudflare's Clef decision models, on your AI Reserve key and wallet, billed per input token.

The gateway exposes decision models under `/v1/decisions`, with the same API key, rate limits,
wallet, and spend caps as every other route. Behind it sit Cloudflare's open-weight
[Clef](https://developers.cloudflare.com/workers-ai/models/clef/) models: you send a **state**
(text, JSON, or images) and a schema of typed **questions**, and get back a probability for every
allowed answer of every question in one forward pass. There is no free-form text to parse, no
reasoning tokens to wait for, and no prompt engineering to coax out valid JSON — the model can
only answer in the shape you declared.

Use it for the parts of an agent that are classification, routing, triage, moderation, or scoring
rather than writing: "is this ticket urgent", "which team owns it", "how severe is the impact",
"does this reply follow the policy". A decision is a few hundred milliseconds and a fraction of a
cent, so you can ask it on every turn.

You never create a Cloudflare account or hold a Cloudflare token. AI Reserve holds one account,
each decision is billed to your wallet at the published per-token rate, and every decision appears
in your usage analytics under the model `clef` or `clef-flash`.

> [!NOTE]
>
> **Jev / System One compatible.** The request and response bodies are the System One decision
> API, so an existing Jev integration moves over by pointing at
> `https://api.aireserve.com/v1/decisions` with your AI Reserve key and setting `model` to `clef`
> or `clef-flash`.

## Quickstart

```bash theme={"dark"}
curl -s https://api.aireserve.com/v1/decisions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "clef-flash",
    "state": "Checkout has been failing for every customer for the last hour.",
    "questions": {
      "urgent":   { "type": "noul",   "instructions": "Is this support request urgent?" },
      "team":     { "type": "choice", "instructions": "Which team should handle this request?",
                    "criteria": { "billing": "Payments, invoices, and refunds",
                                  "technical": "Outages, errors, and configuration",
                                  "sales": "Plans and upgrades" } },
      "severity": { "type": "score",  "instructions": "How severe is the customer impact?",
                    "criteria": ["No impact", "Minor", "Major", "Critical"] }
    }
  }'
```

```json theme={"dark"}
{
  "model": "clef-flash",
  "answers": {
    "urgent": { "type": "noul", "noul": 0.97 },
    "team": {
      "type": "choice",
      "choice": "technical",
      "confidence": 0.94,
      "probabilities": { "billing": 0.05, "technical": 0.94, "sales": 0.01 }
    },
    "severity": {
      "type": "score",
      "score": 2.88,
      "confidence": 0.89,
      "probabilities": { "0": 0.0, "1": 0.02, "2": 0.08, "3": 0.9 },
      "legend": { "0": "No impact", "1": "Minor", "2": "Major", "3": "Critical" }
    }
  },
  "usage": { "input_tokens": 212, "output_tokens": 0 },
  "aireserve": { "request_id": "6b1d…", "model": "clef-flash" }
}
```

Every response carries an `aireserve` envelope with the request id to quote to support and the
model the decision billed under.

## Request

| Field | Type | Notes |
| - | - | - |
| `model` | enum | Required. `clef` (27B, 64K context, highest precision) or `clef-flash` (9B, 24K context, fastest and cheapest). |
| `state` | any | Required. The situation to decide on: a string, or structured JSON (records, chat logs, application state). Long text is truncated upstream to fit the context window. |
| `questions` | object | Required, 1–64 entries. Keys are your question ids (letters, digits, `_`, `.`, `-`; max 100 chars); answers come back under the same ids. |
| `images` | array | Optional, up to 4 embedded PNG / JPEG / WebP images placed before the state (4 MiB and 16 MP each). Remote URLs are not accepted. |

### Question types

| `type` | Ask | `criteria` | Answer |
| - | - | - | - |
| `noul` | A yes/no question. | — | `noul`: probability the answer is yes (0–1). |
| `choice` | Pick one of your options. | Object of `option id → description`. | `choice`, `confidence`, and `probabilities` over every option. |
| `score` | Rate against an ordered rubric. | Array of level descriptions, lowest first. | `score` (probability-weighted, 0 = lowest level), `confidence`, `probabilities`, `legend`. |

Every question takes `instructions` — the question itself, plus any policy the model should apply.
Questions are answered independently against the same state; the model cannot see one answer while
producing another, so put shared context in `state` or in each question's `instructions`.

> [!TIP]
>
> Decisions are **calibrated**: a `noul` of `0.6` means "more likely yes than no, but not by
> much", so threshold on the number rather than rounding it. Route the confident cases
> automatically and send the uncertain band to a person or a larger model.

## Use it as a gate

The common shape is a cheap decision in front of an expensive model: decide whether the turn
needs the large model, a tool call, or a human, and only then spend on it.

```python theme={"dark"}
import httpx, os
from openai import OpenAI

API_KEY = os.environ["AIRESERVE_API_KEY"]
client = OpenAI(base_url="https://api.aireserve.com/v1", api_key=API_KEY)

def decide(state, questions, model="clef-flash"):
    r = httpx.post(
        "https://api.aireserve.com/v1/decisions",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"model": model, "state": state, "questions": questions},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["answers"]

message = "my invoice from last month double charged me, can you fix it today?"

answers = decide(message, {
    "needs_human": {"type": "noul", "instructions": "Does this require a human agent (refunds, legal, account closure)?"},
    "intent": {"type": "choice", "instructions": "What does the customer want?",
               "criteria": {"refund": "Money back", "question": "Information only", "bug": "Something is broken"}},
})

if answers["needs_human"]["noul"] > 0.7:
    escalate(message, intent=answers["intent"]["choice"])
else:
    reply = client.chat.completions.create(
        model="gpt-5.5",
        messages=[{"role": "system", "content": f"Customer intent: {answers['intent']['choice']}."},
                  {"role": "user", "content": message}],
    )
```

## Billing

| Model | Size | Context | Billed |
| - | - | - | - |
| `clef` | 27B | 64K | \$0.24 per 1M input tokens |
| `clef-flash` | 9B | 24K | \$0.038 per 1M input tokens |

Rates match Cloudflare's published Workers AI list prices. Decisions have no output tokens, so a
request costs its input alone: the serialized `state` and `questions`, plus images, which are
tokenized at one token per 32×32 pixel block and capped at 1,024 tokens each. The wallet holds an
in-process estimate before the call and settles on the token count Cloudflare reports; a decision
that fails — at the provider, on a timeout, or because the surface is not configured — is never
charged. Current rates are always on the [pricing page](https://aireserve.com/pricing).

## Data handling

Request bodies are sent to Cloudflare, Inc. (United States; served from Cloudflare's global
network). Under Cloudflare's published Workers AI data-usage terms, inputs and outputs are
Customer Content that Cloudflare does not use to train models or improve its services, does not
make available to other customers, and stores only when paired with a Cloudflare storage product
— which this route does not use — so it carries **no data-retention consent gate**. Still, send
the minimum state the decision needs. Details on the
[data-handling page](https://privacy.aireserve.com/data-handling).

## Errors

| Status | Meaning |
| - | - |
| `400` | Malformed request — an unknown model, no questions, a bad question type, or Cloudflare's validation message relayed (for example an unsupported image or state over the context window). |
| `402` | Spend cap exceeded or insufficient wallet balance. |
| `403` | Not a client-scoped key, or model not on the key's allowlist. |
| `429` | Rate limit exceeded, here or upstream. Retry after the `Retry-After` header. |
| `503` | Decisions are not configured on this deployment, or the provider is unavailable. Retry. |
| `504` | The provider timed out. Retry. |


# Dedicated GPU endpoints
Source: https://docs.aireserve.com/capabilities/dedicated-gpu-endpoints

Call organization-owned HuggingFace GPU deployments through AI Reserve with your existing API key.

AI Reserve can provision a dedicated HuggingFace Inference Endpoint and bill
its GPU capacity hourly from your organization's wallet. Running vLLM
text-generation deployments are exposed through the AI Reserve gateway, so
you use an existing organization API key — the HuggingFace account credential
stays server-side and is never revealed.

## Call a deployment

Open **Admin → GPUs** for your organization and choose **How to call endpoint**
on a running vLLM deployment. The panel gives you the deployment-specific URL
and a copyable request.

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."

curl https://api.aireserve.com/v1/gpu/<deployment-id>/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen2.5-7B-Instruct",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

The route accepts the OpenAI Chat Completions request and response format,
including `stream: true`. The `model` field is optional. If supplied, AI
Reserve pins it to the repository actually deployed, so a request cannot use
one deployment URL to target another model. On streaming requests AI Reserve
sets `stream_options.include_usage` on your behalf (overriding an explicit
`false`) so the final chunk always carries token counts for usage attribution.

> [!NOTE]
>
> The path contains the deployment's internal ID. Copy the complete URL from the GPUs page rather than constructing it
> from the HuggingFace endpoint name.

## Authentication and access

* Send an active AI Reserve API key belonging to the same organization as the
  deployment.
* User-scoped and team-scoped keys can call their organization's deployment;
  normal key status, IP allowlist, organization IP blocklist,
  [country restrictions](/getting-started/get-an-api-key#country-restrictions),
  geographic, and API rate-limit controls still apply.
* **Spend-based gates do not apply to this route.** GPU capacity is prepaid
  hourly from the organization wallet and inference requests add no per-token
  spend, so the checks that meter token spend — organization wallet balance,
  per-user and per-team budget caps, and the Cognition Token balance gate —
  are intentionally not evaluated here. A principal over its budget cap can
  still call a running deployment. To restrict who can drive a deployment,
  pause or revoke keys, scope the key's IP allowlist, or use the organization
  IP blocklist; to stop the spending itself, pause the deployment.
* A key from another organization receives the same `404` as an unknown
  deployment. The API never confirms that another organization's deployment
  exists.
* Deployments of models marked adult-only on HuggingFace (by HuggingFace's
  own content warning or by author-applied tags) require your organization's
  adult-content access: they can be created only while it is enabled, and
  requests to such a deployment return `403` if it is later turned off. AI
  Reserve also pauses such a deployment within the hour so prepaid GPU time
  stops accruing; once access is re-enabled, an organization admin can
  resume it from the GPUs page. Contact AI Reserve to change the setting
  for your organization.
* Paused, failed, deleted, provisioning, externally drifted, and legacy
  HuggingFace-toolkit deployments cannot serve this OpenAI-compatible route.

AI Reserve replaces the inbound authorization header before forwarding to
HuggingFace. The account-wide `HF_TOKEN`, raw HuggingFace URL, and deployment
management APIs are never exposed to the caller.

## Billing and usage

GPU capacity is prepaid hourly when the deployment starts and while it remains
running. **Inference requests are not charged by token on top of that hourly
rate.** Requests still record model, API key/user/team attribution, token
counts when the vLLM response supplies them, latency, and success/error status
at `$0` request cost.

Running endpoints bill continuously, including idle time. Pause a deployment
to stop future hourly charges; the unused remainder of the current prepaid
hour is not refunded.

## Supported protocol

The managed gateway currently promises:

* `POST /v1/gpu/<deployment-id>/chat/completions`
* OpenAI-compatible JSON responses
* OpenAI-compatible SSE streaming
* vLLM text-generation deployments only

Direct HuggingFace URLs, `/v1/models`, completions, embeddings, and generic
HuggingFace-toolkit task routes are not part of this managed customer API.


# Extractions
Source: https://docs.aireserve.com/capabilities/extractions

Pull typed values out of text and images — strings, numbers, dates, durations, lists, estimates and forecasts — with a calibrated confidence per field, using Cloudflare's Clairic extraction model on your AI Reserve key and wallet, billed per input token.

The gateway exposes a typed extraction model under `/v1/extractions`, with the same API key, rate
limits, wallet, and spend caps as every other route. Behind it sits Cloudflare's
[Clairic](https://developers.cloudflare.com/workers-ai/models/clairic/) model: you send a
**state** (text, optionally with up to four images) and a schema of typed **fields**, and get back
a value for every field in one forward pass — a `text` field is a character span of your input, a
`number` is computed, a `date` is ISO, a `list` is the matching items in input order, an
`estimate` is a distribution with a median and an 80% interval. Every answer carries a calibrated
`confidence` and a `p_null`: a field the input does not determine comes back `null` rather than a
guess, and the guess is still there under `guess` if you want it.

Use it for the parts of a pipeline that are reading rather than writing: invoice and receipt
fields, dates and amounts out of contracts, structured attributes out of listings or support
tickets, numbers out of screenshots. There is no prompt to engineer and no JSON to repair — the
model can only answer in the shape you declared. An extraction is a few hundred milliseconds and a
fraction of a cent, so it fits in front of every row.

You never create a Cloudflare account or hold a Cloudflare token. AI Reserve holds one account,
each extraction is billed to your wallet at the published per-token rate, and every call appears in
your usage analytics under the model `clairic`.

> [!NOTE]
>
> **Sibling of [Decisions](/capabilities/decisions).** Clef answers typed *questions* (yes/no,
> choice, score) with probabilities; Clairic fills typed *fields* with values. Both are one forward
> pass over the same kind of `state`, so an agent can ask "is this an invoice?" and "what is the
> total?" against the same text with two cheap calls.

## Quickstart

```bash theme={"dark"}
curl -s https://api.aireserve.com/v1/extractions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "clairic",
    "state": "Invoice #4421 from Acme Corp, issued March 3 2026, due in 30 days. Total due: $1,250.00. Items: widgets, gaskets, bolts.",
    "fields": {
      "vendor": { "type": "text",   "instructions": "The vendor name" },
      "total":  { "type": "number", "instructions": "Total amount due", "decimals": 2, "unit": "USD" },
      "issued": { "type": "date",   "instructions": "Invoice issue date" },
      "due":    { "type": "date",   "instructions": "Invoice due date" },
      "items":  { "type": "list",   "items": "text", "instructions": "Line items listed" }
    }
  }'
```

```json theme={"dark"}
{
  "model": "clairic",
  "answers": {
    "vendor": { "type": "text", "value": "Acme Corp", "span": [19, 28], "confidence": 0.995, "p_null": 0.002, "guess": "Acme Corp" },
    "total":  { "type": "number", "value": 1250, "confidence": 0.9995, "p_null": 0.00007, "guess": 1250 },
    "issued": { "type": "date", "value": "2026-03-03", "confidence": 0.996, "p_null": 0.0017, "guess": "2026-03-03" },
    "due":    { "type": "date", "value": "2026-04-02", "confidence": 0.90, "p_null": 0.0009, "guess": "2026-04-02" },
    "items":  { "type": "list", "value": ["widgets", "gaskets", "bolts"], "spans": [[96, 103], [105, 112], [114, 119]], "confidence": 0.995 }
  },
  "truncated": false,
  "usage": { "state_tokens": 61, "image_tokens": 0, "schema_tokens": 407, "input_tokens": 468, "output_tokens": 0, "passes": 2 },
  "aireserve": { "request_id": "6b1d…", "model": "clairic" }
}
```

Every response carries an `aireserve` envelope with the request id to quote to support and the
model the extraction billed under. Note the `due` date: the input said "due in 30 days", and the
model computed it from the issue date — with a lower confidence than the dates it could read
directly.

## Request

| Field | Type | Notes |
| - | - | - |
| `model` | enum | Required. `clairic` (64K context, text + images). |
| `state` | string | The text to read. Required unless `images` is sent. `text` answers are character spans of this string. Long text is truncated upstream to fit the context (`truncated: true` in the response). |
| `fields` | object | Required, 1–256 entries. Keys are your field names (letter or `_` first, then letters, digits, `_`, `.`, `-`; max 64 chars); answers come back under the same names. |
| `images` | array | Optional, up to 4 embedded PNG / JPEG / WebP images placed before the state, as `data:` URLs or `{ "content_type", "base64" }` objects (4 MiB each, 8 MiB total decoded). Remote URLs are not accepted. |
| `reference_date` | string | Optional ISO date that anchors dates written without a year ("March 3" → which year). |
| `options` | object | Optional. `include_quantiles: true` adds 99 percentiles to every estimate; `return_state_text: true` returns the text that spans index into. |

### Field types

Every field takes a `type` and `instructions` — what the field should contain, plus any rule the
model should apply. The other knobs depend on the type:

| `type` | Returns | Knobs |
| - | - | - |
| `text` | A span of the state: `value` plus `[start, end]` character `span`. | — |
| `number` | A computed number. | `integer`, `decimals` (0–6), `unit` (label only). |
| `date` | `YYYY-MM-DD`. | `reference_date` (request-level) for dates without a year. |
| `time` | `HH:MM:SS`. | — |
| `datetime` | ISO 8601 date-time. | — |
| `duration` | A number in `unit`. | `unit`: `seconds` (default), `minutes`, `hours`, `days`, `weeks`, `months`, `years`; `integer`, `decimals`. |
| `list` | Matching items in input order (`value` array plus per-item `spans`). | `items`: `text`, `number` or `date` (required); `decimals` for number lists. |
| `estimate` | A distribution: `value` (point estimate), `mean`, `median`, `p10`, `p90`, `p_below` / `p_above` the range. | `min`, `max` (required; numbers, or ISO dates for date estimates), `scale`: `linear` or `log`, `step`. |
| `forecast` | One estimate per future step under `steps`, plus `value` / `median` / `p10` / `p90` arrays. | `min`, `max`, `horizon` (1–64 steps), `interval`: `step`, `minute`, `hour`, `day`, `week`, `month`, `quarter`, `year`. |

Every answer also carries `confidence` and, for nullable types, `p_null` and `guess`. A field is
`null` when `p_null` exceeds its `null_threshold` (default 0.5) — set the threshold per field to
trade recall for precision.

Fields are answered independently against the same state. Fields that do not fit next to the
state in one 8,192-token pass are split across parallel passes upstream (`usage.passes`), so a
large schema still returns in one round trip.

> [!TIP]
>
> Extractions are **calibrated**: a `confidence` of `0.6` means "probably right, not certainly".
> Accept the confident fields automatically and route the uncertain band — or any `null` — to a
> person or a larger model. Keep arithmetic in your code: the model computes simple derived values
> (a due date, a total) but multi-step math belongs in a `number` field per operand, not one field
> per result.

## Images

Send a scanned receipt, a screenshot or a chart as an embedded image; `state` may then be empty.
Text fields read from an image carry `"source": "image"` and no `span`.

```python theme={"dark"}
import base64, httpx, os

API_KEY = os.environ["AIRESERVE_API_KEY"]

with open("receipt.jpg", "rb") as f:
    receipt = base64.b64encode(f.read()).decode()

r = httpx.post(
    "https://api.aireserve.com/v1/extractions",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "clairic",
        "images": [{"content_type": "image/jpeg", "base64": receipt}],
        "reference_date": "2026-10-20",
        "fields": {
            "merchant": {"type": "text", "instructions": "Merchant name"},
            "total": {"type": "number", "instructions": "Total charged", "decimals": 2, "unit": "USD"},
            "paid_on": {"type": "date", "instructions": "Transaction date"},
            "card_last4": {"type": "text", "instructions": "Last four digits of the card"},
        },
    },
    timeout=30,
)
r.raise_for_status()
answers = r.json()["answers"]
if answers["total"]["value"] is None or answers["total"]["confidence"] < 0.8:
    review_queue.put(r.json()["aireserve"]["request_id"])
```

## Billing

| Model | Context | Billed |
| - | - | - |
| `clairic` | 64K | \$0.10 per 1M input tokens |

Rates match Cloudflare's published Workers AI list price. Extractions have no output tokens, so a
request costs its input alone: the `state` and the serialized `fields` (each field adds its own
template tokens — `usage.schema_tokens` shows the count), plus images, which are tokenized at one
token per 32×32 pixel block and capped at 4,096 tokens each. The wallet holds an in-process
estimate before the call and settles on the token count Cloudflare reports; an extraction that
fails — at the provider, on a timeout, or because the surface is not configured — is never charged.
Current rates are always on the [pricing page](https://aireserve.com/pricing).

## Data handling

Request bodies are sent to Cloudflare, Inc. (United States; served from Cloudflare's global
network). Under Cloudflare's published Workers AI data-usage terms, inputs and outputs are
Customer Content that Cloudflare does not use to train models or improve its services, does not
make available to other customers, and stores only when paired with a Cloudflare storage product
— which this route does not use — so it carries **no data-retention consent gate**. Still, send
the minimum state the extraction needs. Details on the
[data-handling page](https://privacy.aireserve.com/data-handling).

## Errors

| Status | Meaning |
| - | - |
| `400` | Malformed request — an unknown model, no fields, a bad field type, an empty state with no images, or Cloudflare's validation message relayed (for example a `list` without `items`, an `estimate` without `min`/`max`, or an image whose dimensions are too large). |
| `402` | Spend cap exceeded or insufficient wallet balance. |
| `403` | Not a client-scoped key, or model not on the key's allowlist. |
| `429` | Rate limit exceeded, here or upstream. Retry after the `Retry-After` header. |
| `503` | Extractions are not configured on this deployment, or the provider is unavailable. Retry. |
| `504` | The provider timed out. Retry. |


# Fallback models
Source: https://docs.aireserve.com/capabilities/fallbacks

List the models you are willing to be served by, in order, and the gateway tries the next one when the one before it fails.

Name the models you accept, in order of preference, on the request itself. If
the first one fails, the gateway retries the same request on the next one, so
a provider incident on one model does not take your feature down. No portal
configuration is needed.

```json theme={"dark"}
{
  "models": ["claude-fable-5-1", "gpt-6-astra", "kimi-k3-fireworks"],
  "messages": [{ "role": "user", "content": "Summarize this quarter's board update." }]
}
```

`models` is shorthand. The first entry is the primary `model`; the rest become
`fallbacks`. The two spellings below are identical:

```json theme={"dark"}
{ "models": ["claude-fable-5-1", "gpt-6-astra"] }
```

```json theme={"dark"}
{ "model": "claude-fable-5-1", "fallbacks": ["gpt-6-astra"] }
```

Keep `model` a single string. Official OpenAI SDKs type it that way, and every
coding tool that replays `model` verbatim depends on it. List up to four models:
one primary plus three fallbacks.

```bash curl theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "models": ["claude-fable-5-1", "gpt-6-astra", "kimi-k3-fireworks"],
    "messages": [{ "role": "user", "content": "hello" }]
  }'
```

```python Python theme={"dark"}
from openai import OpenAI

client = OpenAI(base_url="https://api.aireserve.com/v1", api_key=os.environ["AIRESERVE_API_KEY"])

res = client.chat.completions.with_raw_response.create(
    model="claude-fable-5-1",
    messages=[{"role": "user", "content": "hello"}],
    extra_body={"fallbacks": ["gpt-6-astra", "kimi-k3-fireworks"]},
)
served = res.headers.get("x-aireserve-served-model")  # set only when a fallback answered
print(res.parse().choices[0].message.content, served)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.aireserve.com/v1", apiKey: process.env.AIRESERVE_API_KEY });

const params = {
  model: "claude-fable-5-1",
  messages: [{ role: "user", content: "hello" }],
  fallbacks: ["gpt-6-astra", "kimi-k3-fireworks"], // gateway extension, forwarded as-is
} as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming;

const { data, response } = await client.chat.completions.create(params).withResponse();

const served = response.headers.get("x-aireserve-served-model"); // null unless a fallback answered
console.log(data.choices[0].message.content, served);
```

## Which model answered

When a fallback served the request, the response carries the
`x-aireserve-served-model` header naming it. Read the header, not the body's
`model` field. The header is absent when the primary answered. Your usage
ledger records both the requested and the served model on every row, so
reporting and billing follow what actually ran.

## How entries are checked

Every entry is held to the same policy as the primary model. An entry is
dropped from the chain, never served silently, when it is:

* not a model in the [catalog](/models) (after alias resolution, so `fable-5-1`
  and `claude-fable-5-1` are both fine);
* outside your organization's model allowlist or inside its blocklist;
* behind an [organization consent](/models#organization-consent-gates) your
  organization has not accepted (China-hosted serving, training use, and so
  on), or behind a restricted-access list you are not on;
* the primary itself, or a duplicate of an earlier entry.

If nothing survives, the request runs exactly as if you had sent no list.

## Portal defaults and the request-level list

Organization admins can configure a default fallback chain per model in the
portal under Inference → Router. A request-level list replaces that default
for the one request that carries it.

Fallbacks are opt-in per organization or per request. A new organization has
no failover of any kind, so a provider's real error reaches you. Configuring
at least one fallback chain in the portal switches failover on for the whole
organization: the chains you wrote apply to the models they name, and the
models we have paired across providers with identical weights (the Claude
models on Anthropic and Amazon Bedrock, for example) fail over to their
sibling provider automatically, same model, same request, with nothing to
configure per model. To keep a chained model on the same weights first,
list the sibling as its first rung (`claude-sonnet-4-6-bedrock`, then a
different model). Ask support to change either behaviour. Two edge cases:

* `"fallbacks": []` opts a single request out of the organization's default
  chain. `models` never produces an empty list, so it cannot opt out by
  accident.
* Requests on your organization's own provider key ([BYOK](/capabilities/byok))
  never fall back to a different provider.

## Where it applies

| Endpoint | `models` / `fallbacks` |
| - | - |
| `POST /v1/chat/completions` | Supported |
| `POST /v1/responses` | Supported |
| `POST /v1/messages` | Not a failover chain. On the Anthropic wire, `fallbacks` is Anthropic's own `[{ "model": "…" }]` list consulted only when the primary refuses on a safety classifier. Error failover there uses the organization's portal chain. |

Failover engages on upstream failures (provider errors, rate limits, timeouts,
connection errors) after the gateway's own retries on the primary are
exhausted. The same request, unchanged, is then sent to the next model in your
list.


# Image generation
Source: https://docs.aireserve.com/capabilities/image-generation

Generate images through an OpenAI-compatible endpoint with the same key, rate limits, and spend caps as chat.

The gateway also **generates** images: an OpenAI-compatible endpoint sits
alongside chat completions, authenticated with the same API key (as
`Authorization: Bearer` or `x-api-key`) and governed by the same
per-client rate limits as every other `/v1` route. Requests are synchronous —
multi-image or high-quality generations can take tens of seconds, so set client timeouts
accordingly.

```bash theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-flash-image",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024",
    "response_format": "url"
  }'
```

## Request parameters

| Field | Required | Description |
| - | - | - |
| `model` | yes | Image model ID — see the table below |
| `prompt` | yes | Text description of the desired image(s); 1–32,000 characters |
| `n` | no | Number of images to generate — integer 1–10 (model-dependent) |
| `size` | no | Dimensions as a `"WxH"` string (e.g. `1024x1024`); supported values differ per model |
| `quality` | no | Provider-specific quality tier (e.g. `standard`, `hd`, `low`, `high`) |
| `response_format` | no | `url` (default) — a signed download link — or `b64_json` — inline base64 bytes |
| `user` | no | End-user identifier forwarded to the provider for abuse attribution |

## Response

The response follows the OpenAI images shape — `created` (unix seconds), a
`data` array with one entry per generated image, and an optional
`usage` object on token-priced models:

```json theme={"dark"}
{
  "created": 1752000000,
  "data": [
    {
      "url": "https://storage.googleapis.com/…?X-Goog-Signature=…",
      "revised_prompt": "A watercolor painting of a fox…"
    }
  ],
  "usage": { "input_tokens": 12, "output_tokens": 1024, "total_tokens": 1036 }
}
```

* With `response_format: "url"` (the default), each image is stored by the gateway and returned as a **signed download URL valid for \~24 hours** — download promptly and persist on your side.
* With `response_format: "b64_json"`, each entry carries the base64-encoded PNG bytes inline instead.
* `revised_prompt` appears when the provider rewrites your prompt before generating.

## Models & pricing

| Model | Pricing |
| - | - |
| `gemini-2.5-flash-image` | Token-based (≈ \$0.039 / image) |
| `gemini-3.1-flash-image` | $0.50 / 1M input tokens, $3.00 / 1M output tokens, plus up to \$0.151 / image at 4K resolution |
| `gpt-image-1` | Token-based ($5.00 / 1M text input, $40.00 / 1M image output tokens) |
| `qwen-image-3.0` | Per-image (\$0.03 / image, 1K and 2K) |
| `qwen-image-3.0-pro` | Per-image (\$0.075 / image) |
| `nano-banana-2` | Per-image (\$0.08 / image at 1K; served by fal) |
| `flux-2-flex` | Per-megapixel ($0.05 / MP of the requested `size`, rounded up to whole megapixels — 1024x1024 is $0.05, 2048x2048 is \$0.20; served by fal) |
| `grok-imagine-image` | Per-image (\$0.02 / image; served by fal) |
| `seedream-5` | Per-image ($0.045 / image up to 2.36 MP, $0.09 above; served by ByteDance Ark — China-hosted, per-organization opt-in). Also edits: pass `image` (one public HTTPS URL or base64 image, or an array of up to 14) with your `prompt` on this same endpoint |

Token-based models report token counts in the response `usage` object. Every
request's cost is metered against your key exactly like chat traffic and counts toward
the same spend caps. The fal-served models accept `n` (1–4 for `nano-banana-2`) and
`size` as `"WxH"` (256–4096 per side, at most 2048x2048 pixels).

## Image editing

`POST /v1/images/edits` edits existing images: send `model`, a `prompt`
describing the change, and `images` — one to nine public HTTPS URLs. The
response is a job (`202`, `{ id, status }`); poll `GET /v1/images/edits/{id}`
until `status` is `succeeded` and read the output URL from `result`. Editing
is billed per output image at the provider's list price (plus a per-input
fee where the provider charges one).

| Model | Inputs | Approximate pricing |
| - | - | - |
| `nano-banana-2-edit` | up to 8 images | \$0.08 / image |
| `flux-2-flex-edit` | up to 4 images | $0.05 / MP on output and input (billed as $0.20 + \$0.10 per input) |
| `qwen-image-2-pro-edit` | 1–3 images | \$0.075 / image |
| `grok-imagine-image-edit` | up to 4 images | $0.02 / image + $0.002 per input |
| `bria-background-remove` | 1 image, no prompt | \$0.018 / image |
| `topaz-image-upscale` | 1 image, no prompt (2× upscale) | \$0.32 / image (fal tiers by output megapixels) |

All image-editing models are served by fal in the United States.

> [!NOTE]
>
> **Qwen Image 3.** The `qwen-image-3.0` family is served by Alibaba Cloud
> Model Studio and is **China-hosted** under the gateway's provider-jurisdiction
> labeling — organizations must have the China-hosted model opt-in enabled to
> use it, same as the Qwen chat models. These models accept only `n` and
> `size` of the optional parameters (`quality`, `style`, and other
> provider-specific fields are ignored), and `qwen-image-3.0-pro` carries a
> low upstream rate limit (5 requests / minute) — expect 429s under parallel
> load and retry with backoff.

> [!WARNING]
>
> **Imagen retirement.** Google is shutting down the entire Imagen family on
> **August 17, 2026**, and the whole line is now delisted from the gateway:
> `imagen-4`, `imagen-4-fast`, and `imagen-4-ultra` IDs
> all return errors. The migration target is `gemini-2.5-flash-image`
> (GA, token-based, ≈ \$0.039 / image); `gpt-image-1` also remains available.

> [!NOTE]
>
> **Reliability.** Upstream image backends occasionally stall with a 503 for a
> few minutes. There is deliberately **no automatic fallback** to a different
> image model — silently swapping models would change output style and quality — so callers
> should **retry** instead. The SDKs already retry 503s with jittered backoff
> up to their configured retry budget.

## Using the SDKs

All five SDKs ship an image-generation helper as of **SDK v0.4.0**, with the
same auth, error mapping (401 → `AccessDeniedException`, 402 →
`ServiceQuotaExceededException`, 429 → `ThrottlingException`), and
retry policy as `Converse`:

```python Python theme={"dark"}
result = client.images.generate(
    model="gemini-2.5-flash-image",
    prompt="A watercolor painting of a fox in a snowy forest",
)
print(result["data"][0]["url"])   # signed download URL, valid ~24 h

# Inline bytes instead: response_format="b64_json" → result["data"][0]["b64_json"]
```

```typescript TypeScript theme={"dark"}
const result = await client.images.generate({
  model: "gemini-2.5-flash-image",
  prompt: "A watercolor painting of a fox in a snowy forest",
});
console.log(result.data[0].url); // signed download URL, valid ~24 h

// Inline bytes instead: responseFormat: "b64_json" → result.data[0].b64Json
```

```go Go theme={"dark"}
out, err := client.GenerateImage(ctx, &audacityruntime.GenerateImageInput{
    Model:  audacity.String("gemini-2.5-flash-image"),
    Prompt: audacity.String("A watercolor painting of a fox in a snowy forest"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(out.Data[0].Url) // signed download URL, valid ~24 h

// Inline bytes instead: ResponseFormat: audacity.String("b64_json") → out.Data[0].B64Json
```

```java Java theme={"dark"}
GenerateImageResponse result = client.generateImage(b -> b
    .model("gemini-2.5-flash-image")
    .prompt("A watercolor painting of a fox in a snowy forest"));

System.out.println(result.data().get(0).url()); // signed download URL, valid ~24 h

// Inline bytes instead: .responseFormat("b64_json") → result.data().get(0).b64Json()
```

```rust Rust theme={"dark"}
let result = client.generate_image()
    .model("gemini-2.5-flash-image")
    .prompt("A watercolor painting of a fox in a snowy forest")
    .send()
    .await?;

println!("{}", result.data[0].url.as_deref().unwrap()); // signed URL, valid ~24 h

// Inline bytes instead: .response_format("b64_json") → result.data[0].b64_json
```

Errors reuse the chat-completions codes: 400 `invalid_request_error` for a
malformed body, 401 `invalid_api_key`, 402 `usage_cap_exceeded` when
a spend cap is reached (never retried), and 429 `rate_limit_exceeded` with a
`Retry-After` header. See [Errors & retries](/api-reference/errors) for the
full exception mapping in each SDK.


# Live search
Source: https://docs.aireserve.com/capabilities/live-search

Give any model current numbers and live facts — structured knowledge cards with named sources plus web results from Tako, on your AI Reserve key and wallet, billed per search.

The gateway exposes live data and web search under `/v1/search`, with the same API key,
rate limits, wallet, and spend caps as every other route. Behind it sits [Tako](https://tako.com):
one call searches Tako's curated knowledge graph (finance, macro, companies, sports, weather)
and the live web, and returns **knowledge cards** — interactive, embeddable data visualizations
backed by structured series with named sources and methodology — plus **web results**. There is
no LLM in the loop, so results come back in well under a second and you decide what to do with
them: feed them to the model you already use, render the card, or compute on the data.

You never create a Tako account or hold a Tako key. AI Reserve holds one account, each search is
billed to your wallet at the published per-search rate, and every search appears in your usage
analytics under the model `tako-search` (or `tako-search-deep`).

> [!NOTE]
>
> **Opt-in by construction.** Nothing on the gateway calls Tako unless you call `/v1/search`.
> Ordinary chat completions never trigger a search. The recommended pattern is a **tool** your
> agent calls only when a turn needs a live number — see [Use it as a tool](#use-it-as-a-tool).

## Quickstart

```bash theme={"dark"}
curl -s https://api.aireserve.com/v1/search \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "What is the price of Silver?"}'
```

```json theme={"dark"}
{
  "cards": [
    {
      "card_id": "KfYeym50vtsF93LMsIFW",
      "title": "Silver Spot Price (USD/oz)",
      "description": "Spot price of silver in US dollars per troy ounce, updated intraday.",
      "webpage_url": "https://tako.com/card/KfYeym50vtsF93LMsIFW/",
      "image_url": "https://tako.com/api/v1/image/KfYeym50vtsF93LMsIFW/",
      "embed_url": "https://tako.com/embed/KfYeym50vtsF93LMsIFW/",
      "sources": [{ "source_name": "LBMA", "source_index": "tako" }]
    }
  ],
  "web_results": [{ "title": "Silver price today", "url": "https://..." }],
  "request_id": "f20f965b-6bbd-40df-b50b-a8861f34df24",
  "aireserve": { "request_id": "6b1d…", "model": "tako-search" }
}
```

The request and response bodies are Tako's own Search API shapes, so Tako's SDKs and docs apply
unchanged — point them at `https://api.aireserve.com/v1` with your AI Reserve key. The only
differences: Tako's `usage` block is not returned (billing is in your AI Reserve ledger), and
every response carries an `aireserve` envelope with the request id to quote to support and the
model the search billed under.

## Request

| Field | Type | Default | Notes |
| - | - | - | - |
| `query` | string | — | Required, 1–2,000 characters. Add context for relevance: `"MSFT stock price last 6 months"`, not `"MSFT"`. |
| `effort` | enum | `fast` | `instant` (cached cards, fastest), `fast` (balanced), `deep` (wider retrieval + rerank; billed as `tako-search-deep`). |
| `sources` | object | data + web | Keys select indexes: `{ "data": {} }`, `{ "web": {} }`, or both. Each takes `count` (1–20) and `include_contents`. |
| `country_code` | string | `US` | ISO 3166-1 alpha-2. |
| `locale` | string | `en-US` | BCP-47. |
| `timezone` | string | — | IANA timezone, e.g. `America/New_York`. |
| `output_settings` | object | — | `image_dark_mode`, `force_refresh` (`instant` only). |

Double quotes in `query` force a phrase to be one entity, with an optional type label:
`"\"Tesla\":PRODUCT price"`. Every quote must be paired or Tako ignores all of them.

> [!WARNING]
>
> `sources` is an **object**, not an array. `{"sources": ["data"]}` is rejected with `400`; use
> `{"sources": {"data": {}}}`.

## Use it as a tool

Register search as a function the model can call. The model decides when a turn needs live data
— typically a minority of turns — so you pay per search only when it matters, and the rest of
your traffic is untouched.

```python theme={"dark"}
from openai import OpenAI
import httpx, json, os

client = OpenAI(base_url="https://api.aireserve.com/v1", api_key=os.environ["AIRESERVE_API_KEY"])

TOOLS = [{
    "type": "function",
    "function": {
        "name": "live_search",
        "description": "Look up a current number or live fact (prices, filings, macro series, "
                       "scores, weather). Returns knowledge cards with sources plus web results.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"],
        },
    },
}]

def live_search(query: str) -> dict:
    r = httpx.post(
        "https://api.aireserve.com/v1/search",
        headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
        json={"query": query, "sources": {"data": {"count": 3}, "web": {"count": 3}}},
        timeout=60,
    )
    r.raise_for_status()
    return r.json()

messages = [{"role": "user", "content": "How has silver moved this month, and why?"}]
response = client.chat.completions.create(model="gpt-5.5", messages=messages, tools=TOOLS)
choice = response.choices[0]
if choice.message.tool_calls:
    messages.append(choice.message)
    for call in choice.message.tool_calls:
        result = live_search(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    response = client.chat.completions.create(model="gpt-5.5", messages=messages, tools=TOOLS)
print(response.choices[0].message.content)
```

Render `cards[].embed_url` in an iframe for the interactive chart, or `cards[].image_url` for a
static image; show `cards[].sources` as the attribution.

## Billing

| Model | Effort | Billed |
| - | - | - |
| `tako-search` | `instant`, `fast` | $0.007 per search ($7/1K) |
| `tako-search-deep` | `deep` | $0.012 per search ($12/1K) |

Rates match Tako's published list prices. Each search is one row in your usage analytics under
those model names. The wallet reservation equals the settlement because the price is known before
the call; a search that fails — at the provider, on a timeout, or because the surface is not
configured — is never charged. Current rates are always on the
[pricing page](https://aireserve.com/pricing).

## Data handling

Search queries are sent to Tako Inc. (United States). Tako excludes paid-plan queries from
training use but retains them under its privacy policy, and offers zero-data-retention only under
an enterprise agreement that the platform account is not on. Live search therefore carries the
**data-retention consent gate**: an organization admin accepts the disclosure once in the portal
before the first search; until then the route answers `403`. Do not put personal information in
queries. Details on the [data-handling page](https://privacy.aireserve.com/data-handling).

## Errors

| Status | Meaning |
| - | - |
| `400` | Malformed request — Tako's validation message is relayed. |
| `402` | Spend cap exceeded or insufficient wallet balance. |
| `403` | Not a client-scoped key, model not on the key's allowlist, or retention consent missing. |
| `429` | Rate limit exceeded. |
| `503` | Live search is not configured on this deployment, or the provider is unavailable. Retry. |
| `504` | The provider timed out. Retry. |


# Prompt caching
Source: https://docs.aireserve.com/capabilities/prompt-caching

Cache long, stable prompt prefixes server-side — ~90% off cache reads on Anthropic models, automatic on OpenAI and Gemini.

When consecutive requests share a long prefix — a large system prompt, a pasted document,
a growing conversation — providers can cache that prefix server-side. Cached input tokens
bill at a steep discount (**\~90% off** cache reads on Anthropic models; the
first request pays a one-time **\~25% premium** on cache writes) and
time-to-first-token improves because the provider skips re-processing the prefix.

| Models | Caching behavior | What you do |
| - | - | - |
| OpenAI (`gpt-*`) | Automatic for prompts of 1,024+ tokens | Nothing |
| Gemini (`gemini-*`) | Automatic (implicit caching) | Nothing |
| Grok (`grok-*`) | Automatic; the cache lives on the xAI server that handled the request | Send a stable conversation id (see [Keeping a conversation on one cache](#keeping-a-conversation-on-one-cache)) |
| Open-weights models served on Fireworks or Baseten (`gpt-oss-120b`, `glm-5.3`, `qwen-3.7-plus`, any `-fireworks` / `-baseten` leg) | Automatic; the cache lives on the serving replica | Same conversation id |
| Claude (`claude-*` and `-bedrock` variants) | Opt-in per request | Add a `cache_control` marker |

## Keeping a conversation on one cache

Some providers keep the prompt cache **per server**, not per account: xAI
(Grok) and the serverless pools behind Fireworks and Baseten. A request that
lands on a different server than the previous turn misses the cache even
though the prefix is byte-identical. That is why the same prompt can report
thousands of cached tokens on one call and almost none on the next.

The gateway handles the routing hint for you. On every Grok, Fireworks, and
Baseten request it sends the provider's sticky-routing header (`x-grok-conv-id`
for xAI, `x-session-affinity` for Fireworks and Baseten) with a key derived, in
order, from:

1. your `x-grok-conv-id` header, if you already set one for direct xAI calls;
2. your `x-conversation-id` header;
3. otherwise, a hash of the conversation's opening (system prompt, first user
   turn, first reply) — so a multi-turn conversation stays on one server even
   with no header at all.

For the best hit rate, send a stable id per conversation or session. Any
opaque string works; reuse it on every turn and change it when the
conversation changes.

```bash theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "x-conversation-id: 7f3c2a9e-session-42" \
  -d '{
    "model": "grok-4-3",
    "messages": [
      {"role": "system", "content": "<your stable system prompt…>"},
      {"role": "user", "content": "<the growing conversation…>"}
    ]
  }'
```

Only the key leaves the gateway, never the id's meaning: it is hashed before it
reaches the provider. Cached tokens come back in
`usage.prompt_tokens_details.cached_tokens` on each response, and the portal's
Analytics **Cache Hits** column shows the fleet-wide rate. Two things still
break a prefix on every provider: editing or reordering earlier messages, and
sending one-shot prompts whose only shared part is a short system prompt (there
is little to cache beyond it).

## Marking a prefix on Claude models

The gateway accepts the Anthropic-style marker in OpenAI-compatible format: write the
message `content` as an array of parts and put
`"cache_control": {"type": "ephemeral"}` on the content block where the
cacheable prefix ends — everything up to and including that block is cached. The gateway
forwards the marker to Anthropic (or AWS Bedrock for `-bedrock` variants)
unchanged. A message may carry the marker on its **last** content block only,
and a request may contain at most four markers.

```bash theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "messages": [
      {
        "role": "system",
        "content": [
          {
            "type": "text",
            "text": "You are a contracts analyst. <full playbook + the 40-page agreement text…>",
            "cache_control": {"type": "ephemeral"}
          }
        ]
      },
      {"role": "user", "content": "Summarize the termination clauses."}
    ],
    "max_tokens": 1024
  }'
```

* **Minimum size.** Each model has a minimum cacheable prefix (see the table below); shorter prefixes are processed normally with **no error and no cache entry** — the marker is silently ignored.
* **Lifetime.** Cache entries live for **5 minutes** by default, refreshed on each hit — steady traffic keeps the prefix warm.
* **Exact-prefix match.** Reuse requires a byte-identical prefix up to the marker; put stable content (system prompt, documents) first and variable content after it.

## Minimum cacheable prefix per model

Minimums differ by model *and by route*. In particular, AWS Bedrock enforces a
higher **4,096-token** minimum for Opus and Haiku than Anthropic's direct
API does — a prefix between 1,024 and 4,095 tokens that caches fine on
`claude-opus-4-6` will get zero cache activity on
`claude-opus-4-6-bedrock`. This is an AWS-side constraint (verified against
Bedrock directly), not gateway behavior.

| Model | Minimum prefix | Notes |
| - | - | - |
| Claude Sonnet (direct: `claude-sonnet-4-6`, `claude-sonnet-4-5`) | 1,024 tokens | Anthropic documented minimum |
| Claude Sonnet on Bedrock (`claude-sonnet-5-5-bedrock`, `claude-sonnet-5-bedrock`, `claude-sonnet-4-6-bedrock`, `claude-sonnet-4-5-bedrock`) | 1,024 tokens | Same as direct |
| Claude Opus (direct: `claude-fable-5-1`, `claude-fable-5`, `claude-opus-5-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`) | 1,024 tokens | Anthropic documented minimum |
| Claude Haiku (direct: `claude-haiku-4-5-20251001`) | 2,048 tokens | Anthropic documented minimum |
| **Claude Opus / Haiku on Bedrock** (`claude-opus-4-6-bedrock`, `claude-haiku-4-5-bedrock`, and other `-bedrock` Opus variants) | **4,096 tokens** | AWS Bedrock enforces a higher floor; sub-4,096 prefixes are accepted but never cached (no error, full input billing) |
| OpenAI (`gpt-*`) | 1,024 tokens | Automatic — no marker needed |
| Grok (`grok-*`) | No published minimum | Automatic, per xAI server — the gateway pins each conversation to one server (see [above](#keeping-a-conversation-on-one-cache)); cache reads surface in `usage.prompt_tokens_details.cached_tokens` |
| Gemini (`gemini-2.5-*`, `gemini-3-*`) | 1,024 (Flash) / 4,096 (Pro) tokens | Implicit caching is automatic and best-effort: cache hits depend on Google-side capacity and recency, so identical prompts may report `cached_tokens` only on some responses |

> [!NOTE]
>
> **Newer Claude variants on Bedrock.** `claude-fable-5-1-bedrock`,
> `claude-fable-5-bedrock`, `claude-opus-5-5-bedrock`, `claude-opus-5-bedrock`,
> `claude-opus-4-8-bedrock`, `claude-opus-4-7-bedrock`, `claude-sonnet-5-5-bedrock`
> and `claude-sonnet-5-bedrock` (and their `-bedrock-us` twins) route through
> AWS Bedrock (see
> [Bedrock-routed models](/migrate/from-bedrock#bedrock-routed-models)). Plan
> on the Bedrock minimums above — **4,096 tokens** for the Opus-class variants,
> 1,024 for Sonnet — until we publish measured floors for these models; a
> prefix sized that way caches on every Claude route. `claude-fable-5-1-bedrock`
> keeps Fable 5.1's cache-read rate (2.5% of input), the same as direct.

If your prefix is below the model's minimum, requests still succeed — you simply pay the
full input rate. Sizing the stable prefix above the minimum (for Bedrock Opus/Haiku,
above 4,096 tokens) is what unlocks the cache discount.

## Using the typed SDKs (`cachePoint`)

As of **SDK v0.2.0**, all five SDKs support prompt caching natively via a
Bedrock-style `cachePoint` content block. Place a cache point after the stable
prefix you want cached — in the `system` list, in message `content`,
or both. The SDK translates each cache point into the `cache_control` wire
marker on the preceding content part; the block itself is never sent. The same limits
apply: at most four cache points per request, and a cache point with nothing before it in
the same message is silently ignored.

```python Python theme={"dark"}
response = client.converse(
    modelId="claude-sonnet-4-6",
    system=[
        {"text": long_system_prompt},
        {"cachePoint": {"type": "default"}},
    ],
    messages=[{
        "role": "user",
        "content": [
            {"text": big_reference_document},
            {"cachePoint": {"type": "default"}},
            {"text": "Summarise the key risks."},
        ],
    }],
)

# Cache activity is reported in usage (Bedrock names):
print(response["usage"]["cacheReadInputTokens"])   # tokens served from cache
print(response["usage"]["cacheWriteInputTokens"])  # tokens written to cache
```

```typescript TypeScript theme={"dark"}
const response = await client.send(
  new ConverseCommand({
    modelId: "claude-sonnet-4-6",
    system: [
      { text: longSystemPrompt },
      { cachePoint: { type: "default" } },
    ],
    messages: [
      {
        role: "user",
        content: [
          { text: bigReferenceDocument },
          { cachePoint: { type: "default" } },
          { text: "Summarise the key risks." },
        ],
      },
    ],
  })
);

// Cache activity is reported in usage (Bedrock names):
console.log(response.usage?.cacheReadInputTokens);  // tokens served from cache
console.log(response.usage?.cacheWriteInputTokens); // tokens written to cache
```

```go Go theme={"dark"}
resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
    ModelId: audacity.String("claude-sonnet-4-6"),
    System: []types.SystemContentBlock{
        {Text: longSystemPrompt},
        {CachePoint: &types.CachePointBlock{Type: types.CachePointTypeDefault}},
    },
    Messages: []types.Message{{
        Role: types.ConversationRoleUser,
        Content: []types.ContentBlock{
            &types.ContentBlockMemberText{Value: bigReferenceDocument},
            &types.ContentBlockMemberCachePoint{
                Value: types.CachePointBlock{Type: types.CachePointTypeDefault},
            },
            &types.ContentBlockMemberText{Value: "Summarise the key risks."},
        },
    }},
})

// Cache activity is reported in usage (Bedrock names):
fmt.Println(resp.Usage.CacheReadInputTokens)  // tokens served from cache
fmt.Println(resp.Usage.CacheWriteInputTokens) // tokens written to cache
```

```java Java theme={"dark"}
ConverseResponse resp = client.converse(request -> request
    .modelId("claude-sonnet-4-6")
    .system(
        SystemContentBlock.fromText(longSystemPrompt),
        SystemContentBlock.fromCachePoint(CachePointBlock.defaultType()))
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(
            ContentBlock.fromText(bigReferenceDocument),
            ContentBlock.fromCachePoint(CachePointBlock.defaultType()),
            ContentBlock.fromText("Summarise the key risks."))
        .build()));

// Cache activity is reported in usage (Bedrock names):
System.out.println(resp.usage().cacheReadInputTokens());  // tokens served from cache
System.out.println(resp.usage().cacheWriteInputTokens()); // tokens written to cache
```

```rust Rust theme={"dark"}
use audacity_sdk::{CachePointBlock, ContentBlock, SystemContentBlock};

let response = client.converse()
    .model_id("claude-sonnet-4-6")
    .system(SystemContentBlock::text(long_system_prompt))
    .system(SystemContentBlock::cache_point())
    .messages(
        Message::builder()
            .role(ConversationRole::User)
            .content(ContentBlock::Text(big_reference_document))
            .content(ContentBlock::CachePoint(CachePointBlock::new()))
            .content(ContentBlock::Text("Summarise the key risks.".into()))
            .build()?
    )
    .send()
    .await?;

// Cache activity is reported in usage (Bedrock names):
println!("{}", response.usage().cache_read_input_tokens);  // tokens served from cache
println!("{}", response.usage().cache_write_input_tokens); // tokens written to cache
```

## Verifying and billing

Cache activity is reported in the response `usage` object. On the wire the
fields are `cache_creation_input_tokens` (tokens written to the cache) and
`cache_read_input_tokens` (tokens served from it); the SDKs surface them under
the Bedrock names `cacheWriteInputTokens` and `cacheReadInputTokens`.
Both are metered per request in your usage reporting and billed at the premium write /
discounted read rates — a non-zero cache-read count confirms the cache is doing its job.

Fleet-wide, the portal's **Analytics** page shows the same signal without any
code: the *Usage by Model* table carries a **Cache Hits** column (the share of
input tokens served from the provider's prompt cache) alongside typical /
95th-percentile response times per model, over whatever date range and team
scope you select.

> [!NOTE]
>
> **Caches don't transfer between providers.** A prompt cache lives with the
> provider that served the request. When a model's serving provider changes —
> you switch model IDs, or a gradual provider migration moves your traffic —
> the new provider starts with a cold cache: expect the cache-hit rate to dip
> and recover within minutes as steady traffic re-warms the prefix. The
> Analytics cache-hit column is the easiest place to watch that recovery.

> [!NOTE]
>
> **SDK note.** Typed `cachePoint` support requires
> **SDK v0.2.0 or later** in every language. On OpenAI and Gemini models
> caching is automatic — the marker is ignored there, so the same code runs unchanged
> across providers.


# Realtime voice sessions
Source: https://docs.aireserve.com/capabilities/realtime-voice

Live speech-to-speech voice agents over WebSocket — mint a signed session credential from the gateway, connect directly to the voice relay, billed per minute of audio.

> [!NOTE]
>
> Realtime voice is **available on request**. Contact your AI Reserve representative to have `realtimeVoiceEnabled`
> turned on for your organization — until then, session mints return `403`. In environments where the voice relay is not
> deployed they return `503`.

Realtime voice gives your application a live speech-to-speech session with xAI Grok Voice over a
WebSocket. Billing, budgets, and usage reporting are handled by AI Reserve the same way as every
other surface.

The gateway acts as a **voice-bound relay**, not a generic LiteLLM passthrough. When you mint a
session you select a voice (built-in or your organization's custom voice); that voice is locked
at mint and injected server-side the moment the upstream WebSocket opens. Your AI Reserve API
key never travels to the WebSocket — only the short-lived ephemeral key does.

## How it works

Because a WebSocket cannot ride the normal request/response gateway, the flow has two steps:

1. **Mint** a session credential — one API call that authenticates you, reserves funds, selects
   the voice, and returns a short-lived `ephemeral_key` and `wss_url`.
2. **Connect** your WebSocket directly to `wss_url` using `ephemeral_key`. Drive the session
   with audio I/O events only.

## Step 1: Mint a session

`POST /v1/realtime/sessions` authenticates the caller, checks the org gate, resolves voice
ownership, reserves worst-case session funds from your wallet, and returns the credentials.

The `voice` parameter selects which voice the relay will use for this session. Pass:

* Any **built-in voice ID** from `GET /v1/voices` (e.g. `"ara"`, `"atlas"`, `"luna"`) — no
  extra org gate required.
* One of **your organization's custom voice IDs** from `GET /v1/custom-voices` — requires the
  `customVoicesEnabled` org gate in addition to `realtimeVoiceEnabled`.

`voice` defaults to `"ara"` when omitted.

```bash cURL theme={"dark"}
curl -X POST https://api.aireserve.com/v1/realtime/sessions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "grok-voice", "voice": "ara"}'
```

```typescript TypeScript theme={"dark"}
const response = await fetch("https://api.aireserve.com/v1/realtime/sessions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ model: "grok-voice", voice: "ara" }),
});
const session = await response.json();
```

```python Python theme={"dark"}
import os, requests

session = requests.post(
    "https://api.aireserve.com/v1/realtime/sessions",
    headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
    json={"model": "grok-voice", "voice": "ara"},
).json()
```

A successful mint returns `201`:

```json theme={"dark"}
{
  "session_id": "9c3f1a2b-4d5e-6f7a-8b9c-0d1e2f3a4b5c",
  "model": "grok-voice",
  "voice": "ara",
  "wss_url": "wss://voice-relay-uat-abcdefg-ue.a.run.app/v1/realtime?model=grok-voice",
  "ephemeral_key": "v1.1756946700.ABCDEFGHIJKLMNOPQRSTuvwxyz01234.signature_base64url_43chars",
  "expires_at": "2026-09-03T21:05:00.000Z",
  "key_ttl_seconds": 300,
  "max_session_seconds": 3540,
  "browser_subprotocols": [
    "openai-beta.realtime-v1",
    "openai-insecure-api-key.v1.1756946700.ABCDEFGHIJKLMNOPQRSTuvwxyz01234.signature_base64url_43chars"
  ]
}
```

The `ephemeral_key` is an **HMAC-SHA-256 signed, opaque, one-use relay ticket** — not an API
key. The token itself encodes only an expiry timestamp and a random nonce; it does **not**
carry a voice ID. Voice authorization lives in the session record: the relay stores the
authorized voice and ticket state in a DB row keyed by the ticket's SHA-256 hash at mint time.
The ticket is valid for 5 minutes and consumed on first use — a replay is rejected even within
the TTL. Mint a new session for each conversation; do not log or share the key.

## Step 2: Connect the WebSocket

**From a server** — pass the key as a bearer token header:

```text theme={"dark"}
GET <wss_url returned by POST /v1/realtime/sessions>
Authorization: Bearer <ephemeral_key>
```

**From a browser** — browsers cannot set WebSocket headers; pass the `browser_subprotocols`
array from the mint response verbatim:

```javascript theme={"dark"}
const ws = new WebSocket(session.wss_url, session.browser_subprotocols);
```

The relay verifies the HMAC signature and expiry, reads the session record by the ticket's
SHA-256 hash to retrieve the authorized voice (and atomically marks the ticket consumed to
prevent replay), then opens a connection to the xAI Grok Voice engine and sends an initial
`session.update` event with the authorized voice before forwarding any client audio. The voice
is bound in the session record — the client cannot change it mid-session.

## Supported WebSocket events

The relay enforces a **strict event allowlist**. Only the following client→relay events are
accepted; anything else closes the connection with code `1008`:

| Event | Purpose |
| - | - |
| `input_audio_buffer.append` | Send a chunk of PCM audio (base64-encoded) |
| `input_audio_buffer.commit` | Mark the current audio turn as complete |
| `input_audio_buffer.clear` | Clear the uncommitted audio buffer |
| `response.create` | Request a response from the model |
| `response.cancel` | Cancel an in-progress response |
| `conversation.item.create` | Add a text `message` item to the conversation (see shape below) |
| `conversation.item.truncate` | Trim an assistant audio item to `audio_end_ms` (barge-in) |
| `conversation.item.delete` | Remove an item from the conversation context |
| `session.update` | Update session options (`instructions`, `turn_detection`, `audio` format only) |

`session.update` is additionally sanitized: only `instructions`, `turn_detection`, and `audio`
fields are forwarded. `voice` is always forced to the value selected at mint regardless of what
the client sends.

`conversation.item.create` accepts `message` items only, with a `role` of `user`, `system`, or
`assistant` and `content` parts of type `input_text` or `text` (up to 32,768 characters each).
An optional `item.id` and `previous_item_id` are forwarded. Audio parts (`input_audio`),
`function_call` and `function_call_output` items, and any other field close the connection with
code `1008`; audio goes through `input_audio_buffer.append`.

`conversation.item.truncate` requires `item_id`, `content_index`, and `audio_end_ms` (non-negative
integers). `conversation.item.delete` requires `item_id`. Both are forwarded verbatim; the engine
answers an `error` event for an unknown `item_id`.

Relay→client messages are forwarded as-is from the xAI engine.

> [!NOTE]
>
> **Transcription, tool calling, and session resumption are not supported in this release.** Attempting to enable
> transcription or tools via `session.update` will not work — those fields are stripped. See [Deferred
> features](#deferred-features).

## Available voices

Pass a supported built-in voice ID or one of your organization's custom voice IDs (requires
`customVoicesEnabled`). The default when `voice` is omitted is `ara`. Use `GET /v1/voices` to
retrieve the current catalog with names, languages, and genders; catalog additions are enabled on
the synthesis surfaces after AI Reserve verifies and deploys them.

To create custom voice clones for your organization, see [Text-to-speech](/capabilities/text-to-speech).

## Billing and limits

| Item | Detail |
| - | - |
| **Pricing unit** | Per audio minute at the published `grok-voice` rate |
| **Wallet reserve** | Worst-case session cost (`max_session_seconds` = 3,540 s) is reserved at mint; normally the recorded session duration is settled and the difference released. If relay lifecycle telemetry is incomplete, settlement uses a conservative bounded estimate and marks the ledger row for reconciliation. |
| **Unused credentials** | An unused (never-connected) ephemeral key releases its wallet reservation automatically |
| **Mint requires balance** | `402` is returned when the wallet cannot cover the worst-case session |
| **Session ceiling** | One session runs at most 3,540 seconds; mint a new session to continue |
| **Key TTL** | The ephemeral key accepts new WebSocket upgrades for 5 minutes (`key_ttl_seconds` = 300); connect promptly after minting |

Usage appears on your ledger and dashboards like any other model call (unit: audio seconds) and
counts toward the same wallet and budget caps.

## Audio persistence

AI Reserve does **not** persist audio from realtime sessions. Session metadata (duration, cost,
voice ID, session ID) is stored for billing and usage reporting; no audio content is retained.

## Enable realtime voice

1. Contact your AI Reserve representative (or the Help page in the portal) to enable
   `realtimeVoiceEnabled` for your organization.
2. Optionally enable `customVoicesEnabled` if you want to use custom voice clones in sessions.
3. Mint a session and connect — the two-step flow above is the full integration.
4. Watch your usage dashboard: each session appears as one audio usage row with duration and cost.

## Deferred features

The following are **not available in this release**:

* **Standalone speech-to-text**: transcription calls without voice synthesis. See
  `POST /v1/audio/transcriptions` for the existing OpenAI-compatible transcription endpoint.
* **Streaming TTS**: text-in, audio-out streaming without a microphone. See
  `POST /v1/audio/speech` for synchronous (non-streaming) TTS with `grok-tts`.
* **SIP / telephony integration**: direct PSTN or SIP dial-in/dial-out.
* **Tool calling in realtime sessions**: function calling over the realtime session is not
  available in this release.
* **Session resumption**: each `POST /v1/realtime/sessions` mint starts a fresh session;
  reconnecting to a prior session is not supported.


# Streaming
Source: https://docs.aireserve.com/capabilities/streaming

ConverseStream returns the same Bedrock event union you already handle, in all five SDKs.

`ConverseStream` returns the same Bedrock event union you already handle:
`messageStart → contentBlockStart → contentBlockDelta → contentBlockStop →
messageStop → metadata`. Under the hood the gateway streams server-sent events;
the SDK translates each chunk into typed Bedrock events, and the final
`metadata` event always carries token usage and latency.

Streams are **never cut off by the request timeout** — the timeout applies only
until response headers arrive, so long generations run to completion. One honest
exception: if the upstream provider goes completely silent (no chunks at all,
distinct from a model still generating) for roughly 30 seconds — a few minutes
on deep-reasoning models that think before emitting — the gateway fails the
request quickly so retries and fallbacks can engage, instead of leaving the
connection hanging.

```python Python theme={"dark"}
stream_response = client.converse_stream(
    modelId="gpt-5.4-mini",
    messages=[{"role": "user", "content": [{"text": "Write me a haiku."}]}],
)

for event in stream_response["stream"]:         # boto3 parity: response["stream"]
    if "contentBlockDelta" in event:
        delta = event["contentBlockDelta"]["delta"]
        print(delta.get("text", ""), end="", flush=True)
```

```typescript TypeScript theme={"dark"}
import { ConverseStreamCommand } from "@audacity/sdk";

const { stream } = await client.send(
  new ConverseStreamCommand({
    modelId: "gpt-5.4-mini",
    messages: [{ role: "user", content: [{ text: "Tell me a story" }] }],
  })
);

for await (const event of stream) {
  if ("contentBlockDelta" in event) {
    const delta = event.contentBlockDelta.delta;
    if ("text" in delta) process.stdout.write(delta.text);
  }
}
```

```go Go theme={"dark"}
streamResp, err := client.ConverseStream(ctx, &audacityruntime.ConverseStreamInput{
    ModelId: audacity.String("gpt-5.4-mini"),
    Messages: []types.Message{{
        Role:    types.ConversationRoleUser,
        Content: []types.ContentBlock{&types.ContentBlockMemberText{Value: "Tell me a story"}},
    }},
})
if err != nil {
    log.Fatal(err)
}

stream := streamResp.GetStream()
defer stream.Close()

for event := range stream.Events() {
    switch e := event.(type) {
    case *types.ConverseStreamOutputMemberContentBlockDelta:
        if td, ok := e.Value.Delta.(*types.ContentBlockDeltaMemberText); ok {
            fmt.Print(td.Value)
        }
    case *types.ConverseStreamOutputMemberMetadata:
        fmt.Printf("\n[tokens in=%d out=%d latency=%dms]\n",
            e.Value.Usage.InputTokens, e.Value.Usage.OutputTokens, e.Value.Metrics.LatencyMs)
    }
}
if err := stream.Err(); err != nil {
    log.Fatal(err)
}
```

```java Java theme={"dark"}
// Push handler (AWS SDK v2 style)
client.converseStream(
    request -> request
        .modelId("gpt-5.4-mini")
        .messages(Message.builder()
            .role(ConversationRole.USER)
            .content(ContentBlock.fromText("Tell me a short story."))
            .build()),
    ConverseStreamHandler.builder()
        .onContentBlockDelta(e -> {
            if (e.delta().text() != null) System.out.print(e.delta().text());
        })
        .onMessageStop(e -> System.out.println("\nStop: " + e.stopReason()))
        .onMetadata(e -> System.out.printf("Tokens: %d%n", e.usage().totalTokens()))
        .build());

// Or a pull-based iterator:
try (var iter = client.converseStreamIterator(request -> request
        .modelId("gpt-5.4-mini")
        .messages(Message.builder()
            .role(ConversationRole.USER)
            .content(ContentBlock.fromText("Hello!"))
            .build()))) {
    while (iter.hasNext()) {
        ConverseStreamOutput event = iter.next();
        // handle event
    }
}
```

```rust Rust theme={"dark"}
use audacity_sdk::ConverseStreamOutput;

let mut output = client.converse_stream()
    .model_id("gpt-5.4-mini")
    .messages(
        Message::builder()
            .role(ConversationRole::User)
            .content(ContentBlock::Text("Tell me a joke".into()))
            .build()?
    )
    .send()
    .await?;

while let Some(event) = output.stream.recv().await? {
    if let ConverseStreamOutput::ContentBlockDelta(e) = event {
        if let audacity_sdk::ContentBlockDeltaPayload::Text(t) = e.delta {
            print!("{t}");
        }
    }
}
```


# Text-to-speech
Source: https://docs.aireserve.com/capabilities/text-to-speech

Synthesize speech with xAI's grok-tts or the ElevenLabs eleven-* models, browse the built-in voice catalog, and manage consented custom voice clones — all with the same API key and spend caps as chat.

The AI Reserve gateway exposes text-to-speech under `/v1/audio/speech` with the same API key,
rate limits, wallet, and spend caps as every other route. Two providers sit behind one
OpenAI-compatible request shape — pick a model and a voice:

| Model | Provider | Best for | Max input | Price / 1M chars |
| - | - | - | - | - |
| `grok-tts` | xAI | Fast, inexpensive narration with the xAI voices | 4,096 | \$15 |
| `eleven-v4` | ElevenLabs | The most expressive, emotive speech; 90+ languages | 10,000 | \$80 |
| `eleven-v3` | ElevenLabs | Dramatic, performed delivery; 70+ languages | 5,000 | \$80 |
| `eleven-multilingual-v2` | ElevenLabs | Stable, consistent long-form audio; 29 languages | 10,000 | \$80 |
| `eleven-flash-v2-5` | ElevenLabs | Lowest latency and half the price; 32 languages | 40,000 | \$40 |

Two layers of voices are available:

* **Built-in voices** — the xAI voices (for `grok-tts`) and the ElevenLabs voice library (for the
  `eleven-*` models), usable by any caller, no org gate required.
* **Custom voices** — clones of consented speakers, owned and namespaced by your organization
  (org-gated, xAI Enterprise contract required; synthesized with `grok-tts`).

> [!NOTE]
>
> **Custom voices are available on request.** The full CRUD surface (`POST /v1/custom-voices` and
> all `/v1/custom-voices/{voiceId}` routes) requires the `customVoicesEnabled` org gate to be on
> for your organization and an xAI Enterprise contract on the platform. Contact your AI Reserve
> representative to enable both. Until enabled, custom-voice endpoints return `403`.
>
> **Speech synthesis** (`POST /v1/audio/speech`) with built-in voices is available to any org.
> Custom voices additionally require `customVoicesEnabled`.

## Built-in voices

`GET /v1/voices` returns the live catalog of voices you can pass as `voice` in any TTS call
(xAI voices also drive realtime sessions). Every entry carries a `provider` (`grok` or
`elevenlabs`) and the `models` it can be synthesized with, so you can pick a voice and a model
together. No org gate — available to every caller.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/voices \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

```typescript TypeScript theme={"dark"}
const response = await fetch("https://api.aireserve.com/v1/voices", {
  headers: { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` },
});
const { voices } = await response.json();
```

```python Python theme={"dark"}
import os, requests

response = requests.get(
    "https://api.aireserve.com/v1/voices",
    headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
)
voices = response.json()["voices"]
```

The response is `{ "voices": [ { "voice_id": "ara", "name": "Ara", "language": "en", "gender":
"female", "provider": "grok", "models": ["grok-tts"] }, { "voice_id": "JBFqnCBsd6RMkjVDRZzb",
"name": "George", "gender": "male", "accent": "British", "category": "premade", "provider":
"elevenlabs", "models": ["eleven-v4", "eleven-v3", "eleven-multilingual-v2", "eleven-flash-v2-5"]
}, … ] }`. Each provider's list is cached for 5 minutes and a stale list is served during brief
upstream outages rather than an error — an outage at one provider never hides the other's voices.

Use `GET /v1/voices` for the current catalog. ElevenLabs voices may be addressed by `voice_id` or
by `name` (case-insensitive, e.g. `"voice": "George"`); xAI voices by `voice_id` (`ara` is the
default).

## Text-to-speech synthesis

`POST /v1/audio/speech` synthesizes speech from text. The call is synchronous — the full audio
is returned in one response body. The response `Content-Type` matches `response_format`
(`audio/mpeg` by default).

### Parameters

| Field | Required | Description |
| - | - | - |
| `model` | yes | `grok-tts`, `eleven-v4`, `eleven-v3`, `eleven-multilingual-v2` or `eleven-flash-v2-5` |
| `input` | yes | Text to synthesize, counted in Unicode code points — max 4,096 for `grok-tts`, 10,000 for `eleven-v4` / `eleven-multilingual-v2`, 5,000 for `eleven-v3`, 40,000 for `eleven-flash-v2-5` |
| `voice` | yes | Built-in voice ID (ElevenLabs voices also accept their `name`) or your organization's custom voice ID (`grok-tts` only) |
| `language` | no | Language hint (e.g. `en`, `en-US`, `es`). xAI: defaults to the voice's primary language. ElevenLabs: sent as an ISO 639-1 `language_code` where the model accepts one; `eleven-multilingual-v2` detects it |
| `response_format` | no | `grok-tts`: `mp3` only. `eleven-*`: `mp3` (44.1 kHz / 128 kbps), `opus` (48 kHz), `pcm` (24 kHz 16-bit mono) or `wav` (24 kHz). Defaults to `mp3` |
| `speed` | no | Playback speed 0.7–1.2, ElevenLabs models only (1.0 is normal) |

### Quickstart

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"grok-tts","input":"Welcome to AI Reserve.","voice":"ara"}' \
  --output speech.mp3
```

```typescript TypeScript theme={"dark"}
const response = await fetch("https://api.aireserve.com/v1/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "grok-tts",
    input: "Welcome to AI Reserve.",
    voice: "ara",
  }),
});
// response body is raw MP3 bytes
const buffer = Buffer.from(await response.arrayBuffer());
await Bun.write("speech.mp3", buffer);
```

```python Python theme={"dark"}
import os, requests

response = requests.post(
    "https://api.aireserve.com/v1/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
    json={"model": "grok-tts", "input": "Welcome to AI Reserve.", "voice": "ara"},
)
with open("speech.mp3", "wb") as f:
    f.write(response.content)
```

### ElevenLabs example

Same request shape — choose an `eleven-*` model and an ElevenLabs voice (by name or `voice_id`).
`eleven-flash-v2-5` is the pick for real-time chat (lowest latency, half the price); `eleven-v4`
for the most expressive delivery.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"eleven-flash-v2-5","input":"Welcome to AI Reserve.","voice":"George","response_format":"mp3"}' \
  --output speech.mp3
```

```typescript TypeScript theme={"dark"}
const response = await fetch("https://api.aireserve.com/v1/audio/speech", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "eleven-v4",
    input: "Welcome to AI Reserve.",
    voice: "George",
    speed: 1.0,
  }),
});
await Bun.write("speech.mp3", Buffer.from(await response.arrayBuffer()));
```

```python Python theme={"dark"}
import os, requests

response = requests.post(
    "https://api.aireserve.com/v1/audio/speech",
    headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
    json={"model": "eleven-v4", "input": "Welcome to AI Reserve.", "voice": "George"},
)
with open("speech.mp3", "wb") as f:
    f.write(response.content)
```

### Billing

Billed per **Unicode code point** in `input` at the model's published rate: `grok-tts` $15 / 1 M
characters; `eleven-v4`, `eleven-v3` and `eleven-multilingual-v2` $80 / 1 M; `eleven-flash-v2-5`
\$40 / 1 M (ElevenLabs' public API card, billed in USD). The character count is known before
synthesis begins, so the wallet reservation equals the settlement amount — no post-call
adjustment.

### Limits and notes

* **Input length**: per-model ceilings above. For longer text, split at sentence boundaries and
  concatenate the returned audio on your side.
* **Output format**: `grok-tts` emits MP3 only; the ElevenLabs models emit `mp3`, `opus`, `pcm`
  or `wav`. Streaming TTS is deferred — see [Deferred features](#deferred-features).
* **Request timeout**: 120 seconds. Long inputs near a model's ceiling may take tens of seconds;
  set your HTTP client timeout accordingly.
* **Content**: ElevenLabs' terms of service prohibit sexually explicit and certain other content;
  requests that violate them are rejected by the provider. Use `grok-tts` for voices in those
  products.
* **Auth requirement**: a client-scoped API key is required (personal keys without org context
  are rejected with `403`).

## Custom voices

Custom voices are speaker clones your organization creates from reference audio. Once created, a
custom voice ID can be used anywhere a built-in voice ID is accepted: `POST /v1/audio/speech`
and `POST /v1/realtime/sessions`.

### Requirements

| Requirement | Detail |
| - | - |
| **Org gate** | `customVoicesEnabled` must be on for your organization — off by default |
| **xAI Enterprise** | An xAI Enterprise contract is required on the platform; `POST /custom-voices` returns a shaped `403` until it is active |
| **Consent** | `consent_attestation=true` is required on every create — you attest the speaker consented to the clone |
| **Geography** | Voice cloning is available in the **United States except Illinois**; do not upload voices from Illinois or create voices whose use would violate biometric, publicity, privacy, or impersonation laws |

### Reference audio recommendations

The quality of the clone depends heavily on the recording:

* **Format**: single-speaker mono WAV at 24 kHz
* **Duration**: 90–120 seconds produces the best results; at least 30 seconds is recommended
* **Environment**: quiet room, no background music, minimal noise
* **Upload limit**: 31 MB (bounds a 120-second uncompressed WAV with multipart overhead)
* **Duration ceiling**: 120 seconds (enforced upstream by xAI)

### Create a custom voice

`POST /v1/custom-voices` is `multipart/form-data`. Required fields are `name`, `language`,
`file`, and `consent_attestation=true`.

```bash cURL theme={"dark"}
curl -X POST https://api.aireserve.com/v1/custom-voices \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -F "name=Product narrator" \
  -F "language=en-US" \
  -F "tone=warm" \
  -F "use_case=narration" \
  -F "consent_attestation=true" \
  -F "file=@reference.wav;type=audio/wav"
```

```typescript TypeScript theme={"dark"}
const form = new FormData();
form.set("name", "Product narrator");
form.set("language", "en-US");
form.set("tone", "warm");
form.set("use_case", "narration");
form.set("consent_attestation", "true");
form.set("file", new Blob([await Bun.file("reference.wav").arrayBuffer()], { type: "audio/wav" }), "reference.wav");

const response = await fetch("https://api.aireserve.com/v1/custom-voices", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` },
  body: form,
});
const voice = await response.json();
// voice.voice_id is the 8-character ID to use in /audio/speech
```

```python Python theme={"dark"}
import os, requests

with open("reference.wav", "rb") as audio:
    response = requests.post(
        "https://api.aireserve.com/v1/custom-voices",
        headers={"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"},
        files={"file": ("reference.wav", audio, "audio/wav")},
        data={
            "name": "Product narrator",
            "language": "en-US",
            "tone": "warm",
            "use_case": "narration",
            "consent_attestation": "true",
        },
    )
voice = response.json()
# voice["voice_id"] is the 8-character ID to use in /audio/speech
```

A successful create returns `201` with the voice object including `voice_id` — an 8-character
lowercase alphanumeric ID assigned by xAI.

**Optional metadata fields**: `description` (free text), `gender` (`male` / `female` /
`neutral`), `accent`, `age` (`young` / `middle-aged` / `old`), `use_case`
(`conversational` / `narration` / `characters` / `educational` / `advertisement` /
`social_media` / `entertainment`), `tone` (`warm` / `casual` / `professional` / `friendly` /
`authoritative` / `expressive` / `calm`).

### Manage custom voices

| Operation | Endpoint | Notes |
| - | - | - |
| List your voices | `GET /v1/custom-voices` | Returns your org's ownership map, never xAI's team-wide list |
| Read one voice | `GET /v1/custom-voices/{voiceId}` | Refreshes from upstream on every call |
| Update metadata | `PATCH /v1/custom-voices/{voiceId}` | At least one field required; `name` cannot be `null` |
| Delete a voice | `DELETE /v1/custom-voices/{voiceId}` | Removes from xAI and soft-deletes the ownership record; idempotent |

```bash cURL — list theme={"dark"}
curl https://api.aireserve.com/v1/custom-voices \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

```bash cURL — update theme={"dark"}
curl -X PATCH https://api.aireserve.com/v1/custom-voices/ab3f9c2e \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"Warm narrator v2","tone":"warm"}'
```

```bash cURL — delete theme={"dark"}
curl -X DELETE https://api.aireserve.com/v1/custom-voices/ab3f9c2e \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

### Tenant isolation

Every custom voice lives on the platform's single xAI team — xAI cannot separate one
organization's voices from another's at the team level. AI Reserve enforces tenant isolation
through an ownership map: every id-addressed operation checks that the voice is owned by the
calling organization. A voice ID owned by a different organization returns `404` — the same
response as a nonexistent ID. Voice existence is never confirmed cross-tenant.

### Capacity

The shared upstream capacity is currently **200 live custom voices** across the platform. Delete
an unused voice or contact support when `POST /v1/custom-voices` returns `409`; the API does not
expose other organizations or their usage of the shared capacity. Larger allocations are
available on request.

### Data handling

Reference audio uploaded to create a custom voice is transmitted to xAI, which builds and stores
the resulting voice model. AI Reserve stores only the ownership record and consent attestation —
no reference audio is retained by AI Reserve. See the
[provider data handling page](https://privacy.aireserve.com/data-handling) for details.

## Click-to-copy snippets in the portal

The AI Reserve portal's Voice workspace surfaces the same API operations with a click-to-copy
UI: browse the catalog, preview voices, manage your organization's custom voices, and copy the
exact code snippet for any operation. The portal snippets match the endpoints documented here —
there is no separate portal-only API.

## Deferred features

The following are **not available in this release**:

* **Streaming TTS**: real-time audio streaming from text input. Use
  `POST /v1/realtime/sessions` (speech-to-speech) for live voice sessions.
* **Standalone speech-to-text**: transcription-only calls without synthesis.
  See `POST /v1/audio/transcriptions` for the existing OpenAI-compatible transcription endpoint.
* **SIP / telephony integration**: direct PSTN or SIP dial-in/dial-out.
* **Tool calling over TTS**: function calling is not available on the `grok-tts` surface.


# Tool use
Source: https://docs.aireserve.com/capabilities/tool-use

Function calling with Bedrock's exact toolConfig / toolUse / toolResult shapes, in all five SDKs.

Function calling uses Bedrock's exact `toolConfig` / `toolUse` /
`toolResult` shapes. Define tools with a JSON Schema, the model responds with a
`toolUse` block (`stopReason == "tool_use"`), you execute it and send
back a `toolResult` block. Streaming tool calls arrive as
`contentBlockStart` (tool identity) followed by `contentBlockDelta`
events carrying incremental JSON argument fragments — exactly as Bedrock streams them.

```python Python theme={"dark"}
response = client.converse(
    modelId="gpt-5.4-mini",
    messages=[{"role": "user", "content": [{"text": "What's the weather in NYC?"}]}],
    toolConfig={
        "tools": [{
            "toolSpec": {
                "name": "get_weather",
                "description": "Get current weather for a city",
                "inputSchema": {
                    "json": {
                        "type": "object",
                        "properties": {"city": {"type": "string"}},
                        "required": ["city"],
                    }
                },
            }
        }],
        "toolChoice": {"auto": {}},
    },
)

# Assistant responds with a tool call
tool_use = response["output"]["message"]["content"][0]["toolUse"]
print(tool_use["name"])   # "get_weather"
print(tool_use["input"])  # {"city": "NYC"}

# Send the tool result back
response2 = client.converse(
    modelId="gpt-5.4-mini",
    messages=[
        {"role": "user",  "content": [{"text": "What's the weather in NYC?"}]},
        {"role": "assistant", "content": response["output"]["message"]["content"]},
        {"role": "user",  "content": [
            {"toolResult": {
                "toolUseId": tool_use["toolUseId"],
                "content": [{"text": "Sunny, 72°F"}],
            }}
        ]},
    ],
)
```

```typescript TypeScript theme={"dark"}
const response = await client.send(
  new ConverseCommand({
    modelId: "gpt-5.4-mini",
    messages: [{ role: "user", content: [{ text: "What's the weather in NYC?" }] }],
    toolConfig: {
      tools: [{
        toolSpec: {
          name: "get_weather",
          description: "Get current weather for a city",
          inputSchema: {
            json: {
              type: "object",
              properties: { city: { type: "string" } },
              required: ["city"],
            },
          },
        },
      }],
      toolChoice: { auto: {} },
    },
  })
);

// response.stopReason === "tool_use"
const block = response.output?.message?.content?.[0];
if (block && "toolUse" in block) {
  console.log(block.toolUse.name);   // "get_weather"
  console.log(block.toolUse.input);  // { city: "NYC" }
}
```

```go Go theme={"dark"}
resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
    ModelId: audacity.String("gpt-5.4-mini"),
    Messages: []types.Message{{
        Role:    types.ConversationRoleUser,
        Content: []types.ContentBlock{&types.ContentBlockMemberText{Value: "Weather in London?"}},
    }},
    ToolConfig: &types.ToolConfiguration{
        Tools: []types.Tool{{
            ToolSpec: &types.ToolSpecification{
                Name:        "get_weather",
                Description: audacity.String("Returns current weather"),
                InputSchema: &types.ToolInputSchema{
                    Json: map[string]interface{}{
                        "type": "object",
                        "properties": map[string]interface{}{
                            "city": map[string]interface{}{"type": "string"},
                        },
                        "required": []string{"city"},
                    },
                },
            },
        }},
        ToolChoice: &types.ToolChoiceMemberAuto{},
    },
})
// resp.StopReason == "tool_use"
// resp.Output.(*types.ConverseOutputMemberMessage).Value.Content[0].(*types.ContentBlockMemberToolUse)
```

```java Java theme={"dark"}
Map<String, Object> schema = new LinkedHashMap<>();
schema.put("type", "object");
Map<String, Object> props = new LinkedHashMap<>();
Map<String, Object> cityProp = new LinkedHashMap<>();
cityProp.put("type", "string");
props.put("city", cityProp);
schema.put("properties", props);
schema.put("required", List.of("city"));

ConverseResponse resp = client.converse(request -> request
    .modelId("gpt-5.4-mini")
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(ContentBlock.fromText("What's the weather in NYC?"))
        .build())
    .toolConfig(tc -> tc
        .tools(Tool.builder()
            .toolSpec(ts -> ts
                .name("get_weather")
                .description("Get current weather for a city")
                .inputSchema(ToolInputSchema.builder().json(schema).build()))
            .build())
        .toolChoice(ToolChoice.auto())));

ContentBlock block = resp.output().message().content().get(0);
if (block.toolUse() != null) {
    System.out.println("Tool: " + block.toolUse().name());
    System.out.println("Args: " + block.toolUse().input());
}
```

```rust Rust theme={"dark"}
// Rust follows the identical canonical shape: a ToolConfiguration with
// toolSpec { name, description, inputSchema.json } entries and a toolChoice
// of Auto / Any / Tool{name}. The assistant reply carries
// ContentBlock::ToolUse { tool_use_id, name, input } blocks and
// stop_reason == "tool_use"; return results with ContentBlock::ToolResult.
//
// See the crate docs for the builder signatures — they mirror
// aws-sdk-bedrockruntime member-for-member.
```


# Video generation
Source: https://docs.aireserve.com/capabilities/video-generation

Create video from a text prompt with an asynchronous job API — submit, poll, download.

This section is about *creating* video from a text prompt. To send an existing
video to a model for analysis, see [Video input](/capabilities/video-input).

The gateway generates **video** too. Unlike image generation, video is
**asynchronous**: a generation can take from tens of seconds to several
minutes, so you submit a *job* and poll for its result instead of holding one HTTP
request open. Authentication is the same API key as every other route (as
`Authorization: Bearer` or `x-api-key`), and the same per-client
rate limits and spend caps apply.

1. `POST /v1/videos/generations` — submit a job. Answers **202** with a job object containing an `id`.
2. `GET /v1/videos/generations/{id}` — poll the job until its `status` is terminal (`succeeded` or `failed`).

## Quickstart

```bash theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2.6",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5,
    "size": "1280x720"
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the finished clip (mp4)
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

## Request parameters

| Field | Required | Description |
| - | - | - |
| `model` | yes | Video model ID — see the table below |
| `prompt` | yes\* | Text description of the desired video; 1–32,000 characters. \*Optional only when the request carries a media input (see [Media inputs](#media-inputs)) |
| `duration_seconds` | no | Clip length in seconds — each model accepts a specific set of values (see the models table below: `wan-2.6` accepts 5, 10, or 15; `seedance-2.0` and the official-API `seedance-2.0-bytedance`/`-mini`/`-fast` accept integers 4–15; `seedance-2.5` accepts 4–30; `wan3.0-video` accepts 1–30). An unsupported value is rejected synchronously with a 400 listing the allowed values. Omit it to use the model's default. `duration` is accepted as an alias |
| `size` | no | Dimensions as a `"WxH"` string. The gateway maps it to the nearest resolution tier and aspect ratio the model supports — e.g. `1280x720` becomes 720p at 16:9 |
| `user` | no | End-user identifier forwarded for abuse attribution |

## Media inputs

Image-to-video-capable models accept media inputs alongside (or instead of)
the prompt. `wan-2.6` and `seedance-2.0` in the public table below are
**text-to-video only** — they reject every field in this section
synchronously with a 400 naming the unsupported fields, so nothing is ever
silently ignored. `wan3.0-video` accepts keyframe mode (`first_frame` /
`last_frame`) or reference mode (`reference_images` / `reference_videos` /
`reference_audios`, up to 10 / 5 / 5) plus `resolution`, `ratio` (`adaptive`,
`21:9`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`), `audio`, `seed` and
`prompt_extend`; the two modes are mutually exclusive and a prompt is optional
when media is present. The ByteDance official-API Seedance models, the fal
media models, the Higgsfield models, and the (not yet available) BACH models
accept the inputs listed in their own
tables further down; other media-capable models are provisioned per account.
Some models require a prompt even with media, and accepted URL/inline formats
differ by provider — Higgsfield and BACH accept **http(s) URLs only**, not inline images.
These fields apply:

| Field | Description |
| - | - |
| `first_frame` / `last_frame` | Keyframe images the video must start/end on. Each accepts a public HTTPS URL, a `data:image/...;base64,` data URI, or a bare Base64 string (≤20MB image) |
| `image` | Single reference image for single-image i2v models — same accepted shapes as `first_frame`. Accepted by the fal image-to-video models below (`grok-imagine-video-*-i2v`, `flux-3-i2v`, `minimax-h3-max-i2v`), where `first_frame` is an alias for it |
| `reference_images` | Up to 10 reference images (URL, data URI, or Base64 — mixable). Reference them in the prompt as "Image 1", "Image 2", … |
| `reference_videos` / `reference_audios` | Up to 5 each, **http(s) URL only**. Keyframe fields and reference fields are mutually exclusive — mixing them is a 400 |
| `video` | Source clip for video-*extension* models: the model continues this video, guided by the prompt (**http(s) URL only**). Not accepted by any publicly listed model; available on video-extension models provisioned per account |
| `resolution` / `ratio` | Model-native tier name (e.g. `"720p"`) and aspect ratio (e.g. `"16:9"`, `"adaptive"`); when present they win over `size`. **The fal models below do not accept `resolution`** (it is rejected by name): steer their output tier with `size` (`"WxH"`), which snaps to the closest tier in the table. `ratio` is accepted only where the table says so |
| `negative_prompt` | Elements to exclude. Accepted by `flux-3-i2v` and `wan-3.0-prime-reference`; other models reject it by name |
| `audio` | Whether the output carries an audio track (default follows the model) |
| `audio_url` | Audio to drive the video (http(s) URL only). Not accepted by any publicly listed model; available on image-to-video models provisioned per account |
| `seed` | 0–2147483647 for reproducible generations |
| `prompt_extend` | Whether the provider may rewrite/expand the prompt before generating. When omitted, the provider's own default applies (typically on) |

> [!NOTE]
>
> **Inline media and retries.** Requests that pass images inline (data URI or
> bare Base64) are not re-submitted automatically after a transient provider
> rejection — the job fails with a clear message and you should submit again.
> Passing media by URL permits retries after definite transient provider rejections.
> Higgsfield and BACH submissions are **not** retried after ambiguous timeouts or 5xx responses:
> the provider may already have accepted the job and has no documented idempotency key. Inline payloads are
> never persisted in stored job records, and once a job reaches a terminal
> state the platform scrubs the stored request content — prompt, generation
> parameters, media URLs — down to billing metadata (zero content retention;
> scrubbing is deferred while an organization's optional support-capture
> window is open). The job stays readable by id: `status`, `result`, and
> `error` are unaffected.

## The job object

Both endpoints return the same shape — `object` is always
`"video.generation.job"` and `status` moves strictly forward:

| Status | Meaning |
| - | - |
| `queued` | Accepted, not yet dispatched to the provider |
| `running` | Generating. Jobs advance when you poll — keep polling every few seconds |
| `succeeded` | Terminal — `result` is populated |
| `failed` | Terminal — `error` carries the reason; the job stays readable by id |

A finished job looks like this:

```json theme={"dark"}
{
  "id": "3f8a1e2c-9d4b-4c6a-b7e1-2a5c8d9f0e13",
  "object": "video.generation.job",
  "kind": "video",
  "model": "wan-2.6",
  "status": "succeeded",
  "created_at": 1752000000,
  "completed_at": 1752000041,
  "result": {
    "video": {
      "url": "https://…/output.mp4",
      "width": 1280,
      "height": 720,
      "duration": 5
    }
  },
  "error": null,
  "artifact_expires_at": null,
  "upstream_deleted_at": null
}
```

* On success, `result.video.url` is an MP4 hosted on the provider's CDN — **download promptly and persist on your side**; the URL is not permanent. Every model also returns the same URL as `result.videos[0]`, so a parser written against either field works for every provider.
* Generated artifacts follow **each provider's own retention policy** — no fixed deletion window is guaranteed (see the [provider data-handling page](https://privacy.aireserve.com/data-handling) for per-provider retention). `artifact_expires_at` and `upstream_deleted_at` report platform-scheduled deletion of the provider-side artifact where a model supports it; they are `null` for models without platform-side deletion — including every model in the table below.
* Extra metadata in `result` varies by model (for example `wan-2.6` echoes width/height/duration; `seedance-2.0` omits them).
* On failure, `error` is a human-readable string and `result` stays `null`.

## Models & pricing

| Model | Resolutions | Durations | Approximate pricing |
| - | - | - | - |
| `wan-2.6` | 720p, 1080p (16:9, 9:16, 1:1, 4:3, 3:4) | 5, 10, or 15 s | \~$0.10/s at 720p, ~$0.15/s at 1080p |
| `seedance-2.0` | 480p, 720p, 1080p, 4k (16:9, 9:16, 1:1, 21:9) | 4–15 s | \~$0.14/s at 480p, ~$0.30/s at 720p, \~$0.68/s at 1080p, ~$1.56/s at 4k |
| `seedance-2.5` | 480p, 720p, 1080p (16:9, 9:16, 1:1, 4:3, 3:4, 21:9; `adaptive` for image/video inputs) | 4–30 s, audio included | \~$0.10/s at 480p, ~$0.23/s at 720p, \~\$0.57/s at 1080p (token-metered; 16:9 reference rates; lower per-token rate when a reference video is supplied) |
| `seedance-2.0-bytedance` | 480p, 720p, 1080p, 4k (16:9, 9:16, 1:1, 21:9) | 4–15 s | \~$0.07/s at 480p, ~$0.15/s at 720p, \~$0.37/s at 1080p, ~$0.78/s at 4k (token-metered; official ByteDance API) |
| `seedance-2.0-mini` | 480p, 720p (16:9, 9:16, 1:1, 21:9) | 4–15 s | \~$0.03/s at 480p, ~$0.08/s at 720p (token-metered) |
| `seedance-2.0-fast` | 480p, 720p (16:9, 9:16, 1:1, 21:9) | 4–15 s | \~$0.05/s at 480p, ~$0.12/s at 720p (token-metered) |
| `wan3.0-video` | 480P, 720P, 1080P (`adaptive`, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16); keyframe or reference media | 1–30 s, audio included | $0.05/s at 480P, $0.10/s at 720P, \$0.20/s at 1080P |

### Wan 3.0 (Higgsfield)

These three routes use Higgsfield's direct asynchronous HTTP API, not the
LiteLLM engine or a WebSocket. Integration is documented ahead of deployment;
credentials, account funding, and live smoke verification remain deployment steps.
Higgsfield Inc. is a **US operator**, not a PRC-labeled serving leg. Its standard
terms permit training on inputs and outputs; an enterprise no-training carve-out
has **not** been verified for our account. All three routes therefore require the
organization administrator's existing **training and unverified-retention consents**.
See [provider data handling](https://privacy.aireserve.com/data-handling).

| Model | Media fields | List price per generated second |
| - | - | - |
| `wan3.0-video-higgsfield` | Text only; media inputs rejected | 480p $0.05, 720p $0.10, 1080p \$0.20 |
| `wan3.0-i2v-higgsfield` | `image` or `first_frame` required; `last_frame` optional | 480p $0.05, 720p $0.10, 1080p \$0.20 |
| `wan3.0-reference-higgsfield` | Optional `reference_images`, `reference_videos`, `reference_audios` | 480p $0.05, 720p $0.10, 1080p \$0.20 |

All require a nonblank `prompt` (gateway limit 32,000 characters; Higgsfield's
published schema states no prompt maximum). Duration is an integer **2–30 seconds**,
default **5**. Resolution is `480p`, `720p`, or `1080p`, default **1080p**;
ratio is `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, or `adaptive`, default **adaptive**.
`size` maps to the nearest supported tier and ratio; explicit `resolution` and
`ratio` override those dimensions. `audio` defaults to **true**. Optional `seed`
is an integer from **0 to 2147483647**. Rates above are provider list prices before
any customer discount; a 5-second 720p video is \$0.50 at list price. No temporary
promotional discount is assumed.

| Gateway field | Higgsfield field |
| - | - |
| `duration_seconds` | `duration` |
| `ratio` | `aspect_ratio` |
| `audio` | `generate_audio` |
| `image` or `first_frame` | `image_url` |
| `last_frame` | `end_image_url` |
| `reference_images` | `image_urls` |
| `reference_videos` | `video_urls` |
| `reference_audios` | `audio_urls` |
| `prompt`, `resolution`, `seed` | Unchanged |

Use publicly fetchable HTTPS URLs (http(s) URLs accepted); inline Base64/data URIs
and authenticated URLs are not supported. For i2v, send `image` or `first_frame`,
not two different values. Reference arrays are optional, not a requirement to
provide at least one reference. Limits are **10 images, 5 videos, 5 audios**.
The provider additionally enforces video lengths of **1–30 seconds each, 30 seconds
total**, and audio inputs of **WAV/MP3, 30 seconds total**. AI Reserve validates URL
shape and counts, but does not download or inspect source media to measure duration
or format before submit. Do not mix keyframes and reference arrays.

```bash theme={"dark"}
# Submit a source image animation. Requires both organization consents.
JOB=$(curl --fail-with-body -sS https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-i2v-higgsfield",
    "prompt": "A slow cinematic camera push toward the subject",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5,
    "resolution": "720p",
    "ratio": "16:9",
    "audio": true
  }')
JOB_ID=$(printf '%s' "$JOB" | jq -r .id)

# Repeat every few seconds until succeeded or failed; use a deadline in production.
curl --fail-with-body -sS "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

Successful gateway polls expose `result.video.url`. Higgsfield's upstream status
body is flat (`status: "completed"`, `video: { "url": "…" }`); the adapter normalizes
it to the gateway job object. `failed`, `nsfw`, and `canceled` upstream states become
failed gateway jobs. The provider does not document measured duration or cost in
status results; settlement uses the submitted duration and resolution rate.

Download promptly: Higgsfield documents output availability of **at least seven
days**, which is **not** a promise to delete after seven days or a zero-retention
policy. API-specific retention/deletion controls and the account's serving region
remain unverified. `artifact_expires_at` and `upstream_deleted_at` remain `null`.

**Not exposed in this initial integration:** Higgsfield file uploads, cancellation,
webhooks, WebSockets, image generation, Wan Prime or Seedance on Higgsfield;
`enable_thinking`, `file_url`, `link_url`, `negative_prompt`, `prompt_extend`,
`video`, and `audio_url`. Deep thinking remains at the upstream default `false`.
The similarly named fal Wan Prime route below is a different serving provider.

Contracts and list rates: [text-to-video](https://dash.higgsfield.ai/models/alibaba/wan-3.0/text-to-video/llms.txt),
[image-to-video](https://dash.higgsfield.ai/models/alibaba/wan-3.0/image-to-video/llms.txt),
[reference-to-video](https://dash.higgsfield.ai/models/alibaba/wan-3.0/reference-to-video/llms.txt),
[status API](https://docs.higgsfield.ai/docs/api-reference/requests/get-request-status),
[billing and retention](https://docs.higgsfield.ai/docs/concepts/billing-and-retention).

### BACH (Video Rebirth)

Three routes onto Video Rebirth's asynchronous `bach-1.0` HTTP API, integrated
through the same media-job pipeline as the Higgsfield routes (submit → poll →
settle). **They are not yet available.** The integration ships dark: the
models are absent from `GET /v1/models`, and a request to any of them is
refused synchronously with `422 MODEL_NOT_CONFIGURED` (a platform fault — you
are not charged, no job is created) until the platform has recorded both the
provider credentials and the provider's list rates. No rate is published by
Video Rebirth today, so **no price is quoted here**; this section will gain a
pricing table when the rates are recorded, and the models will then appear
in the catalog automatically.

Video Rebirth publishes no API-content terms (training use, retention,
deletion, processing region are all pending verification), and the platform
labels it China-affiliated pending vendor diligence, so once enabled the
routes require the organization administrator's **PRC-affiliated-models and
unverified-retention consents**. See
[provider data handling](https://privacy.aireserve.com/data-handling).

| Model | Media fields | Duration (integer seconds) |
| - | - | - |
| `bach-1.0-video` | Text only; `negative_prompt` and `prompt_extend` accepted | 1–8, default 8 |
| `bach-1.0-i2v` | `image` (or `first_frame`) and/or `last_frame`, http(s) URLs | 1–8 with a first frame only; 1–6 when `last_frame` is set; default 6 |
| `bach-1.0-reference` | `reference_images`: 1–9 http(s) URLs | 1–8, default 6 |

`prompt` is required except for `bach-1.0-i2v` (where the frames can carry the
shot) and is capped at **10,000 characters**, as is `negative_prompt`.
Resolution is `720p` or `1080p`, default **720p**; ratio is `16:9`, `9:16`, or
`1:1`, default **16:9** (`bach-1.0-i2v` takes its aspect from the frame and does
not accept `ratio`). `size` maps to the nearest tier and ratio; explicit
`resolution` / `ratio` win. Media must be publicly fetchable http(s) URLs —
inline Base64 / data URIs are rejected. `audio`, `seed`, `reference_videos`,
`reference_audios`, and `video` are not accepted (audio in particular is
withheld until the provider's audio surcharge, if any, is known — accepting it
now would price audio at the silent-video rate).

| Gateway field | BACH field |
| - | - |
| `duration_seconds` | `duration` |
| `ratio` | `aspect_ratio` |
| `prompt_extend` | `enhance_prompt` |
| `image` or `first_frame` | `image_url` |
| `last_frame` | `end_image_url` |
| `reference_images` | `reference_inputs` (`{ type: "image", url }`) |
| `prompt`, `negative_prompt`, `resolution` | Unchanged |

Successful polls expose `result.video.url`. Upstream `TASK_FAILED` results
(including the provider's content-safety rejection, "Contains sensitive
information.") become failed gateway jobs; billing uses the submitted duration
and resolution tier. Download promptly — Video Rebirth advises callers to
transfer and store generated videos promptly and states that task results can
expire; that is not a deletion commitment, and `artifact_expires_at` /
`upstream_deleted_at` stay `null`. Bach submissions are not retried after
ambiguous timeouts or 5xx responses (no documented idempotency key); a
provider queue-capacity answer is retried like any transient rejection.

**Enable runbook (operators, in order):**

1. Apply infrastructure so the two secret containers and the proxy's access grants exist: dispatch the **Infrastructure Deploy** workflow from `main` with `environment=uat`, then `environment=production` (`action=up`), or run `cd packages/infra && bun up:uat` / `bun up:production`. The workflow is `workflow_dispatch` only — it does not run on merge.
2. Add the credential versions, UAT first: `gcloud secrets versions add BACH_ACCESS_KEY --project audacity-uat --data-file=-` and `gcloud secrets versions add BACH_SECRET_KEY --project audacity-uat --data-file=-`; repeat with `--project audacity-production`. Never create the secrets themselves with `gcloud` — Pulumi owns them.
3. Once Video Rebirth's rates are in writing, commit `packages/db/scripts/pricing-sync/update-provider-pricing-<date>-bach.ts` with one row per model under `provider: "bach"` — `inputPricePer1mTokens` = USD per 1,000,000 generated seconds at 720p, `outputPricePer1mTokens` = the same at 1080p, `outputPricePerImage` = the default-job reference for reporting. The Provider Pricing Apply workflow applies it on merge; `scripts/pricing-sync/bach-pricing-parity.test.ts` pins the column convention. A `0.000000` placeholder is not a rate card — the model stays dark.
4. Deploy `litellm-proxy` (UAT auto-deploys on merge; production through **Deploy All**). The adapter re-reads pricing every 60 seconds, so no restart is needed for a rate change alone.
5. Smoke on UAT: confirm the three ids appear in `GET /v1/models`, submit a `bach-1.0-video` job, poll to `succeeded`, and check the usage row carries `provider: "bach"` with the expected estimated cost.

Contract: [API general guide](https://www.bach.art/docs/general),
[error codes](https://www.bach.art/docs/error),
[text-to-video](https://www.bach.art/docs/videos-bach/v1/text2video),
[image-to-video](https://www.bach.art/docs/videos-bach/v1/image2video),
[reference-to-video](https://www.bach.art/docs/videos-bach/v1/reference2video).

### Image-to-video and reference-to-video (fal)

These models start from your media instead of a bare prompt: pass `image`
(or `first_frame`) for image-to-video, or `reference_images` for
reference-to-video, alongside the prompt. They are served by fal in the
United States and billed per second of finished video at fal's list price
(plus the small per-input-image fee where fal charges one).

| Model | Input | Resolutions | Approximate pricing |
| - | - | - | - |
| `grok-imagine-video-1.5-i2v` | `image` | 480p, 720p, 1080p | $0.08/s, $0.14/s, $0.25/s + $0.01/image |
| `grok-imagine-video-1.5-reference` | `reference_images` (≤7) | 480p, 720p | $0.08/s, $0.14/s + \$0.01/image |
| `grok-imagine-video-i2v` | `image` | 480p, 720p | $0.05/s, $0.07/s + \$0.002/image |
| `flux-3-i2v` | `image` | 720p, 1080p | $0.17/s, $0.29/s (5–20 s) |
| `seedance-2.5-reference` | `reference_images` | 480p, 720p, 1080p | \~$0.22/s, ~$0.47/s, \~\$1.16/s (token-metered) |
| `seedance-2.0-mini-reference` | `reference_images` | 480p, 720p | \~$0.07/s, ~$0.15/s (token-metered) |
| `wan-3.0-prime-reference` | `reference_images` (+ `reference_videos`, `reference_audios`) | 480p, 720p, 1080p | $0.068/s, $0.14/s, \$0.28/s |
| `minimax-h3-max-i2v` | `image` (+ `last_frame`) | 480p, 768p, 1080p | $0.05/s, $0.08/s, \$0.16/s |

Video-to-video utilities on fal (reframe, upscale, translate, prompt-driven
edit, background removal) bill per second of the **source** clip and are
provisioned per account — they are not in the public model list.

### Image-to-video and reference-to-video (ByteDance official API)

The ByteDance official-API Seedance models in the table above also take
media inputs — the same model ids, no separate `-i2v` / `-reference`
variants. Two modes, mutually exclusive on one request:

* **Keyframe mode**: `first_frame` (or its alias `image`) starts the clip on
  your image; add `last_frame` to also pin the closing frame. Images may be a
  public URL, a `data:image/...;base64,` data URI, or bare Base64 (PNG, JPEG,
  GIF, WebP, BMP).
* **Reference mode** (ByteDance's "omni reference"): `reference_images`,
  `reference_videos` and `reference_audios`, in any combination, referenced in
  the prompt as "Image 1", "Video 1", "Audio 1". Video editing and video
  extension are reference-mode requests whose prompt describes the change or
  the continuation of a `reference_videos` clip. Videos and audio are
  http(s) URLs only.

| Model | Inputs | Notes |
| - | - | - |
| `seedance-2.5` | `first_frame`/`image` (+ `last_frame`); `reference_images` (≤10), `reference_videos` (≤5), `reference_audios` (≤5) | Image and video inputs keep the input's aspect ratio (`ratio` must be omitted or `adaptive`); `size` still selects the resolution tier |
| `seedance-2.0-bytedance` | same fields; `reference_images` ≤9, `reference_videos` ≤3, `reference_audios` ≤3 | 480p–4k output |
| `seedance-2.0-mini` / `seedance-2.0-fast` | same fields and caps as `seedance-2.0-bytedance` | 480p–720p output |

`audio` (boolean) toggles the generated soundtrack and `seed` is forwarded.
ByteDance does not accept reference images or videos that contain real
human faces on these models. Billing stays token-metered on the finished
clip; when a request carries a `reference_videos` clip, ByteDance bills the
input clip's duration as well, at a lower per-token rate, and the job's
`cost` reflects the tokens ByteDance reports.

Video is billed **per second of finished video** at the tier actually
generated — a 5-second `wan-2.6` clip at 720p is roughly \$0.50. Only videos that
finish successfully are billed. Each job's cost is metered against your key exactly like
chat and image traffic, appears in your usage reporting, and counts toward the same spend
caps.

## Polling from Python

A production-shaped loop with a hard deadline: poll every few seconds, treat 5xx poll
errors as transient (the job keeps running server-side), and give up after a sensible
timeout. A typical 5-second `wan-2.6` clip completes in under a minute; longer
clips and higher tiers take proportionally longer.

```python theme={"dark"}
import os, time, requests

BASE = "https://api.aireserve.com"
HEADERS = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

job = requests.post(
    f"{BASE}/v1/videos/generations",
    headers=HEADERS,
    json={
        "model": "wan-2.6",
        "prompt": "A drone shot over a misty pine forest at sunrise",
        "duration_seconds": 5,
        "size": "1280x720",
    },
    timeout=30,
)
job.raise_for_status()
job = job.json()

deadline = time.monotonic() + 600          # give up after 10 minutes
while job["status"] in ("queued", "running"):
    if time.monotonic() > deadline:
        raise TimeoutError(f"video job {job['id']} did not finish in time")
    time.sleep(3)
    resp = requests.get(
        f"{BASE}/v1/videos/generations/{job['id']}", headers=HEADERS, timeout=30
    )
    if resp.status_code >= 500:
        continue                            # transient — retry the next poll
    resp.raise_for_status()
    job = resp.json()

if job["status"] == "succeeded":
    url = job["result"]["video"]["url"]
    with open("clip.mp4", "wb") as f:       # download promptly — URLs expire
        f.write(requests.get(url, timeout=120).content)
else:
    print("generation failed:", job["error"])
```

> [!NOTE]
>
> **SDK note.** The SDKs do not yet ship a video-generation helper — call the
> HTTP endpoints directly as above. Typed helpers in all five languages are coming in an
> upcoming SDK release.

## Errors

Submission errors reuse the familiar codes: 400 `invalid_request_error` for a
malformed body, 401 `invalid_api_key`, 402 `usage_cap_exceeded` when
a spend cap is reached, and 429 `rate_limit_exceeded` with a
`Retry-After` header. Three video-specific cases:

* **400 at submit** — `duration_seconds` is not one of the values the model supports (for example `wan-2.6` only accepts 5, 10, or 15). The message lists the allowed values; no job is created.
* **502 at submit** — the provider rejected the job synchronously (for example a prompt rejected by upstream validation). The response carries the provider's message and a `job_id`; the failed job remains readable by id.
* **404 `job_not_found` on poll** — the job id is unknown or belongs to a different workspace's key.

> [!NOTE]
>
> **Content policy.** Upstream video providers apply safety filtering to
> prompts and outputs. A prompt that violates the provider's content policy fails the
> generation — the job lands in `failed` with the provider's message in
> `error` (or, if rejected at submit, in the 502 response).


# Video input (understanding)
Source: https://docs.aireserve.com/capabilities/video-input

Send a video to a model and ask questions about it — inline bytes up to 20 MB, or upload once and reference by URI up to 1 GB.

Send a video **to** a model and ask questions about it — summarize a
recording, extract action items from a meeting, describe what happens in a clip.
Bedrock-style `video` content blocks are supported in user messages, mirroring
the `bytes` | `s3Location` pattern of Bedrock Converse's
video source. This is the input-side counterpart of
[Video generation](/capabilities/video-generation), which *creates* video from a
text prompt — don't confuse the two.

## Model support

Video input is available on the **Gemini family only**. Sending a video
block to any other model returns an HTTP **400** before the request reaches
the provider (see [Limits & errors](#limits-&-errors)).

| Model | Video input |
| - | - |
| `gemini-2.5-flash` | yes |
| `gemini-2.5-pro` | yes |
| `gemini-3-flash-preview` | yes |
| `gemini-3.8-flash` | yes |
| Every other model | no — HTTP 400 |

## Inline video (≤ 20 MB)

For small files, hand the SDK **raw bytes** — it base64-encodes them into
the request for you. Base64 inflates bytes by \~33% against the gateway's 30 MB
request cap, so inline video is capped at **20 MB raw** per request
(larger inline payloads are rejected with HTTP 413 — use the upload flow below instead).
All five SDKs support video input as of **SDK v0.3.0**.

```python Python theme={"dark"}
with open("demo.mp4", "rb") as f:
    video_bytes = f.read()

response = client.converse(
    modelId="gemini-2.5-flash",
    messages=[{
        "role": "user",
        "content": [
            {"text": "Summarize what happens in this video."},
            {"video": {"format": "mp4", "source": {"bytes": video_bytes}}},
        ],
    }],
)
print(response["output"]["message"]["content"][0]["text"])
```

```typescript TypeScript theme={"dark"}
import { readFile } from "node:fs/promises";

const videoBytes = new Uint8Array(await readFile("demo.mp4"));

const response = await client.send(
  new ConverseCommand({
    modelId: "gemini-2.5-flash",
    messages: [
      {
        role: "user",
        content: [
          { text: "Summarize what happens in this video." },
          { video: { format: "mp4", source: { bytes: videoBytes } } },
        ],
      },
    ],
  })
);
```

```go Go theme={"dark"}
videoBytes, err := os.ReadFile("demo.mp4")
if err != nil {
    log.Fatal(err)
}

resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
    ModelId: audacity.String("gemini-2.5-flash"),
    Messages: []types.Message{{
        Role: types.ConversationRoleUser,
        Content: []types.ContentBlock{
            &types.ContentBlockMemberText{Value: "What happens in this video?"},
            &types.ContentBlockMemberVideo{Value: types.VideoBlock{
                Format: types.VideoFormatMp4,
                Source: &types.VideoSourceMemberBytes{Value: videoBytes},
            }},
        },
    }},
})
```

```java Java theme={"dark"}
byte[] videoBytes = java.nio.file.Files.readAllBytes(java.nio.file.Path.of("demo.mp4"));

ConverseResponse resp = client.converse(request -> request
    .modelId("gemini-2.5-flash")
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(
            ContentBlock.fromText("What happens in this video?"),
            ContentBlock.fromVideo(VideoBlock.builder()
                .format(VideoFormat.MP4)
                .source(VideoSource.fromBytes(videoBytes))
                .build()))
        .build()));
```

```rust Rust theme={"dark"}
use audacity_sdk::{ContentBlock, VideoBlock, VideoFormat, VideoSource};

let video_bytes = std::fs::read("demo.mp4")?;

let response = client.converse()
    .model_id("gemini-2.5-flash")
    .messages(
        Message::builder()
            .role(ConversationRole::User)
            .content(ContentBlock::Text("What happens in this clip?".into()))
            .content(ContentBlock::Video(VideoBlock {
                format: VideoFormat::Mp4,
                source: VideoSource::Bytes(video_bytes),
            }))
            .build()?
    )
    .send()
    .await?;
```

## Large videos: upload, then reference by URI

For files over 20 MB (up to **1 GB**), upload once and reference
the returned `audacity://files/…` URI in as many requests as you like. The
flow has three steps:

1. `POST /v1/files` with `content_type` and `size_bytes` — returns a `file_id`, a signed `upload_url` (valid \~15 minutes), the `uri` to reference in chat requests, and `expires_at`.
2. Upload the bytes to `upload_url` over a **resumable session** (Google Cloud Storage protocol: one POST opens the session, then PUT the bytes).
3. Reference the video with `{"video": {"format": …, "source": {"uri": …}}}` in a `Converse` call.

The file-create step from curl:

```bash theme={"dark"}
# 1) Create an upload slot
curl -s https://api.aireserve.com/v1/files \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content_type": "video/mp4", "size_bytes": 52428800}'
```

```json theme={"dark"}
{
  "file_id": "3f8a1e2c-9d4b-4c6a-b7e1-2a5c8d9f0e13",
  "upload_url": "https://storage.googleapis.com/…&X-Goog-Signature=…",
  "uri": "audacity://files/3f8a1e2c-9d4b-4c6a-b7e1-2a5c8d9f0e13",
  "expires_at": "2026-07-09T05:20:00.000Z"
}
```

```bash theme={"dark"}
# 2) Open the resumable session (the session URI comes back in the Location header)
SESSION_URI=$(curl -si -X POST "$UPLOAD_URL" \
  -H "x-goog-resumable: start" \
  -H "Content-Type: video/mp4" \
  | awk 'tolower($1)=="location:" {print $2}' | tr -d "\r")

# 3) Upload the bytes (a single PUT works; the SDK helpers chunk + auto-resume)
curl -X PUT "$SESSION_URI" --data-binary @keynote.mp4
```

`GET /v1/files/{file_id}` reports upload status — `"pending"`
before the bytes land, then `"uploaded"` with `size_bytes` and
`content_type`.

The SDK helpers (`client.files.upload` in Python/TypeScript,
`UploadFile`/`uploadFile` in Go/Java, `upload_file()` in
Rust) run this whole flow for you and stream the file in 8 MB chunks, automatically
resuming from the last confirmed byte after a network drop. The full loop in Python:

```python theme={"dark"}
from audacity import Audacity

client = Audacity()   # AIRESERVE_API_KEY from the environment

# Upload once — accepts raw bytes or a file path; resumable under the hood
upload = client.files.upload("keynote.mp4", content_type="video/mp4")
# {"file_id": …, "upload_url": …, "uri": "audacity://files/…", "expires_at": …}

# Reference the uploaded video by URI — reusable across requests for ~24 h
response = client.converse(
    modelId="gemini-2.5-pro",
    mediaResolution="low",   # optional cost knob — see below
    messages=[{
        "role": "user",
        "content": [
            {"text": "Summarize this keynote and list the action items."},
            {"video": {"format": "mp4", "source": {"uri": upload["uri"]}}},
        ],
    }],
)
print(response["output"]["message"]["content"][0]["text"])
```

Uploaded files are **transient inference inputs**: they expire after
**\~24 hours** and are scoped to your workspace's API keys — a URI leaked to
another workspace resolves against that workspace's namespace and simply does not exist.
Re-referencing the same URI across conversation turns is free; the gateway caches the
provider-side staging, so a large video is not re-transferred on every request.

> [!NOTE]
>
> **Calling without an SDK?** On the raw
> [OpenAI-protocol endpoint](/connect/openai-sdk), video rides the `file`
> content part — inline as a data URL in `file_data`, or by reference in
> `file_id` — with the MIME type in `format`:
>
> ```json theme={"dark"}
> {"type": "file", "file": {"file_data": "data:video/mp4;base64,…", "format": "video/mp4"}}
> {"type": "file", "file": {"file_id": "audacity://files/3f8a1e2c-…", "format": "video/mp4"}}
> ```
>
> A per-part `"detail"` field and a request-level
> `"media_resolution"` field control media resolution (next section).

## Media resolution (video token cost)

Video is tokenized frame by frame on Gemini, so long clips get expensive fast. The
request-level `mediaResolution` option (wire name:
`media_resolution`) controls how densely video is sampled —
`"low"` processes video at roughly **4× fewer tokens**. Non-Gemini
models ignore the field; when unset, the model's default applies.

| Value | Guidance |
| - | - |
| `low` | \~4× fewer video tokens. The right default for summarization, transcription-style tasks, and long footage |
| `medium` | Balanced sampling for general question-answering about a clip |
| `high` | Finer sampling — reading small on-screen text, UI walkthroughs, fine visual detail |
| `ultra_high` | Maximum fidelity at maximum token cost — dense charts or frame-critical analysis |

Raw-protocol callers can also set `detail` per content part; an explicit
per-part value wins over the request-level field. On **Gemini 2.5** models
the highest resolution across all parts applies to the whole request; true per-part
granularity starts with **Gemini 3**.

## Supported formats

| SDK `format` | MIME type (`content_type` for uploads) |
| - | - |
| `mp4` | `video/mp4` |
| `mov` | `video/mov` |
| `mkv` | `video/x-matroska` |
| `webm` | `video/webm` |
| `flv` | `video/x-flv` |
| `mpeg` | `video/mpeg` |
| `mpg` | `video/mpg` |
| `wmv` | `video/wmv` |
| `three_gp` | `video/3gpp` |

## Limits & errors

* **Inline cap** — 20 MB of raw video per request (all video parts combined). Exceeding it returns **413** with a message pointing to the upload flow.
* **Upload cap** — 1 GB per file. `POST /v1/files` rejects a larger `size_bytes`, or an unsupported `content_type`, with **400**.
* **Upload URL expiry** — the signed `upload_url` is valid \~15 minutes; create a fresh slot if it lapses.
* **File expiry** — uploaded files auto-delete after \~24 hours. Referencing an expired or unknown URI fails with **400**: `video file "audacity://files/…" not found or expired; upload via POST /v1/files and retry`.
* **Non-video model** — sending video to anything outside the Gemini family returns **400** before the provider is contacted. The SDKs raise `ValidationException`; the raw response looks like:

```json theme={"dark"}
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "model \"gpt-5.4-mini\" does not support video input; video is supported on: gemini-2.5-flash, gemini-2.5-pro, gemini-3-flash-preview",
    "request_id": "…"
  }
}
```

* Video blocks are valid in **user** messages only, matching image input.

> [!NOTE]
>
> **boto3 / AWS SDK path.** The [Bedrock-compatible
> endpoint](/connect/aws-sdk) does not accept `video` content blocks — it returns a
> `ValidationException` listing its supported block types. Use one of the
> AI Reserve SDKs or the raw OpenAI-protocol wire format above for video.


# Images (vision)
Source: https://docs.aireserve.com/capabilities/vision

Send images to vision-capable models — raw bytes or a hosted URL — with Bedrock-style image content blocks.

Bedrock-style `image` content blocks are supported in user messages on
vision-capable models. Hand the SDK **raw bytes** (it base64-encodes them for
you, Bedrock parity) or — an AI Reserve extension Bedrock doesn't offer — a
**hosted URL**, which is passed through verbatim so your payload stays tiny.
Supported formats: `png`, `jpeg`, `gif`, `webp`.

```python Python theme={"dark"}
with open("chart.png", "rb") as f:
    image_bytes = f.read()

response = client.converse(
    modelId="gpt-5.5",
    messages=[{
        "role": "user",
        "content": [
            {"text": "What does this chart show?"},
            {"image": {"format": "png", "source": {"bytes": image_bytes}}},
        ],
    }],
)

# Or reference a hosted image directly (not available in Bedrock):
# {"image": {"format": "jpeg", "source": {"url": "https://example.com/photo.jpg"}}}
```

```typescript TypeScript theme={"dark"}
import { readFile } from "node:fs/promises";

const imageBytes = new Uint8Array(await readFile("chart.png"));

const response = await client.send(
  new ConverseCommand({
    modelId: "gpt-5.5",
    messages: [
      {
        role: "user",
        content: [
          { text: "What does this chart show?" },
          { image: { format: "png", source: { bytes: imageBytes } } },
        ],
      },
    ],
  })
);

// Or reference a hosted image directly (not available in Bedrock):
// { image: { format: "jpeg", source: { url: "https://example.com/photo.jpg" } } }
```

```go Go theme={"dark"}
imageBytes, err := os.ReadFile("chart.png")
if err != nil {
    log.Fatal(err)
}

resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
    ModelId: audacity.String("gpt-5.5"),
    Messages: []types.Message{{
        Role: types.ConversationRoleUser,
        Content: []types.ContentBlock{
            &types.ContentBlockMemberText{Value: "What does this chart show?"},
            &types.ContentBlockMemberImage{Value: types.ImageBlock{
                Format: types.ImageFormatPng,
                Source: &types.ImageSourceMemberBytes{Value: imageBytes},
            }},
        },
    }},
})

// Or reference a hosted image directly (not available in Bedrock):
// Source: &types.ImageSourceMemberUrl{Value: "https://example.com/photo.jpg"}
```

```java Java theme={"dark"}
byte[] imageBytes = java.nio.file.Files.readAllBytes(java.nio.file.Path.of("chart.png"));

ConverseResponse resp = client.converse(request -> request
    .modelId("gpt-5.5")
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(
            ContentBlock.fromText("What does this chart show?"),
            ContentBlock.fromImage(ImageBlock.builder()
                .format(ImageFormat.PNG)
                .source(ImageSource.fromBytes(imageBytes))
                .build()))
        .build()));

// Or reference a hosted image directly (not available in Bedrock):
// ImageSource.fromUrl("https://example.com/photo.jpg")
```

```rust Rust theme={"dark"}
use audacity_sdk::{ContentBlock, ImageBlock, ImageFormat, ImageSource};

let image_bytes = std::fs::read("chart.png")?;

let response = client.converse()
    .model_id("gpt-5.5")
    .messages(
        Message::builder()
            .role(ConversationRole::User)
            .content(ContentBlock::Text("What does this chart show?".into()))
            .content(ContentBlock::Image(ImageBlock {
                format: ImageFormat::Png,
                source: ImageSource::Bytes(image_bytes),
            }))
            .build()?
    )
    .send()
    .await?;

// Or reference a hosted image directly (not available in Bedrock):
// source: ImageSource::Url("https://example.com/photo.jpg".into())
```

## Payload guidance

* Base64 inflates bytes by \~33%; with the gateway's 30 MB request cap, keep inline images at roughly **20 MB raw or less**.
* For large or frequently reused images, prefer `source.url` — the request stays small and the provider fetches the image directly.
* Text-only conversations are wire-identical to before image support existed; nothing changes unless a turn actually contains an image.
* Image blocks are valid in **user** messages only (Bedrock parity); blocks in assistant turns are ignored.


# Aider
Source: https://docs.aireserve.com/connect/aider

Run aider, the terminal pair programmer, through the AI Reserve gateway with two environment variables.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — every aider request is then
> metered and billed through your organization.

Aider speaks the OpenAI chat-completions format and takes a custom endpoint
entirely through environment variables
([aider's OpenAI-compatible guide](https://aider.chat/docs/llms/openai-compat.html)).
Set the base to the gateway's `/v1` surface and prefix model names with
`openai/`:

```bash theme={"dark"}
export OPENAI_API_BASE="https://api.aireserve.com/v1"   # /v1 suffix
export OPENAI_API_KEY="$AIRESERVE_API_KEY"              # your aireserve_api_… key

aider --model openai/gpt-5.4-mini
```

The `openai/` prefix is aider's routing convention for "OpenAI-compatible
endpoint", not a vendor claim — Claude models ride the same surface, so
`aider --model openai/claude-sonnet-4-6` routes through the gateway too.

> [!NOTE]
>
> **Expect a one-time "unknown model" warning.** Aider keeps its own metadata
> catalog and doesn't recognize gateway model ids, so it warns that the
> context window and costs are unknown. The warning is cosmetic — requests
> work regardless. Accept it, pass `--no-show-model-warnings`, or pin
> metadata in [`.aider.model.metadata.json`](https://aider.chat/docs/config/adv-model-settings.html).

## Verify

Run a one-shot edit from any git repository:

```bash theme={"dark"}
aider --model openai/gpt-5.4-mini --yes-always \
  --message "add a docstring to the top of the main module"
```

Aider prints the model's reply and its token/cost line. The request appears on
your [Spend page](https://portal.aireserve.com/spend) seconds later —
metered against the key you exported.


# Anthropic SDK
Source: https://docs.aireserve.com/connect/anthropic-sdk

Point the official anthropic package at the gateway — host root, no /v1 — and reach every gateway model.

Keep the official `anthropic` package: change the base URL to the **host root without
`/v1`** (the SDK appends `/v1/messages` itself), use your AI Reserve API key, and every
gateway model — not just Claude — answers the same call.

```python Python theme={"dark"}
import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.aireserve.com",  # host root — NO /v1
    api_key=os.environ["AIRESERVE_API_KEY"],
)

# Works with Claude models — and with GPT model IDs too (bridged).
res = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=256,
    messages=[{"role": "user", "content": "hello"}],
)
print(res.content[0].text)
```

```typescript TypeScript theme={"dark"}
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.aireserve.com", // host root — NO /v1
  apiKey: process.env.AIRESERVE_API_KEY,
});

// Works with Claude models — and with GPT model IDs too (bridged).
const res = await client.messages.create({
  model: "claude-haiku-4-5-20251001",
  max_tokens: 256,
  messages: [{ role: "user", content: "hello" }],
});
```

Migrating an existing Anthropic codebase? The [Migrating from Anthropic](/migrate/from-anthropic)
guide covers the full concept mapping. Using Claude Code or the Claude Agent SDK instead?
They are configured entirely through environment variables — see the
[Claude Code recipe](/connect/claude-code).


# AWS SDK (boto3) / Bedrock migration
Source: https://docs.aireserve.com/connect/aws-sdk

Keep your unmodified boto3 / AWS SDK Bedrock code — override the endpoint and credentials, and every call site stays byte-identical.

**Already on Bedrock? Keep your code.** The gateway serves the Bedrock
Converse API at the same paths the AWS SDKs call
(`POST /model/{modelId}/converse` and
`POST /model/{modelId}/converse-stream`), so an unmodified
`boto3` `bedrock-runtime` client works by overriding the endpoint
and credentials — every `converse()` / `converse_stream()` call
site, message shape, `toolConfig`, *and `modelId` string*
stays byte-identical:

```diff theme={"dark"}
 import boto3

-# Before — real AWS Bedrock
-client = boto3.client("bedrock-runtime", region_name="us-east-1")
+# After — AI Reserve gateway (the whole migration)
+client = boto3.client(
+    "bedrock-runtime",
+    endpoint_url="https://api.aireserve.com",
+    aws_access_key_id=os.environ["AIRESERVE_API_KEY"],  # your aireserve_api_… key
+    aws_secret_access_key="aireserve",  # ignored — any value
+    region_name="us-east-1",            # ignored — any value
+)

 response = client.converse(
     modelId="us.anthropic.claude-sonnet-4-5-20250929-v1:0",  # unchanged
     messages=[{"role": "user", "content": [{"text": "Hi"}]}],
     inferenceConfig={"maxTokens": 256},
 )
```

**Why the secret key and region don't matter:** boto3 signs every request
with SigV4 and puts the access-key ID in the `Authorization` header's
`Credential` field. The gateway authenticates the
`aireserve_api_…` key it finds there — the key itself is the bearer secret,
carried over TLS, exactly the same trust model as the `x-api-key` header on
every other endpoint. The SigV4 *signature* (which is what the fake secret key
produces) is ignored, and no region routing exists — there is one gateway.

## Full example

```python theme={"dark"}
import os
import boto3

client = boto3.client(
    service_name="bedrock-runtime",
    endpoint_url="https://api.aireserve.com",
    aws_access_key_id=os.environ["AIRESERVE_API_KEY"],
    aws_secret_access_key="aireserve",
    region_name="us-east-1",
)

response = client.converse(
    modelId="claude-sonnet-4-6-bedrock",
    messages=[{"role": "user", "content": [{"text": "Say hello in five words."}]}],
    inferenceConfig={"maxTokens": 64, "temperature": 0.5},
)

print(response["output"]["message"]["content"][0]["text"])
print(response["usage"])       # {"inputTokens": …, "outputTokens": …, "totalTokens": …}
print(response["stopReason"])  # "end_turn"
```

**Streaming** works the same way — `converse_stream()` responses
are real AWS binary event streams (`application/vnd.amazon.eventstream`,
per-frame CRC32 checksums), yielding the standard Bedrock event union
(`messageStart → contentBlockDelta → … → messageStop → metadata`) with token
usage in the final `metadata` event:

```python theme={"dark"}
stream_response = client.converse_stream(
    modelId="claude-sonnet-4-6-bedrock",
    messages=[{"role": "user", "content": [{"text": "Write me a haiku."}]}],
)

for event in stream_response["stream"]:
    if "contentBlockDelta" in event:
        print(event["contentBlockDelta"]["delta"].get("text", ""), end="", flush=True)
    elif "metadata" in event:
        print("\n", event["metadata"]["usage"])  # {"inputTokens": …, "outputTokens": …, "totalTokens": …}
```

The same two overrides work from the AWS JS SDK
(`@aws-sdk/client-bedrock-runtime`):

```typescript theme={"dark"}
import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";

const client = new BedrockRuntimeClient({
  endpoint: "https://api.aireserve.com",
  region: "us-east-1", // ignored — any value
  credentials: {
    accessKeyId: process.env.AIRESERVE_API_KEY!, // your aireserve_api_… key
    secretAccessKey: "aireserve",                // ignored — any value
  },
});

const response = await client.send(new ConverseCommand({
  modelId: "claude-sonnet-4-6-bedrock",
  messages: [{ role: "user", content: [{ text: "Hi" }] }],
}));
```

## Model IDs

**Your existing AWS model ids work as-is.** The gateway resolves the
Bedrock model ids below to their AI Reserve catalog equivalents, so migrating code
keeps its `modelId` strings untouched. Region inference-profile prefixes
(`global.` / `us.` / `eu.` / `apac.`) are optional, and full Bedrock ARNs
(`foundation-model` or `inference-profile`) are accepted too. The prefix picks the
geography for Claude, exactly as it does on Bedrock: a `us.` id resolves to the
`-bedrock-us` leg (US geographic profile, processed only in AWS US regions, billed at
Bedrock's geographic rate); `global.`, `eu.`, `apac.` and bare ids resolve to the
`-bedrock` leg (global cross-region profile, Anthropic list price). Llama, Mistral and
DeepSeek ids resolve to their single `-bedrock` leg for every prefix.

| AWS model id (as-is) | AI Reserve id | Notes |
| - | - | - |
| `global.anthropic.claude-fable-5-1` (or bare) | `claude-fable-5-1-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-fable-5-1` | `claude-fable-5-1-bedrock-us` | Served via AWS Bedrock, US geographic profile (US-only processing) |
| `global.anthropic.claude-fable-5` (or bare) | `claude-fable-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-fable-5` | `claude-fable-5-bedrock-us` | Served via AWS Bedrock, US geographic profile (US-only processing) |
| `global.anthropic.claude-opus-5-5` (or bare) | `claude-opus-5-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-opus-5-5` | `claude-opus-5-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-opus-5` (or bare) | `claude-opus-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-opus-5` | `claude-opus-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-opus-4-8` (or bare) | `claude-opus-4-8-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-opus-4-8` | `claude-opus-4-8-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-opus-4-7` (or bare) | `claude-opus-4-7-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-opus-4-7` | `claude-opus-4-7-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-sonnet-5-5` (or bare) | `claude-sonnet-5-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-sonnet-5-5` | `claude-sonnet-5-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-sonnet-5` (or bare) | `claude-sonnet-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-sonnet-5` | `claude-sonnet-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-opus-4-6-v1` (or bare) | `claude-opus-4-6-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-opus-4-6-v1` | `claude-opus-4-6-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-sonnet-4-6` (or bare) | `claude-sonnet-4-6-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-sonnet-4-6` | `claude-sonnet-4-6-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-sonnet-4-5-20250929-v1:0` (or bare) | `claude-sonnet-4-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-sonnet-4-5-20250929-v1:0` | `claude-sonnet-4-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `global.anthropic.claude-haiku-4-5-20251001-v1:0` (or bare) | `claude-haiku-4-5-bedrock` | Served via AWS Bedrock, global cross-region profile |
| `us.anthropic.claude-haiku-4-5-20251001-v1:0` | `claude-haiku-4-5-bedrock-us` | Served via AWS Bedrock, US geographic profile |
| `us.meta.llama4-maverick-17b-instruct-v1:0` | `llama-4-maverick-bedrock` | Served via AWS Bedrock |
| `us.meta.llama4-scout-17b-instruct-v1:0` | `llama-4-scout-bedrock` | Served via AWS Bedrock |
| `mistral.mistral-large-3-675b-instruct` | `mistral-large-bedrock` | Served via AWS Bedrock (on-demand id — no region prefix) |
| `us.deepseek.r1-v1:0` | `deepseek-reasoner-bedrock` | Served via AWS Bedrock |
| `deepseek.v3.2` | `deepseek-v3.2-bedrock` | Served via AWS Bedrock (in-region-only id — no region prefix) |
| `zai.glm-4.7` | `glm-4.7-bedrock` | Served via AWS Bedrock (in-region-only id — no region prefix) |

**AI Reserve catalog names also work** — the same IDs every other endpoint
takes (anything `GET /v1/models` returns), including non-Bedrock models like
`gpt-5.4-mini` or `gemini-2.5-flash`: the Converse surface is bridged
to every provider, not just Anthropic-on-Bedrock. AWS ids not in the table above
return `ResourceNotFoundException`.

## Supported operations

| Operation | Status | Use instead |
| - | - | - |
| `converse()` | Supported | — |
| Tool use (`toolConfig`, `toolUse`, `toolResult`) | Supported | — |
| Images in messages | Supported | — |
| Prompt caching (`cachePoint`) | Supported | — |
| `converse_stream()` | Supported | — |
| Tool-use streaming (`contentBlockStart` + `toolUse` input deltas) | Supported | — |
| `invoke_model()` / `…_with_response_stream()` | Not served (404) | `converse()`, or the audacity-sdk |
| Documents / video content blocks | Not yet — returns `ValidationException` | audacity-sdk (video), `/v1/chat/completions` |
| Guardrails (`guardrailConfig`) | Rejected honestly (400) | [Managed content moderation](/capabilities/content-moderation), available on request |
| Knowledge Bases, Agents | Out of scope | — |

Errors arrive in the AWS wire shape (`__type` +
`x-amzn-ErrorType`), so boto3 raises its normal typed exceptions:
bad key → `AccessDeniedException`, rate limit →
`ThrottlingException` (with `Retry-After`), spend cap →
`ServiceQuotaExceededException`, unknown model →
`ResourceNotFoundException`. For `converse_stream()`, errors
before the first event use the same HTTP shapes (raised from the
`converse_stream()` call itself); a failure *after* streaming has
started arrives as an in-stream `internalServerException` event frame,
which boto3 raises as an `EventStreamError` from the stream iterator —
the connection is never silently dropped mid-stream.

> [!NOTE]
>
> Running containers on **Amazon ECS**? The same two overrides repoint an unmodified ECS client at AI Reserve — see
> [Containers & orchestration](/containers/ecs).

## Which path should I use?

* **boto3 / AWS SDK against the gateway** — you have an existing Bedrock codebase (or a vendor tool that only speaks Bedrock) and want zero code changes beyond the client constructor — `converse()` and `converse_stream()` both supported.
* **audacity-sdk** — you want the same Converse surface *plus* streaming, retries tuned for the gateway, typed exceptions, file upload, and image generation. The recommended default for new integrations.
* **OpenAI-compatible API (`/v1/chat/completions`)** — your stack is already built on OpenAI SDKs, LangChain, or anything OpenAI-shaped. Full streaming, broadest ecosystem support.


# Claude Code
Source: https://docs.aireserve.com/connect/claude-code

Point Claude Code at the AI Reserve gateway with three environment variables — no code change, no plugin — including the full 1M-token context.

> **[One command →](/connect/cli)**
>
> `curl -fsSL https://get.aireserve.com/install.sh | sh` installs the `aireserve` CLI and configures Claude Code with
> the full gateway model catalog in its native `/model` picker — plus a session-cost status line and a one-command undo.

> **[Or connect in one click →](https://portal.aireserve.com/connect/claude-code)**
>
> The guided connect page creates a managed key for your account and writes the `env` block of `~/.claude/settings.json`
> for you — no terminal work.

Everything below is the manual equivalent.

Claude Code is configured entirely through environment variables — no code change, no
plugin. Set the base URL to the host root (no `/v1`), pass your AI Reserve key
as the auth token, and make sure `ANTHROPIC_API_KEY` is empty so the CLI
doesn't prefer it:

```bash theme={"dark"}
# Point Claude Code at the AI Reserve gateway
export ANTHROPIC_BASE_URL="https://api.aireserve.com"   # host root — NO /v1
export ANTHROPIC_AUTH_TOKEN="$AIRESERVE_API_KEY"                  # your aireserve_api_… key
export ANTHROPIC_API_KEY=""                                       # must be empty

# Recommended: pin the model in its [1m] form for the full 1M-token context
export ANTHROPIC_MODEL="claude-sonnet-4-6[1m]"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="claude-haiku-4-5-20251001"

# Recommended: the 1-hour prompt-cache TTL first-party sessions get.
# On API-key billing Claude Code defaults to a 5-minute TTL, so any pause
# longer than that forfeits the cache and the next turn re-writes the whole
# prompt. 1h cache writes bill 2x base input (vs 1.25x); reads stay 0.1x —
# one avoided cold rebuild pays for the premium.
export ENABLE_PROMPT_CACHING_1H=1

# Recommended: keep MCP tool search on. Claude Code disables it behind
# custom base URLs, which loads every MCP tool definition into the cached
# prompt prefix — any MCP server reconnect then invalidates the whole cache.
# The AI Reserve gateway forwards the tool-search protocol end to end.
export ENABLE_TOOL_SEARCH=true

claude   # every request is now metered and billed through your AI Reserve key
```

Add the exports to your shell profile (or the `env` block of
`~/.claude/settings.json`) to make the routing permanent. Requests hit
`/v1/messages` — including `count_tokens` — so the full agent
loop, tool use, and prompt caching work unchanged.

> [!NOTE]
>
> Neither the one-click flow nor `aireserve configure claude-code` touches `.mcp.json`, `~/.claude.json`, or the
> environment your MCP servers start with — your own MCP servers run exactly as they do first-party. See [MCP servers
> behind the gateway](#mcp-servers-behind-the-gateway) for the one kind that does not (claude.ai Connectors) and for
> the optional environment isolation.

> [!NOTE]
>
> **Short-lived tokens with the CLI.** `aireserve configure claude-code` no longer puts your key in `settings.json`. It
> sets Claude Code's `apiKeyHelper` to `aireserve token claude-code` and `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` to the
> five minutes. Every helper invocation validates or renews its cached token at the gateway, and every session
> authenticates with a token that expires within the hour — the long-lived key stays in `~/.config/aireserve/credentials.json`. The manual
> environment-variable flow above still authenticates with the key itself via `ANTHROPIC_AUTH_TOKEN`; both work, and
> pausing or revoking the key in the portal stops both on the next request. See the [CLI page](/connect/cli#credentials).

## Why the `[1m]` suffix?

When Claude Code talks to a gateway
it can't verify 1M support, so it budgets a 200K window by default — the context meter
fills five times faster than first-party even though the gateway serves the full
window. The `[1m]` id form tells Claude Code to budget the same 1M-token
context it has first-party. It works on every extended-context model
(`claude-sonnet-4-6`, `claude-sonnet-5`, `claude-opus-5`, `fable-5`, `opus-4-8`):

```bash theme={"dark"}
# The flagship at full context works the same way
export ANTHROPIC_MODEL="fable-5[1m]"
```

Claude Code strips the suffix before sending and adds the
`anthropic-beta: context-1m-2025-08-07` opt-in, which the gateway relays to
Anthropic — and the gateway also accepts the `[1m]` id form directly, so
either convention works. Selecting a 1M variant from the `/model` picker is
known not to stick behind a custom base URL; pin it through the environment variable
instead. Tokens are billed at the model's normal rates.

## Full model catalog in the `/model` picker

Claude Code (≥ 2.1.118) can populate its native `/model` picker straight from
the gateway:

```bash theme={"dark"}
export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
export ANTHROPIC_CUSTOM_HEADERS="X-Gateway-Client: claude-code"
```

At startup Claude Code fetches `/v1/models` and lists every model your key can
serve, with real display names. Models outside the Claude family appear under
self-naming ids like `claude-air-gpt-5.6-sol[1m]` (Claude Code only lists
`claude`/`anthropic`-prefixed ids) — the id always names the model that serves
the request, and the response's `x-aireserve-served-model` header records it.
Add `X-Gateway-Model-View: all` on a second line of `ANTHROPIC_CUSTOM_HEADERS`
to list the full catalog instead of the recommended compact set. The
[`aireserve` CLI](/connect/cli) sets all of this up (and undoes it) for you.

## MCP servers behind the gateway

> [!WARNING]
>
> **claude.ai Connectors stop working behind the gateway.** The moment `ANTHROPIC_AUTH_TOKEN` is set, Claude Code drops
> your claude.ai login for the session — and Connectors (Gmail, Google Drive, Google Calendar, Linear, …) ride on that
> login. This is a Claude Code limitation
> ([anthropics/claude-code#48011](https://github.com/anthropics/claude-code/issues/48011), closed "not planned"); no
> gateway can work around it.

| MCP source | Behind the gateway | What to do |
| - | - | - |
| **claude.ai Connectors** (added on claude.ai, pushed by your org) | ❌ Disabled | Replace with the vendor's native MCP server (below) |
| **Your own MCP servers** (`claude mcp add …`, `.mcp.json`) | ✅ Work unchanged | Nothing — they start with the same shell environment they have first-party |

Most Connectors have a native MCP server you can add directly — same tools,
one-time OAuth in your browser, and it keeps working whether the gateway is
configured or not:

```bash theme={"dark"}
claude mcp add --transport http linear https://mcp.linear.app/mcp
claude mcp add --transport http notion https://mcp.notion.com/mcp
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```

> [!NOTE]
>
> After switching between gateway and first-party auth, a native MCP server may ask you to re-authenticate once (`/mcp`
> → select → authenticate) — a known Claude Code token-refresh issue
> ([#59460](https://github.com/anthropics/claude-code/issues/59460),
> [#61214](https://github.com/anthropics/claude-code/issues/61214)), not data loss. Your server registrations are never
> removed.

### Optional: isolate MCP server environments

Claude Code can start stdio MCP servers with only a safe baseline environment plus each server's own `env` block,
instead of your full shell environment (`CLAUDE_CODE_MCP_ALLOWLIST_ENV=1` in Anthropic's [environment-variable
reference](https://code.claude.com/docs/en/env-vars)). AI Reserve does **not** turn this on for you: any server that
reads a token from your shell rather than its own `env` stops starting, which looks like "my MCP servers disappeared
behind the gateway". If you want the isolation anyway — for example so gateway credentials never reach a third-party
MCP process — declare each server's credentials in its own `env` first, then opt in:

```bash theme={"dark"}
# Manual flow: add alongside the other exports
export CLAUDE_CODE_MCP_ALLOWLIST_ENV=1

# CLI flow: remembered across refreshes; --no-isolate-mcp-env undoes it
aireserve configure claude-code --isolate-mcp-env
```

If MCP servers went missing after an earlier AI Reserve setup that enabled this by default, re-running
`aireserve configure claude-code` (or the next session-start refresh) releases it; on the manual or one-click flow,
remove the line or set it to `0`.

## Claude Agent SDK

The embeddable agent runtime takes the same three variables via
`options.env`:

```typescript theme={"dark"}
import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "hello",
  options: {
    model: "claude-haiku-4-5-20251001",
    env: {
      ...process.env, // options.env REPLACES the environment — keep PATH etc.
      ANTHROPIC_BASE_URL: "https://api.aireserve.com", // host root
      ANTHROPIC_AUTH_TOKEN: process.env.AIRESERVE_API_KEY!,
      ANTHROPIC_API_KEY: "",
    },
  },
})) {
  /* ... */
}
```


# aireserve CLI
Source: https://docs.aireserve.com/connect/cli

One command installs the AI Reserve CLI and connects Claude Code and Codex to the gateway — full model catalog in each agent's native picker, fully reversible.

The `aireserve` CLI is the fastest way to route your coding agents through
AI Reserve. One command installs it and configures every supported agent it
finds on your machine:

```bash theme={"dark"}
curl -fsSL https://get.aireserve.com/install.sh | sh
```

Your browser opens once to approve the connection — a managed API key is
minted for your account and handed to the CLI over a loopback callback. No
key to copy, nothing pasted into config files by hand.

Want just the binary, with no agent setup? Install with `--no-configure`:

```bash theme={"dark"}
curl -fsSL https://get.aireserve.com/install.sh | sh -s -- --no-configure
```

> [!NOTE]
>
> These top-level commands require a CLI release that includes the flat command
> layout; v0.2.0 and older do not support them. After that release is published,
> run `aireserve update`, then `aireserve refresh`. Before stable publication,
> test with an explicit `--version canary` install. The old `aireserve router
>     configure` spelling remains accepted for existing scripts and hooks.

## What you get

* **Native model pickers.** Every gateway model appears in Claude Code's
  `/model` picker and Codex's model picker with real display names, context
  windows, and reasoning-effort options you can toggle with the arrow keys.
  Models outside the Claude family appear in Claude Code under self-naming
  ids like `claude-air-gpt-5.6-sol[1m]` — the id always names the model that
  serves the request, and the gateway records both.
* **Session cost in your status line.** Claude Code's status line shows the
  session's actual server-computed spend and your remaining credits.
* **Freshness for free.** A session-start hook refreshes the model catalog at
  most every 12 hours, in the background, without delaying your session.
* **Your MCP servers keep working.** Existing `.mcp.json` and
  `~/.claude.json` files are left byte-for-byte unchanged, and stdio MCP
  servers keep inheriting your shell environment exactly as they do
  first-party. Prefer isolation? `aireserve configure claude-code --isolate-mcp-env`
  turns on Claude Code's `CLAUDE_CODE_MCP_ALLOWLIST_ENV=1` (servers then need
  their credentials declared in their own `env`); `--no-isolate-mcp-env` undoes it.
* **A real undo.** `aireserve unconfigure` restores your previous
  settings exactly — every value the CLI touched is recorded before it is
  changed, and anything you edited yourself afterwards is left alone.

## Commands

```bash theme={"dark"}
aireserve configure              # connect all installed agents (browser sign-in)
aireserve configure claude-code  # connect one agent
aireserve configure --api-key …  # non-interactive (CI, scripts)
aireserve unconfigure            # restore previous settings
aireserve refresh                # re-sync models/config now
aireserve subagents --haiku …    # point Claude Code sub-agent tiers at any model
aireserve baseline --set …       # pick this session's statusline cost-comparison model
aireserve copilot sync           # GitHub Copilot: VS Code Custom Endpoint file + Copilot CLI variables
aireserve update                 # self-update
```

Pass `AIRESERVE_API_KEY` in the environment instead of `--api-key` to keep
the key out of shell history. Non-production gateways: add
`--base-url https://<your-uat-gateway>` (keys are environment-specific).

## Credentials

The managed key the browser sign-in mints lives in
`~/.config/aireserve/credentials.json` (mode `0600`, your user only;
`AIRESERVE_CONFIG_DIR` or `XDG_CONFIG_HOME` relocate it). It is never written
into `~/.codex/config.toml` or `~/.claude/settings.json`. Instead each harness
is configured to call `aireserve token <harness>` — Codex through its
provider's `auth.command`, Claude Code through `apiKeyHelper` — and the CLI
exchanges the key for a gateway **session token** that expires within the
hour. Sessions authenticate with that short-lived token, so a harness debug
log, HTTP trace, or crash report that captures an `Authorization` header holds
a credential that is worthless minutes later rather than a durable key.
Pausing or revoking the key in the portal still takes effect on the very next
request: the gateway re-reads the parent key for every session token.

Credentials are isolated by harness and config directory. Separate
`CLAUDE_CONFIG_DIR` or `CODEX_HOME` profiles can use different organizations on
the same gateway. Helpers and cost hooks name that profile explicitly. An
explicit gateway or portal mismatch never falls back to another stored key.

The helper validates its cached token at the gateway every time it runs. A live
token is reused without another mint; a revoked or evicted token is replaced.
Changing the parent key selects a different cache. If validation is unavailable,
the helper fails rather than returning a potentially rejected credential.

`aireserve unconfigure` removes only the selected profiles' credentials and
caches and restores their recorded settings. It revokes the parent key's sessions
only when no other stored profile or legacy entry still uses that key.

## Escape hatches

The CLI never locks you in:

* `claude --setting-sources '' --settings ~/.claude/original.settings.json` runs one Claude Code
  session with your saved pre-gateway user settings, including your original
  credential helper if you had one. The empty source list prevents the gateway's
  global helper from being inherited, even when you launch from your home directory.
  This escape excludes current user, project, and local settings files; enforced
  managed policy still applies. Normal configured sessions are unaffected.
  Reconfigure or refresh updates this saved snapshot unless you have edited it.
* `codex --profile original` does the same for Codex.
* `aireserve unconfigure` removes everything permanently and restores
  the recorded values.

## Requirements

* macOS or Linux (x64/arm64). Windows: install via WSL for now.
* Claude Code ≥ 2.1.118 (covers gateway model names and the optional stdio
  MCP environment-isolation setting) and/or Codex CLI ≥ 0.147 (the version
  with catalog support).

Prefer a guided browser flow instead? Only the
[Claude Code](https://portal.aireserve.com/connect/claude-code) connect page
still offers a one-click browser wizard; the
[Codex](https://portal.aireserve.com/connect/codex) page is CLI-first, since a
browser-written static key can neither refresh Codex's model list nor issue
short-lived tokens. Each agent's docs page keeps the manual
environment-variable setup for machines without the CLI.


# Cline
Source: https://docs.aireserve.com/connect/cline

Connect Cline's VS Code agent to the AI Reserve gateway with one OpenAI Compatible provider entry.

> **[Connect Cline with a guided setup →](https://portal.aireserve.com/connect/cline)**
>
> The guided connect page mints your key, hands you every value to paste,
> lists the model IDs with their context-window and vision details, and
> confirms the moment your first task runs.

Everything below is the manual equivalent.

Cline configures its provider inside VS Code — there is no settings file to
edit, so this is a one-time paste stored in VS Code's secure storage
([Cline's OpenAI Compatible guide](https://docs.cline.bot/provider-config/openai-compatible)).
Open Cline, click the **settings gear** in its panel, and under
**API Configuration** set:

| Field | Value |
| - | - |
| API Provider | `OpenAI Compatible` |
| Base URL | `https://api.aireserve.com/v1` |
| API Key | your `aireserve_api_…` key (the value you would export as `AIRESERVE_API_KEY`) |
| Model ID | `claude-sonnet-4-6` (or any gateway model) |

Claude models work through the same OpenAI Compatible entry — the gateway
bridges them — so one provider entry serves the whole catalog. Cline keeps a
single active model; swap the **Model ID** whenever you like. Any id from
[Models](/models) works, for example:

| Model ID | Context window | Max output | Images |
| - | - | - | - |
| `claude-sonnet-4-6` | 1,000,000 | 128,000 | yes |
| `claude-fable-5` | 1,000,000 | 128,000 | yes |
| `gpt-5.4-mini` | 400,000 | 128,000 | yes |

> [!NOTE]
>
> **Keep the `/v1` suffix on the base URL.** Cline appends `/chat/completions`
> to it — without `/v1` every request 404s.

## Optional: model configuration

Cline's optional **model configuration** fields (context window, max output
tokens, supports images) default conservatively. Set them to the values in the
table above — the guided page shows them per model — if you want Cline's own
context-limit warnings to be accurate on long tasks.

## Verify

Start any task in Cline (for example, "explain this file") with the OpenAI
Compatible provider active and watch it stream. The request appears on your
[usage page](https://portal.aireserve.com/profile) seconds later — metered and
billed to your organization's wallet.

## Forks take the same values

Roo Code and other Cline forks expose the identical OpenAI Compatible provider
fields — reuse the base URL, key, and model IDs above there, or follow the
[Roo Code guide](/connect/roo-code).


# Terminal coding agents
Source: https://docs.aireserve.com/connect/code-cli

Run Claude Code or Codex in your terminal on your AI Reserve API key — one command installs the aireserve CLI and connects both to the gateway.

AI Reserve's terminal coding agents are **Claude Code** and **Codex**, running
on your `aireserve_api_…` key. The [`aireserve` CLI](/connect/cli) connects
them: one command installs it and configures every supported agent it finds
on your machine, so each agent's native model picker lists the full gateway
catalog and every request is metered and billed through your organization.

```bash theme={"dark"}
# Install the aireserve CLI and connect Claude Code / Codex
curl -fsSL https://get.aireserve.com/install.sh | sh

# Then start your agent as usual
claude
codex
```

Your browser opens once to approve the connection — a managed API key is
minted for your account and handed to the CLI over a loopback callback. The
key lives in `~/.config/aireserve/credentials.json` (mode `0600`), never in a
harness config file, and `aireserve unconfigure` restores your previous
settings exactly.

> [!NOTE]
>
> The earlier standalone `audacity` coding agent (`npm install -g audacity-cli`) is no longer supported. Remove it
> with `npm uninstall -g audacity-cli`; its `~/.audacity/config.json` is not read by the `aireserve` CLI.

## Where to go next

> **[aireserve CLI](/connect/cli)**
>
> Every command, how credentials are stored, and the escape hatches.

> **[Claude Code](/connect/claude-code)**
>
> The manual environment-variable setup, the full 1M-token context, and model naming.

> **[Codex](/connect/codex)**
>
> The manual `config.toml` setup for the Codex CLI, ChatGPT desktop app, and Codex SDK.

> **[More coding agents](/connect)**
>
> Cursor, GitHub Copilot, Zed, Cline, Aider, Continue, Goose, OpenCode, OpenHands, and Roo Code.

> [!NOTE]
>
> Coding agents resend the full conversation each turn, so long working sessions naturally benefit from provider-side
> [prompt caching](/capabilities/prompt-caching) — repeated context is billed at cached-input rates on supported
> models, and cached token counts are metered per request in your usage reporting.


# Codex
Source: https://docs.aireserve.com/connect/codex

Connect the Codex CLI, ChatGPT desktop app, or Codex SDK to the AI Reserve gateway over the OpenAI Responses format.

> **[One command →](/connect/cli)**
>
> `curl -fsSL https://get.aireserve.com/install.sh | sh` installs the
> `aireserve` CLI and connects Codex and the ChatGPT desktop app: your browser
> signs you in, and the CLI writes a **command-auth** provider into
> `~/.codex/config.toml` whose helper (`aireserve token codex`) exchanges the
> machine's key for a gateway session token that expires within the hour.
> The key never sits in the config file, and the full gateway model catalog
> appears in Codex's native model picker — reasoning-effort toggles included.

Codex only refreshes a provider's model list for command-auth providers, so
the CLI is the only setup that unlocks the native picker; it is also the only
one that gives sessions short-lived credentials. `codex --profile original`
runs one session on your pre-CLI setup and `aireserve unconfigure` restores
the selected profile without removing another profile's credentials. The
[connect page](https://portal.aireserve.com/connect/codex) walks through the
same command with the desktop-app steps.

Everything below is the manual equivalent — the escape hatch for a machine
where you cannot install the CLI.

## Codex CLI / ChatGPT desktop app

Define a custom provider in `~/.codex/config.toml` that reads your key from
the environment:

```toml theme={"dark"}
# Key from the environment (export AIRESERVE_API_KEY=... in your shell)
[model_providers.aireserve]
name = "AI Reserve"
base_url = "https://api.aireserve.com/v1"
env_key = "AIRESERVE_API_KEY"
wire_api = "responses"        # Codex dropped wire_api = "chat" in Feb 2026

model_provider = "aireserve"
model = "gpt-5.5"
```

`env_key` is the only auth to use here. Codex's `experimental_bearer_token`
(a literal key pasted into `config.toml`) is marked *discouraged* upstream in
favor of `env_key`, leaves a long-lived credential in a plain-text file, and
gets none of the picker or short-lived-token behavior above. `http_headers`
alone does not authenticate — Codex ignores it for the provider-has-auth check
and waits for an interactive login.

> [!NOTE]
>
> With `env_key` Codex never refreshes its model list from the provider, so
> its picker only shows the model you pinned. The `aireserve` CLI configures
> **command auth plus a served model catalog** instead — that is what unlocks
> the full native picker with per-model reasoning-effort options, and what
> keeps the key out of `config.toml`. If you want that experience, use the
> CLI; it is not practical to maintain by hand.

## Codex SDK

The Codex runtime speaks the OpenAI Responses format, served at
`/v1/responses`:

```typescript theme={"dark"}
import { Codex } from "@openai/codex-sdk";

const codex = new Codex({
  baseUrl: "https://api.aireserve.com/v1", // /v1 suffix
  apiKey: process.env.AIRESERVE_API_KEY,
});

const thread = codex.startThread({ model: "gpt-5.4-mini" });
const result = await thread.run("hello");
```

Legacy `audacity_api_…` keys and the `AUDACITY_API_KEY` name keep working
everywhere `aireserve_api_…` does.


# Continue
Source: https://docs.aireserve.com/connect/continue

Point Continue's IDE extensions and CLI at the AI Reserve gateway with one models block in config.yaml.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — Continue's chat, edit, and
> agent requests are then metered and billed through your organization.

Continue (VS Code, JetBrains, and the `cn` CLI) reads models from
`~/.continue/config.yaml`
([config reference](https://docs.continue.dev/reference)). Any
OpenAI-compatible gateway is `provider: openai` plus an `apiBase` — Claude
models included, since the gateway bridges them onto the same surface:

```yaml theme={"dark"}
name: AI Reserve
version: 0.0.1
schema: v1

models:
  - name: AI Reserve GPT-5.4 Mini
    provider: openai
    model: gpt-5.4-mini
    apiBase: https://api.aireserve.com/v1
    apiKey: aireserve_api_…   # your key — keep this file private
    roles:
      - chat
      - edit
      - apply
  - name: AI Reserve Claude Sonnet 4.6
    provider: openai
    model: claude-sonnet-4-6
    apiBase: https://api.aireserve.com/v1
    apiKey: aireserve_api_…
    roles:
      - chat
      - edit
      - apply
```

> [!NOTE]
>
> **Keep the `/v1` suffix on `apiBase`.** Continue appends
> `/chat/completions` to it — without `/v1` the request 404s, and Continue's
> own error message points here.

## Verify

The fastest end-to-end check is the CLI in headless mode:

```bash theme={"dark"}
npm install -g @continuedev/cli
cn --config ~/.continue/config.yaml -p "Reply with exactly: gateway-ok"
```

The reply streams back through the gateway, and the request appears on your
[Spend page](https://portal.aireserve.com/spend). The IDE extensions read
the same `config.yaml` — pick the AI Reserve model from Continue's model
dropdown and everything (chat, edit, apply) routes the same way.


# Cursor
Source: https://docs.aireserve.com/connect/cursor

Run the entire Cursor IDE — chat, agent mode, inline edits — through the AI Reserve gateway on your key.

Cursor's custom-model support lets the entire IDE — chat, agent mode, inline edits — run
through the AI Reserve gateway, so every request is metered and billed on your key. The
configuration lives in **Cursor Settings → Models → API Keys**:

1. **OpenAI API Key** — paste your AI Reserve key (`aireserve_api_…`) and switch the toggle **on**.
2. **Override OpenAI Base URL** — set to `https://api.aireserve.com/v1` (note the `/v1` suffix) and switch the toggle **on**.
3. Leave the **Anthropic key toggle off** — Cursor has no Anthropic base-URL override, so Anthropic-slot traffic cannot reach the gateway.
4. Under the model list, choose **Add Custom Model** and add the gateway model IDs you want, e.g. `fable-5-1`, `fable-5`, `opus-4-8`, `sonnet-4-6`, `gpt-5.4-mini`.
5. Pick your custom model in the chat model selector and send a message — the request appears in your AI Reserve usage dashboard within seconds.

> [!NOTE]
>
> **Use the prefix-free Claude aliases.** Cursor routes any model named
> `claude-*` to its built-in Anthropic provider slot on the client side — the
> request never reaches your base URL. The gateway therefore publishes alias IDs without the
> prefix: `fable-5-1`, `fable-5`, `opus-4-8`, `sonnet-4-6`. Same upstream
> models and pricing; only the name differs.

> [!NOTE]
>
> **Start a fresh chat per task.** Cursor does not trim conversation context for
> custom API models, so a long-running chat grows monotonically until it exceeds the model's
> context window. Oversized requests fail fast with `413` and a clear message
> rather than hanging. New task, new chat — you also get better answers that way.


# Devin Desktop
Source: https://docs.aireserve.com/connect/devin-desktop

Use AI Reserve inside Devin Desktop (formerly Windsurf) by running Codex CLI or Claude Code as ACP agents — Devin's own agents don't support custom endpoints or keys.

Devin Desktop (Cognition's June 2026 rebrand of the **Windsurf** editor) can
run AI Reserve models — through the third-party agents it hosts, not through
Devin itself. Its
[Agent Command Center](https://docs.devin.ai/desktop/acp) runs ACP agents such
as Codex CLI and Claude Code inside the editor. Each hosted agent reads its own
configuration, so once you've connected it to AI Reserve it routes through the
gateway exactly as it does standalone — every request metered and billed on
your key.

Devin's own agents (cloud Devin, Devin Local, the Devin CLI) are the
exception: they run exclusively on Cognition's managed models. Cognition's
[enterprise FAQ](https://docs.devin.ai/enterprise/deployment/overview) states
Devin "does not currently support third-party LLM API keys", and the app has
no base-URL or key field — there is nothing to configure on Devin itself. The
editor's
[HTTP proxy setting](https://docs.devin.ai/desktop/troubleshooting/windsurf-proxy-configuration)
doesn't change that: it is corporate-network plumbing, and model traffic
inside the tunnel still authenticates to Cognition — a gateway placed there
never sees a request it could serve.

Two steps:

1. **Connect the agent to AI Reserve** — follow the [Codex](/connect/codex) or
   [Claude Code](/connect/claude-code) guide. Nothing here is Devin-specific
   ([OpenCode](/connect/opencode) is hosted too and works the same way).
2. **Add the agent in Devin Desktop** — open the Agent Command Center and add
   Codex CLI or Claude Code, following
   [Cognition's ACP guide](https://docs.devin.ai/desktop/acp). ACP agents are
   available on Pro, Max, and Teams plans; Enterprise admins can ask their
   Cognition account team to enable them.

> [!NOTE]
>
> **Mind the environment.** Agents launched from Devin's GUI may not inherit
> your shell profile. If you set Codex up by hand, its `~/.codex/config.toml`
> persists but its `env_key` auth still reads `AIRESERVE_API_KEY` from the
> process environment — have Devin inject it per agent (the Agents tab, or
> `devin.acp.agentEnv.<agent>` in its settings), or GUI launches fail auth.
> The [`aireserve` CLI](/connect/cli) sidesteps this: its Codex provider
> authenticates with a helper command rather than an environment variable, so
> GUI launches work as-is. Claude Code needs no extra step either way: the
> `env` block of `~/.claude/settings.json` (the one-click connect page or the
> CLI writes it for you) persists everything the session needs.

Usage from these agents appears in your AI Reserve analytics as **Codex** or
**Claude Code** — the requests genuinely come from those harnesses, so
attribution is correct with no extra setup, unless the API key itself is
tagged to a specific tool (a key's category takes precedence over what the
traffic looks like).


# Factory Droid
Source: https://docs.aireserve.com/connect/droid

Run Factory's Droid CLI through the AI Reserve gateway with one customModels block — personal setup or org-wide enforcement.

> **[Connect Factory Droid in one click →](https://portal.aireserve.com/connect/droid)**
>
> The guided connect page mints your key and generates the `customModels`
> block for exactly the models you pick.

Everything below is the manual equivalent.

Droid reads custom models from `~/.factory/settings.json`
([Factory's BYOK reference](https://docs.factory.ai/cli/byok/overview)). Add the gateway
as `customModels` entries with `provider: "generic-chat-completion-api"` — the
gateway's OpenAI chat-completions surface serves every gateway model, streaming and
tool calls included:

```json theme={"dark"}
{
  "customModels": [
    {
      "model": "gpt-5.4-mini",
      "displayName": "AI Reserve GPT-5.4 Mini",
      "baseUrl": "https://api.aireserve.com/v1",
      "apiKey": "${AIRESERVE_API_KEY}",
      "provider": "generic-chat-completion-api"
    },
    {
      "model": "claude-sonnet-4-6",
      "displayName": "AI Reserve Claude Sonnet 4.6",
      "baseUrl": "https://api.aireserve.com/v1",
      "apiKey": "${AIRESERVE_API_KEY}",
      "provider": "generic-chat-completion-api"
    }
  ]
}
```

Export your key (Droid expands `${VAR}` references in `apiKey` at parse time, so
the settings file never holds the secret):

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # your key
droid   # run /model — AI Reserve models appear under "Custom models"
```

Headless runs work the same way — `droid exec -m "custom:gpt-5.4-mini" "..."`
routes through the gateway with no extra setup.

> [!NOTE]
>
> **Claude models can also use Droid's native Anthropic dialect.** Set
> `"provider": "anthropic"` with `"baseUrl": "https://api.aireserve.com"` (host
> root — no `/v1`); Droid then calls the gateway's `/v1/messages` surface, and
> prompt caching works as it does first-party. The
> `generic-chat-completion-api` entries above work for Claude models too, so
> this is optional.

## Enterprise rollout

Factory's enterprise plans distribute
[org-managed settings](https://docs.factory.ai/enterprise/hierarchical-settings-and-org-control)
to every Droid seat. Publish the AI Reserve models as org-defined `customModels` and pin
`modelPolicy` so members cannot add models that bypass the gateway:

```json theme={"dark"}
{
  "customModels": [
    {
      "model": "claude-sonnet-4-6",
      "displayName": "AI Reserve Claude Sonnet 4.6",
      "baseUrl": "https://api.aireserve.com/v1",
      "apiKey": "${AIRESERVE_API_KEY}",
      "provider": "generic-chat-completion-api"
    }
  ],
  "modelPolicy": {
    "allowCustomModels": false,
    "allowedBaseUrls": ["https://api.aireserve.com/v1"]
  }
}
```

`allowCustomModels: false` disables personal BYOK while org-defined entries keep
working (org-level keys are locked — projects and users can add to them but never
override them), and `allowedBaseUrls` limits custom-model traffic to the gateway.
Each member exports their own `AIRESERVE_API_KEY`, so usage is metered per person.


# GitHub Actions (CI)
Source: https://docs.aireserve.com/connect/github-actions

Run Claude Code or any SDK inside GitHub Actions through the AI Reserve gateway, with the spend reported separately as CI.

> **[Connect GitHub Actions with a guided setup →](https://portal.aireserve.com/connect/github-actions)**
>
> The guided connect page mints a CI-tagged key, hands you the secret command
> and workflow snippets, and confirms the moment your first pipeline request
> arrives.

Everything below is the manual equivalent.

## Why a CI key

Keys tagged as **CI keys** get their own treatment end to end:

* Every request a pipeline makes is stamped as CI spend — shown separately from
  interactive usage in the **Spend by Origin** card on the analytics dashboard,
  no matter which tool the pipeline runs (Claude Code, SDK scripts, eval jobs).
* The key is auto-classified as Engineering, so no one has to answer
  classification questions for workflow traffic.

Get one by checking **"This key will be used by CI"** when creating a key, or
by using the guided connect page above. An admin can also tag an *existing*
key as CI from its key details — past usage is retro-labeled, so there's no
need to rotate a secret that's already deployed.

## 1. Store the key as an Actions secret

The key value lives only in your repository's (or organization's) Actions
secrets:

```bash theme={"dark"}
gh secret set AIRESERVE_API_KEY
# org-wide instead: gh secret set AIRESERVE_API_KEY --org <org> --visibility all
```

Or in the GitHub UI: **Settings → Secrets and variables → Actions → New
repository secret**, named `AIRESERVE_API_KEY`.

## 2. Wire it into the workflow

### Claude Code / claude-code-action

Claude Code reads the gateway from two env vars — the base URL is the host
root, **no `/v1`**:

```yaml theme={"dark"}
jobs:
  claude:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: "Review this pull request"
        env:
          ANTHROPIC_BASE_URL: https://api.aireserve.com   # host root — NO /v1
          ANTHROPIC_AUTH_TOKEN: ${{ secrets.AIRESERVE_API_KEY }}
```

### SDKs and scripts

Point any OpenAI-compatible SDK at the gateway's `/v1` surface:

```yaml theme={"dark"}
env:
  OPENAI_BASE_URL: https://api.aireserve.com/v1
  OPENAI_API_KEY: ${{ secrets.AIRESERVE_API_KEY }}
```

Anthropic SDK equivalent:

```yaml theme={"dark"}
env:
  ANTHROPIC_BASE_URL: https://api.aireserve.com   # host root — NO /v1
  ANTHROPIC_AUTH_TOKEN: ${{ secrets.AIRESERVE_API_KEY }}
```

## 3. Verify

Trigger the workflow. The first metered request flips the key's *last used*
timestamp (visible on the connect page and in your profile's API keys), and
the run's spend appears in the **Spend by Origin** card on the analytics
dashboard as CI.


# GitHub Copilot
Source: https://docs.aireserve.com/connect/github-copilot

Run GitHub Copilot on AI Reserve models (our models in Copilot's model picker), or add the AI Reserve assistant to Copilot Chat. Your AI Reserve key is what gets debited.

Start with **1**: run Copilot on AI Reserve models, so every Copilot chat is metered on your AI Reserve key.
**2** is optional on top: the AI Reserve assistant for account questions inside Copilot Chat.

| | What developers see | How it is paid for |
| - | - | - |
| **1. Run Copilot on AI Reserve models** (start here) | our models in Copilot's own model picker, for Chat, agent mode and edits, made the default | an AI Reserve key, billed like any API call; no Copilot premium requests |
| **2. The AI Reserve assistant** (optional) | account tools inside the Copilot they already use: budget, usage, prices, API keys, or a second opinion from a named model | sign in with the portal account; only the questions handed to our models are billed |

> [!NOTE]
>
> **Any AI Reserve key works, and it is what pays.** Paste a key you already have from the portal's
> [API Keys](https://portal.aireserve.com/keys) page or create one there. Whatever that key belongs to, you, your team
> or your organization, is what gets debited, with its spend caps and model rules applied. GitHub bills nothing extra,
> and GitHub states that requests to a provider you bring do not count against Copilot premium-request allowances.
> Inline ghost-text completions are the one thing that stays on GitHub's own models.

## 1. Run Copilot on AI Reserve models

Three ways to get our models into the picker. They differ only in who sets them up.

| Way | Who | Where it shows up | Needs |
| - | - | - | - |
| [AI Reserve extension](#for-yourself-the-ai-reserve-extension) | each developer, one minute | VS Code | a key |
| [Organization-wide custom models](#for-your-whole-organization-custom-models) | the GitHub admin, once | every client, including Copilot Chat on github.com | GitHub Enterprise with Copilot Business or Enterprise seats |
| [Custom Endpoint or Copilot CLI](#without-the-extension-custom-endpoint-and-copilot-cli) | each developer | VS Code, Copilot CLI | a key; the manual version of the extension |

### For yourself: the AI Reserve extension

The extension registers AI Reserve as a model provider in VS Code. Install it, open Copilot's model picker →
**Manage Models** → **AI Reserve**, paste your key once (it is kept in VS Code's secret storage), and every model your
key can use appears in the picker with its price and context window. Blocked models never show; budget refusals come
back as one plain sentence.

**1. Install**

Until the Marketplace listing is live, download the
[`.vsix` (0.1.2)](https://portal.aireserve.com/connect/aireserve-vscode-0.1.2.vsix) and in VS Code open the
Extensions view → the **···** menu at its top right → **Install from VSIX…**. The
[portal page](https://portal.aireserve.com/connect/copilot) switches to a one-click install the day the listing
is live.

**2. Paste your key**

Copilot model picker → **Manage Models** → **AI Reserve**, or run **AI Reserve: Sign in with an API key** from
the Command Palette.

**3. Pick a model**

**Auto** lets AI Reserve route each request; or pick any model by name. New catalog models appear on their own
with their real name, price and context window (the list refreshes when the picker opens, in the background
every 30 minutes, or right away with **AI Reserve: Refresh the model list**). Settings: `aireserve.models` shows
only the ids you list, `aireserve.includeConsentGatedModels` also lists providers that need a one-time consent
in the portal, `aireserve.refreshIntervalMinutes` changes the background cadence (0 turns it off).

**4. Make it the default (optional)**

Say yes when the extension offers it after sign-in, or run **AI Reserve: Make AI Reserve the default for new
chats**. It sets VS Code's own `"chat.defaultModel": "aireserve"`, so every new Copilot chat starts on **AI Reserve
Auto** instead of GitHub's model; you can still switch within a conversation. Our entries are easy to spot in the
picker: they sit under the **AI Reserve** heading and every detail line starts with "AI Reserve".

> [!NOTE]
>
> **Making AI Reserve the default for everyone (recommended).** Two levers, both your GitHub or IT admin's: (1) VS
> Code's `ChatDefaultModel` enterprise policy (VS Code 1.127+, pushed by MDM or group policy like any VS Code policy)
> forces `chat.defaultModel` to `aireserve` on every managed machine, and users cannot override it; (2) on GitHub
> Enterprise, **AI controls → Copilot → Configure models** lets you disable GitHub's hosted chat models and turn off
> the *default availability* policy so new GitHub models do not reappear, leaving only the AI Reserve custom models in
> the picker. Together they guarantee every chat, agent and edit request is metered on your AI Reserve key, while
> inline ghost-text completions keep working as before: they stay on GitHub's models either way. No admin yet? Each
> developer can pin AI Reserve models to the top of the picker (hover a model → pin) and hide GitHub's under **Manage
> Models** (hover → eye icon).

### For your whole organization: custom models

On GitHub Enterprise with Copilot Business or Enterprise seats, a GitHub admin adds AI Reserve once as an
**OpenAI-compatible** custom model provider (a GitHub public preview). Our models then appear at the bottom of every
developer's picker, under the enterprise name, in VS Code, JetBrains, the Copilot CLI and Copilot Chat on github.com,
with nothing to install per developer and one organization key paying for everything.

**1. Get the organization key**

An AI Reserve administrator mints it on the [Connect GitHub Copilot](https://portal.aireserve.com/connect/copilot)
page (it appears on the organization's API Keys page and can be revoked there at any time).

**2. Turn on the policy**

Enterprise owner: **AI controls → Copilot → Policies → Enable custom models**. Without it, organization admins do
not see the Custom models tab.

**3. Add the key**

Enterprise: **AI controls → Copilot → Configure custom models → Add API key**. Organization: **Settings → Code,
planning, and automation → Copilot → Models → Custom models → Add API key**. Provider **OpenAI-compatible**, name
**AI Reserve**, base URL `https://api.aireserve.com/v1`, the organization key, and the model ids to expose
(case-sensitive): `claude-sonnet-4-6`, `claude-opus-4-8`, `gpt-5.5`, `gpt-5.4-mini`, `gemini-2.5-pro`, plus `auto`
to let AI Reserve pick per request. Any chat model id from the [catalog](/models) works.

**4. Enable and verify**

Enable the models for your organizations and save. Within a few minutes a developer sees them in the picker; the
first request appears on the organization's [Analytics page](https://portal.aireserve.com/analytics). When AI
Reserve adds a model, we email the GitHub admins set up in the portal the new ids to add to this list (one line,
same screen); `auto` and the extension pick new models up on their own.

### Without the extension: Custom Endpoint and Copilot CLI

Have the [aireserve CLI](/connect/cli)? One command writes both lists below from the live catalog and keeps them
current: every tool-calling chat model, **AI Reserve · Auto** first, each with its own context window, merged into
VS Code's Custom Endpoint file for every VS Code channel installed on the machine (other providers in that file are
left alone), plus the Copilot CLI variables as a managed block in your shell profile. It reuses the key
`aireserve configure` stored, so nothing is pasted: the VS Code file keeps the `${input:aireserveApiKey}` prompt,
and the shell block reads the key out of the CLI's credential store when a shell starts, never into the file.

```bash theme={"dark"}
aireserve copilot sync            # VS Code Custom Endpoint file + Copilot CLI variables
aireserve copilot sync --dry-run  # preview every change as a diff, write nothing
aireserve copilot status          # what is managed, how many models, last sync
```

The session-start sync the CLI installs for Claude Code and Codex refreshes both on its 12-hour cadence, so new
models appear without another command. No CLI on this machine, or prefer to do it by hand? The manual steps:

> **VS Code Custom Endpoint, by hand**
>
> VS Code's built-in **Custom Endpoint** provider does what the extension does, by hand
> ([Microsoft's guide](https://code.visualstudio.com/docs/agent-customization/language-models)):
>
> 1. Open the Command Palette and run **Chat: Manage Language Models** (the gear icon in the chat model picker opens
>    the same editor).
> 2. Select **Add Models → Custom Endpoint**. Name the group **AI Reserve**, enter a display name and your
>    `aireserve_api_…` key when asked, and pick **Chat Completions** as the API type.
> 3. VS Code opens `chatLanguageModels.json`. Replace the generated entry with:
>
> ```json chatLanguageModels.json theme={"dark"}
> [
>   {
>     "name": "AI Reserve",
>     "vendor": "customendpoint",
>     "apiKey": "${input:aireserveApiKey}",
>     "apiType": "chat-completions",
>     "models": [
>       {
>         "id": "auto",
>         "name": "AI Reserve · Auto",
>         "url": "https://api.aireserve.com/v1/chat/completions",
>         "toolCalling": true,
>         "vision": true,
>         "maxInputTokens": 128000,
>         "maxOutputTokens": 16000
>       }
>     ]
>   }
> ]
> ```
>
> 4. Save, then choose **AI Reserve · Auto** from the model picker. To pin a model instead, add an entry to `models`
>    with any id from the [catalog](/models), same `url`, one object per model, and set `maxInputTokens` /
>    `maxOutputTokens` to that model's published window (for example `claude-sonnet-4-6` is 1,000,000 / 128,000;
>    the figures are on each model's catalog page, and the [portal page](https://portal.aireserve.com/connect/copilot)
>    prints a ready-made snippet with them filled in). Keep `toolCalling: true` (agent mode needs it); set `vision`
>    only on models that accept images ([per-model table](/capabilities/vision)).
>
> > [!NOTE]
> >
> > **The key never lands in the file.** `${input:aireserveApiKey}` is an input variable: VS Code prompts for the
> > value once and keeps it in secret storage, so `chatLanguageModels.json` is safe to sync or commit. On Copilot
> > Business or Enterprise this is governed by the **Bring Your Own Language Model Key in VS Code** policy, on by
> > default; if **Add Models** is missing, an administrator has turned it off.

> **Copilot CLI variables, by hand**
>
> The Copilot CLI takes the same key through its bring-your-own-provider variables
> ([GitHub's guide](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models)):
>
> ```shell theme={"dark"}
> export COPILOT_PROVIDER_BASE_URL="https://api.aireserve.com/v1"
> export COPILOT_PROVIDER_TYPE="openai"
> export COPILOT_PROVIDER_API_KEY="<your aireserve_api_… key>"
> export COPILOT_MODEL="auto"
> ```

## 2. Add the AI Reserve assistant to Copilot Chat

Optional, on top of section 1. To chat with our models, pick them in the model picker (section 1); the assistant
is for your account: budget, usage, prices and keys, plus a second opinion from a named model. With an AI Reserve
model selected in the picker, the assistant runs entirely on AI Reserve as well; with a GitHub model selected,
GitHub's model orchestrates the call and a Copilot premium request is spent alongside ours.

GitHub retired App-based Copilot Extensions on 10 November 2025; the [AI Reserve MCP server](/connect/mcp) is how
tools and an assistant reach Copilot Chat today. The server publishes OAuth discovery with dynamic client
registration, so every IDE signs you in from a browser tab with your portal account, and each person sees only what
they can already see in the portal. It works alongside whichever model Copilot is running on, ours or GitHub's.

> [!NOTE]
>
> **Copilot Business or Enterprise:** a GitHub admin must turn on the **MCP servers in Copilot** policy once (it is
> off by default) under the organization's or enterprise's Copilot policies. If your company restricts MCP to an
> approved registry, add AI Reserve's [registry entry](/files/github-copilot/server.json). Copilot Pro and Free need
> nothing.

**VS Code**

> **[Add to VS Code](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522aireserve%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fapi.aireserve.com%252Fmcp%2522%257D)**
>
> Opens VS Code and asks to install `aireserve`.

> **[Add to VS Code Insiders](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522aireserve%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fapi.aireserve.com%252Fmcp%2522%257D)**
>
> Same, for the Insiders build.

Click **Install**, then **Allow** when VS Code asks to sign in to AI Reserve. A browser tab signs you in
with your portal account and the tools appear in agent mode. Nothing happened? Paste this into
`.vscode/mcp.json` in your workspace (or your user profile's `mcp.json`):

```json .vscode/mcp.json theme={"dark"}
{
  "servers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp"
    }
  }
}
```

VS Code 1.99 or newer. Verify with **MCP: List Servers** in the Command Palette.

**JetBrains, Visual Studio, Eclipse, Xcode**

Open Copilot Chat in **Agent** mode, click the tools icon (*Configure your MCP server*) →
**Add MCP Tools**, paste the same `servers` JSON, and click **Allow** on the sign-in prompt:

```json mcp.json theme={"dark"}
{
  "servers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp"
    }
  }
}
```

**Copilot CLI and the Copilot app**

One command; the first use opens the AI Reserve sign-in in your browser (Copilot CLI 1.0.11 or newer).
The GitHub Copilot desktop app picks up the CLI's servers automatically, or add it in the app under
**Customize → MCP → Add custom server** (type HTTP, URL `https://api.aireserve.com/mcp`, no headers):

```shell theme={"dark"}
    copilot mcp add --transport http aireserve https://api.aireserve.com/mcp
```

Or declare it in `~/.copilot/mcp-config.json` (the same `mcpServers` shape works in a repository-root
`.mcp.json`, shared with everyone who clones the repo):

```json ~/.copilot/mcp-config.json theme={"dark"}
{
  "mcpServers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp",
      "tools": [
        "*"
      ]
    }
  }
}
```

**github.com: cloud agent and code review**

The agent that works on issues and pull requests (and Copilot code review) runs without a browser, so it
uses an MCP access token instead of signing in:

1. Mint a token with the **Messages** scope on
   [API Keys → Management Keys](https://portal.aireserve.com/keys?type=mcp#api-keys) in the portal.
2. In the repository, add it as an Agents secret named `COPILOT_MCP_AIRESERVE_TOKEN`
   (Settings → Environments → `copilot`). GitHub only exposes `COPILOT_MCP_*` names to MCP servers.
3. Paste this under Settings → Copilot → MCP servers and save:

```json MCP configuration theme={"dark"}
{
  "mcpServers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp",
      "headers": {
        "Authorization": "Bearer $COPILOT_MCP_AIRESERVE_TOKEN"
      },
      "tools": [
        "whoami",
        "list-models",
        "get-model",
        "get-connection-guide",
        "send-message"
      ]
    }
  }
}
```

Tools are listed explicitly because the cloud agent calls them without asking first; `send-message`
spends from the token owner's budget. Copilot Chat on github.com itself only talks to GitHub's own MCP
server (a GitHub limit, the same for every vendor): to use AI Reserve models in that chat, put them in the
[model picker](#1-run-copilot-on-ai-reserve-models).

### Try it

In Copilot Chat, switch to **Agent** mode and type:

```text theme={"dark"}
using fable 5.1 ping me
```

Copilot looks the model up with `list-models`, sends your message with `send-message`, and replies
with the answer and the exact model that produced it (`Model: claude-fable-5-1`). The same loop is one
command, `/mcp.aireserve.ask-model`, and `#send-message` pins the tool when you want to be explicit.
Other things to ask once connected: "which models can I use and what do they cost", "what did my team
spend this week", "how much budget do I have left", "list my API keys". Every answer is scoped to what
your portal role can already see; anything that spends money or changes your account asks for
confirmation first. The full surface is in the [MCP tool reference](/connect/mcp-tools).

### For GitHub admins: assistant rollout checklist

1. **MCP servers in Copilot → Enabled.** Organization: Settings → Copilot → Policies. Enterprise: AI controls →
   Copilot → Policies (or "No policy" to let each organization decide).
2. **Restricting MCP to a registry?** Add the [AI Reserve entry](/files/github-copilot/server.json) to it: the server
   is `https://api.aireserve.com/mcp`, streamable HTTP, OAuth sign-in, nothing to run on developer machines.
3. **Share the install.** Send developers this page, or commit the ready-made
   [`.vscode/mcp.json`](/files/github-copilot/mcp.json) and repository-root
   [`.mcp.json`](/files/github-copilot/mcp-config.json) to shared repositories so every clone has the assistant.
   Repository admins who want the cloud agent on it paste [this configuration](/files/github-copilot/cloud-agent-mcp.json).
4. **Verify** with a pilot group: `using fable 5.1 ping me` answers with a `Model:` line, and the request appears on
   the developer's [Analytics page](https://portal.aireserve.com/analytics).
5. **Set spend caps** on the AI Reserve side (organization budget, per-team and per-member monthly caps) in the
   portal's Admin area.

## What about Copilot on github.com?

* **Copilot Chat on github.com** gets our models through the [organization-wide custom models](#for-your-whole-organization-custom-models)
  setup; that is the only way any vendor reaches its picker. The assistant cannot be added there: GitHub wires only its
  own MCP server into that chat.
* **The Copilot cloud agent and Copilot code review** also run on github.com and take the assistant through the
  repository configuration in the *github.com* tab above.

## Verify

Pick an AI Reserve model in Copilot Chat and send any message; it streams and the request appears on your
[Analytics page](https://portal.aireserve.com/analytics) seconds later, metered against the key it came in on.
Administrators also see each request as a row in the portal's **Event Log** (Observe → Event Log): the model, the
key it came in on, who made it, cost and latency, with requests from the extension labelled *GitHub Copilot* under
*Spend by tool*. For the assistant, `using fable 5.1 ping me` in agent mode answers with a `Model:` line.


# Goose
Source: https://docs.aireserve.com/connect/goose

Point Block's Goose agent at the AI Reserve gateway — Anthropic dialect at the host root, OpenAI dialect with goose's own base path.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — every Goose session is then
> metered and billed through your organization.

Goose configures providers in `~/.config/goose/config.yaml`
([provider reference](https://block.github.io/goose/docs/getting-started/providers)).
For Claude models, use the `anthropic` provider pointed at the gateway's host
root:

```yaml theme={"dark"}
GOOSE_PROVIDER: anthropic
GOOSE_MODEL: claude-sonnet-4-6
ANTHROPIC_HOST: https://api.aireserve.com   # host root — goose appends /v1/messages
keyring: false
```

```bash theme={"dark"}
export ANTHROPIC_API_KEY="$AIRESERVE_API_KEY"   # your aireserve_api_… key
goose run -t "your prompt"                      # or `goose` for the interactive session
```

For GPT models (or any gateway model over the OpenAI dialect), swap the
provider block:

```yaml theme={"dark"}
GOOSE_PROVIDER: openai
GOOSE_MODEL: gpt-5.4-mini
OPENAI_HOST: https://api.aireserve.com   # host root — NO /v1
keyring: false
```

```bash theme={"dark"}
export OPENAI_API_KEY="$AIRESERVE_API_KEY"
goose run -t "your prompt"
```

> [!NOTE]
>
> **Goose hosts are roots, not `/v1` URLs.** Unlike most OpenAI-flavored
> tools, goose builds the path itself: `OPENAI_HOST` gets
> `v1/chat/completions` appended (via its `OPENAI_BASE_PATH` default) and
> `ANTHROPIC_HOST` gets `/v1/messages`. If you see a 404, the usual cause is
> a `/v1` already on the host doubling the path. Keys never go in
> `config.yaml` — goose ignores them there; use the environment variable (or
> goose's keyring/`secrets.yaml`).

## Verify

Run the one-shot command above. Goose answers in the terminal, and the
request appears on your
[Spend page](https://portal.aireserve.com/spend) — metered against your
key, tool calls included.


# Connect your tool
Source: https://docs.aireserve.com/connect/index

Point the tool you already use — Claude Code, Codex, Cursor, GitHub Copilot, Zed, or any OpenAI/Anthropic SDK — at the AI Reserve gateway.

The fastest way to see the gateway work: point the agent harness you already run at
AI Reserve. Both take your `aireserve_api_…` key with no code changes —
every request they make is metered and billed through your organization's wallet.

Keep your existing code. The gateway speaks the provider-native wire formats directly, so
**stock OpenAI and Anthropic SDKs and framework providers work unmodified**
(and so do the Claude Code and Codex harnesses above) — change the
base URL, use your AI Reserve API key, keep everything else. Cross-provider calls are
bridged for you:
Claude models answer OpenAI-SDK calls and GPT models answer Anthropic-SDK calls, all
metered against the same key. (Teams on AWS Bedrock have an equally seamless path — see
[Migrating from Bedrock](/migrate/from-bedrock) and the
[official AI Reserve SDKs](/getting-started/quickstart).) Runnable versions of every snippet
in these guides live in `examples/gateway/` in the repository.

> [!NOTE]
>
> **The one gotcha — base URL suffix.** OpenAI-flavored clients expect the `/v1` suffix on the base URL (they append
> `/chat/completions`). Anthropic-flavored clients expect the **host root without `/v1`** (they append `/v1/messages`
> themselves). Each snippet shows the right form.

> **[Slack](/connect/slack)**
>
> Mention `@aireserve` in any channel — every model; on us in your shared channel with AI Reserve, metered to your wallet in your own workspace.

> **[Claude Code](/connect/claude-code)**
>
> Terminal harness on your key — environment variables only, plus the full 1M-token context.

> **[Codex](/connect/codex)**
>
> Codex SDK and CLI over the OpenAI Responses format.

> **[Cursor](/connect/cursor)**
>
> Run the entire IDE — chat, agent mode, inline edits — through the gateway.

> **[GitHub Copilot](/connect/github-copilot)**
>
> Copilot Chat, agent mode, and the Copilot CLI on your key — one Custom Endpoint block, or org-wide via GitHub Enterprise.

> **[Zed](/connect/zed)**
>
> Agent panel and inline assistant on your key — one `language_models` block, generated for the models you pick.

> **[Cline](/connect/cline)**
>
> The VS Code agent through one OpenAI Compatible provider entry.

> **[Devin Desktop](/connect/devin-desktop)**
>
> Formerly Windsurf. Codex CLI and Claude Code run inside Devin as ACP agents — on your key.

> **[Factory Droid](/connect/droid)**
>
> Droid CLI sessions on your key — one `customModels` block, org-enforceable.

> **[Microsoft Office](/connect/microsoft-office)**
>
> Deploy Claude in Excel, PowerPoint, and Word, or connect through GPT for Work and automation.

> **[Aider](/connect/aider)**
>
> The terminal pair programmer on your key — two environment variables.

> **[Continue](/connect/continue)**
>
> IDE extensions and CLI on one `config.yaml` models block.

> **[Goose](/connect/goose)**
>
> Block's agent over either gateway dialect — one config.yaml block.

> **[OpenCode](/connect/opencode)**
>
> A custom-provider JSON block serves every gateway model.

> **[OpenHands](/connect/openhands)**
>
> CLI and agent server on three `LLM_*` environment variables.

> **[Roo Code](/connect/roo-code)**
>
> The VS Code agent through the OpenAI Compatible provider.

> **[OpenAI SDK](/connect/openai-sdk)**
>
> The official `openai` package, Vercel AI SDK, and any OpenAI-compatible framework.

> **[Anthropic SDK](/connect/anthropic-sdk)**
>
> The official `anthropic` package with a base-URL swap.

> **[Terminal coding agents](/connect/code-cli)**
>
> Claude Code and Codex on your key — one command installs the `aireserve` CLI and connects both.

> **[AWS SDK (boto3)](/connect/aws-sdk)**
>
> Unmodified `bedrock-runtime` clients — override the endpoint and keep your code.

> **[AI Reserve SDKs](/getting-started/quickstart)**
>
> Five official SDKs — Python, TypeScript, Go, Java, Rust — with the exact Converse surface.

> **[MCP server](/connect/mcp)**
>
> Give your agents account operations — catalog, analytics, key and team management — over one hosted MCP endpoint.

Prefer to stay on one dependency? The [official AI Reserve SDKs
(Python & TypeScript) expose these same two wire formats natively](/api-reference/sdk-wire-formats) —
`client.chat.completions.create(...)` and
`client.messages.create(...)` on the AI Reserve client.

## Model discovery

`GET /v1/models` returns the OpenAI-shaped model list, so SDK and framework
discovery calls (`client.models.list()`, LangChain provider probes) work out of
the box. Anthropic-native clients can also call
`POST /v1/messages/count_tokens` for free token counting.

## Guides for end users

Not writing code? These walkthroughs set up desktop apps on your organization's key.

> **[Getting Started with Claude Desktop](https://aireserve.com/developers/claude-desktop)**
>
> Install and sign in to Claude Desktop through AI Reserve.

> **[Getting Started with ChatGPT Work](https://aireserve.com/developers/chatgpt-work)**
>
> Set up ChatGPT with your organization's workspace.


# MCP server
Source: https://docs.aireserve.com/connect/mcp

Give your agents account operations — live catalog, analytics, key and team management, one-shot inference — over one hosted MCP endpoint.

> **[Connect the MCP server in the portal →](https://portal.aireserve.com/connect/mcp)**
>
> The guided connect page mints a scoped MCP access token and walks you through your client's config.

AI Reserve also ships a hosted, remote **MCP server**, so the agents you just connected can
operate your *account* — not just spend your tokens. Over one streamable-HTTP endpoint your
agent gets the live model catalog with pricing, usage analytics, team and API-key management,
and one-shot inference — all as the connected user, bounded by what that user's role already
allows. Any MCP client that speaks streamable HTTP with a bearer header works; Claude Code,
Codex, and Cursor are spelled out below, and the raw HTTP calls are documented for everything
else.

```shell theme={"dark"}
POST https://api.aireserve.com/mcp
Authorization: Bearer aireserve_mcp_…   # an MCP access token — NOT an inference key
```

Every capability is listed in the **[MCP tool reference](/connect/mcp-tools)** — all 26 tools
and 120+ operations an enterprise admin can call, each with a copy-paste request and the
plain-English ask that makes an agent do it for you.

The same connection is the **infrastructure control plane**: an enterprise admin's agent
can quote and launch GPU machines with persistent storage, enable the organization's AWS
container account, mint ECS credentials, write the AWS CLI profile that repoints ECS at the
gateway, deploy an image to an HTTPS URL and read its logs — see
[GPU compute](/connect/mcp-tools#gpu-compute-compute-query-compute-action) and
[Containers](/connect/mcp-tools#containers-containers-query-containers-action). The GPU
and Elastic Container Service pages in the portal carry the one-command connect block for
exactly this.

## Credentials

**MCP access tokens** are minted on the portal
[Keys page](https://portal.aireserve.com/keys?type=mcp), under **Management keys**: explicitly
scoped, expiring (7, 30, 90, or 365 days), revocable, and shown once. Revocation applies on
the token's next request. Inference keys (`aireserve_api_…`) are deliberately refused at this
endpoint — a leaked inference credential must never gain management powers.

Scopes only ever narrow. A token can never grant its owner anything their account role does
not already have:

| Scope | Grants |
| - | - |
| `mcp:read` | Read-only tools: `whoami`, the model catalog, the connection guide, and every `*-query` tool your role can see |
| `mcp:write` | The `*-action` tools — account and team management you are already authorized for |
| `mcp:messages` | `send-message` — one-shot inference through the gateway, billed to your account |

Export the token once and let every config below read it from the environment, so no secret
lands in a file that might get committed:

```shell theme={"dark"}
export AIRESERVE_MCP_TOKEN="aireserve_mcp_…"   # ~/.zshrc or a secrets manager
```

### Or sign in with OAuth

Clients that speak MCP OAuth don't need a pre-minted token. The server implements the
standard discovery chain — a `401` carries a `WWW-Authenticate` header pointing at
`/.well-known/oauth-protected-resource/mcp`, and from there your client finds:

| Endpoint | URL |
| - | - |
| Authorization | `https://api.aireserve.com/mcp-authorize` |
| Token | `https://api.aireserve.com/mcp/oauth/token` |
| Dynamic client registration | `https://api.aireserve.com/mcp/oauth/register` |

PKCE (S256) is required and clients are public (`token_endpoint_auth_methods_supported: ["none"]`). Approving the consent page mints the same kind of scoped, expiring token — it
just never passes through your hands. In Claude Code, `/mcp` → **Authenticate** runs this
flow; claude.ai and Claude Desktop custom connectors work the same way.

With OAuth the whole setup is one command and no token to mint:

```shell theme={"dark"}
claude mcp add --transport http aireserve https://api.aireserve.com/mcp
```

Then `/mcp` → `aireserve` → **Authenticate** opens the AI Reserve sign-in; approve the
scopes and the agent is connected for 30 days.

## Claude Code

```shell theme={"dark"}
claude mcp add --transport http aireserve https://api.aireserve.com/mcp \
  --header "Authorization: Bearer $AIRESERVE_MCP_TOKEN"
```

Default scope is the current project; add `-s user` for all your projects. For a committable
project config use `.mcp.json` — `${AIRESERVE_MCP_TOKEN}` expands from the environment:

```json theme={"dark"}
{
  "mcpServers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp",
      "headers": { "Authorization": "Bearer ${AIRESERVE_MCP_TOKEN}" }
    }
  }
}
```

Verify with `claude mcp list` (or `/mcp` in a session). Tools surface as
`mcp__aireserve__…` — try `mcp__aireserve__whoami`.

## Codex

One command with OAuth, no token to mint — `codex mcp login` opens the AI Reserve sign-in:

```shell theme={"dark"}
codex mcp add aireserve --url https://api.aireserve.com/mcp && codex mcp login aireserve
```

To use a minted token instead, declare the server in `~/.codex/config.toml` with the token
referenced by environment variable. The same config is honored by the Codex CLI, the IDE
extension, and the ChatGPT desktop app:

```toml theme={"dark"}
[mcp_servers.aireserve]
url = "https://api.aireserve.com/mcp"
bearer_token_env_var = "AIRESERVE_MCP_TOKEN"
```

Codex reads the variable at launch — restart Codex after exporting it, then verify with
`codex mcp list`.

## Cursor

One click with OAuth, no token to mint — open this install link (or paste it into the
address bar), accept the server, then choose **Authenticate**:

```text theme={"dark"}
cursor://anysphere.cursor-deeplink/mcp/install?name=aireserve&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vYXBpLmFpcmVzZXJ2ZS5jb20vbWNwIn0=
```

To use a minted token instead, `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per
project). Note Cursor's env interpolation is `${env:VAR}` — not Claude Code's `${VAR}`:

```json theme={"dark"}
{
  "mcpServers": {
    "aireserve": {
      "url": "https://api.aireserve.com/mcp",
      "headers": { "Authorization": "Bearer ${env:AIRESERVE_MCP_TOKEN}" }
    }
  }
}
```

## GitHub Copilot

One click in VS Code ([Add to VS Code](https://insiders.vscode.dev/redirect?url=vscode%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522aireserve%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fapi.aireserve.com%252Fmcp%2522%257D) ·
[Insiders](https://insiders.vscode.dev/redirect?url=vscode-insiders%3Amcp%2Finstall%3F%257B%2522name%2522%253A%2522aireserve%2522%252C%2522type%2522%253A%2522http%2522%252C%2522url%2522%253A%2522https%253A%252F%252Fapi.aireserve.com%252Fmcp%2522%257D)), or paste the server into `.vscode/mcp.json`; JetBrains,
Visual Studio, Eclipse and Xcode take the same `servers` JSON through *Configure your MCP server →
Add MCP Tools*. Each signs you in with OAuth, no token to mint:

```json .vscode/mcp.json theme={"dark"}
{
  "servers": {
    "aireserve": {
      "type": "http",
      "url": "https://api.aireserve.com/mcp"
    }
  }
}
```

Copilot CLI: `copilot mcp add --transport http aireserve https://api.aireserve.com/mcp`. The Copilot cloud agent on
github.com cannot run a browser flow, so it carries a minted token in a header from a
`COPILOT_MCP_*` secret — the exact configuration, the `MCP servers in Copilot` admin policy, and the
`/mcp.aireserve.ask-model` command are on the [GitHub Copilot page](/connect/github-copilot#2-add-the-ai-reserve-assistant-to-copilot-chat).

## Calling the API directly

No MCP client required — the endpoint is plain JSON-RPC 2.0 over HTTPS, and single tool
calls work statelessly (no `initialize` handshake needed). Two rules:

* Send `Accept: application/json, text/event-stream` — the server refuses requests that
  don't accept both.
* The response arrives as a single SSE `message` event whose `data:` line is the JSON-RPC
  response. The tool's payload is JSON, serialized into `result.content[0].text`, with
  `result.isError` flagging failures.

List every tool your token and role can see:

```shell theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

Call one — here, `whoami`:

```shell theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"whoami","arguments":{}}}'
```

```text theme={"dark"}
event: message
data: {"result":{"content":[{"type":"text","text":"{
  \"user\": { \"email\": \"jordan@acme.com\", \"name\": \"Jordan Lee\", \"role\": \"enterprise_admin\" },
  \"organization\": { \"id\": \"9cba8ede-…\", \"name\": \"Acme\" },
  \"authority\": { \"kind\": \"admin\", \"platform\": false },
  \"scopes\": [\"mcp:read\", \"mcp:write\", \"mcp:messages\"],
  \"tokenExpiresAt\": \"2027-08-05T16:34:29.000Z\"
}"}],"isError":false},"jsonrpc":"2.0","id":1}
```

## The tool surface is computed per request

There is no fixed tool list. On every request the server verifies your token, derives your
**live role**, intersects it with the token's **scopes**, and builds the tool set fresh — an
analyst and an admin literally see different tools, and a role change or token revocation
applies on the very next call.

| Your role | What you see |
| - | - |
| **Enterprise admin** | Everything: 22 tools spanning members, teams and budgets, org API keys, analytics, model policy and routing, org settings, files, and billing — plus the personal and fixed tools |
| **Team lead** (manager of an org node) | Personal tools, plus `invite_user` and the team-scoped budget/membership actions for their own subtree |
| **Member** | The fixed tools plus `personal-query` / `personal-action` — own usage, own budget, own API keys, own default model |

Super admins are deliberately de-escalated on this surface: over MCP a platform operator
acts as an enterprise admin of their own organization only — never across tenants.

Beyond the five fixed tools (`whoami`, `list-models`, `get-model`, `get-connection-guide`,
`send-message`), tools come in per-domain pairs — `<domain>-query` for reads,
`<domain>-action` for writes. Each takes **one operation per call**, wrapped as
`{"query": {"action": …, "input": {…}}}` or `{"proposal": {"action": …, "input": {…}}}`.
The [tool reference](/connect/mcp-tools) lists every operation with a runnable request.

## Consent and secrets

Every action resolves to one of three response shapes. Reads and plain writes execute
immediately (your MCP client's own human-in-the-loop approves tool invocations; the server's
authorization guards enforce regardless). High-stakes and secret-revealing actions add a
server-side step that no client setting can skip:

**1. Executed** — reads and plain writes:

```json theme={"dark"}
{ "status": "executed", "summary": "Set default chat model to claude-sonnet-4-6", "ok": true, "message": "Default model set to claude-sonnet-4-6" }
```

**2. Needs confirmation** — irreversible or other-people-affecting actions (revoking keys,
deactivating members, moving money, purging content). The first call returns the exact
consent line plus a signed `confirmToken` binding the operation, input, and caller. Show the
summary to a human; only after they approve, repeat the same call with the token attached.
Tokens expire in 10 minutes, and execution re-checks the target — if the row changed since
the human read the line, the call is refused instead of doing something they didn't approve:

```json theme={"dark"}
{
  "status": "needs_confirmation",
  "summary": "Revoke API key \"CI pipeline\" (aireserve_api_493…28e5ae)",
  "confirmNote": "Irreversible — the key stops working immediately.",
  "confirmToken": "eyJhbGciOi…",
  "message": "High-stakes action: show the user the summary and note, and only after they explicitly approve, call this tool again with the same proposal plus this confirmToken. The token expires in 10 minutes."
}
```

**3. Portal redemption** — actions that reveal a one-time secret (minting API keys, file
download links). The secret **never** passes through the MCP connection or the model's
context. Instead the call returns a signed, user-bound portal link, valid for 15 minutes;
opening it in a signed-in browser confirms the action and shows the secret exactly once.
Nothing is created until the link is redeemed:

```json theme={"dark"}
{
  "status": "portal_redemption",
  "summary": "Create API key \"CI pipeline\"",
  "url": "https://portal.aireserve.com/mcp-redeem?intent=eyJvcCI6…",
  "message": "This action reveals a one-time secret, which never passes through this connection. Give the user the link — it opens in the portal, where they confirm and see the secret once. The link expires in 15 minutes."
}
```

> [!NOTE]
>
> **Why you can't get an API key's secret over the API.** This is a design guarantee, not a
> gap: management credentials for LLM-driven channels must never let a prompt injection
> exfiltrate a fresh key. The redemption link is the proof the action is authorized; the
> signed-in human click is the only place the secret exists.

## Rate limits and errors

Only `tools/call` messages are metered — `initialize`, `ping`, and `tools/list` are free
protocol chatter. Limits are enforced per organization (the same request-per-minute and
per-day limits as the machine API); over the limit you get `429` with a `Retry-After`
header. Ask `get-connection-guide` for your organization's effective values.

Authorization failures relay a human-readable reason (`invalid_token` on the HTTP layer for
bad credentials; in-band `{"error": …}` tool results for operations your role can't
perform). `send-message` can legitimately take a while on slow models — the endpoint allows
up to 120 seconds per call.

## What agents can do — and what they can't

> **[Everything, catalogued](/connect/mcp-tools)**
>
> The complete reference: every tool, every operation, who can call it, a copy-paste
> request for each, and the natural-language ask that does the same thing.

> **Hard limits**
>
> No secrets in responses — ever. No platform (cross-tenant) operations. No inference
> keys accepted. No impersonation, no file-byte uploads. Every write runs the same
> server-side authorization guards as the portal UI.


# MCP tool reference
Source: https://docs.aireserve.com/connect/mcp-tools

Every tool and operation on the AI Reserve MCP server — who can call it, the copy-paste request, and the plain-English ask that does the same thing.

This page is the complete capability catalog of the [hosted MCP server](/connect/mcp): all
**22 tools** and **90+ operations** an enterprise admin can drive, each with a runnable
request. It is generated against the same operation registry the portal's sidebar assistant
uses, so the two surfaces cannot drift.

Two ways to use everything below:

* **Ask your agent.** With the server connected (Claude Code, Codex, Cursor, a Claude
  custom connector, …), say the thing — *"revoke the CI key that hasn't been used in 30
  days"* — and the agent picks the operation, resolves the ids, and walks the consent flow.
  Every section lists example asks.
* **Call it yourself.** Every operation is one JSON-RPC `tools/call` POST. Copy any snippet
  below.

## The call, once

All snippets share this exact shape — only the JSON body changes:

```shell theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"<tool>","arguments":{…}}}'
```

Reads go through a domain's `*-query` tool as `{"query": {"action": …, "input": {…}}}`;
writes go through `*-action` as `{"proposal": {"action": …, "input": {…}}}`. Replace
`<…-uuid>` placeholders with real ids — always resolved from a query tool first, never
guessed.

**How each operation runs** (the *Runs* column below):

| Runs | Meaning |
| - | - |
| immediately | Executes on the call and returns `{"status": "executed", "ok": …, "message": …}` (queries return `{"ok", "message", "data"}`) |
| after confirm | Returns `needs_confirmation` with a 10-minute `confirmToken`; show the summary to a human, then repeat the call with `"confirmToken"` added to the arguments |
| portal link | Returns `portal_redemption` with a 15-minute link; the secret renders once in the signed-in portal, never over the API — see [consent and secrets](/connect/mcp#consent-and-secrets) |

**Who sees what.** The tool list is computed per request from the connected user's live role:
members get the fixed tools plus `personal-*`; team leads add their subtree's membership and
budget actions; enterprise admins get everything on this page. Ids in parentheses after each
heading are the exact tool names (they surface in Claude Code as `mcp__aireserve__<tool>`).

## Identity & catalog (`whoami`, `list-models`, `get-model`, `get-connection-guide`)

Fixed read tools, available to every role with `mcp:read`.

> *"Who is this connection signed in as?"* · *"Which models can we use right now, and what
> do they cost?"* · *"Is deepseek-v3.2 blocked for our org?"* · *"Give me the base URLs and
> rate limits for pointing our SDK at the gateway."*

| Tool | What it returns | Runs |
| - | - | - |
| `whoami` | Acting account, organization, role, authority level, token scopes and expiry | immediately |
| `list-models` | Every gateway chat model with live pricing (USD per 1M tokens), latency/reasoning traits, org blocklist status, and the org default | immediately |
| `get-model` | One model by id: pricing, traits, reasoning notes, org availability | immediately |
| `get-connection-guide` | Gateway base URLs, wire-compatible endpoints (OpenAI, Anthropic, Bedrock), env-var conventions, the org's effective rate limits, guided connect pages | immediately |

```shell whoami theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"whoami","arguments":{}}}'
```

```shell list-models theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list-models","arguments":{}}}'
```

```shell get-model theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get-model","arguments":{"modelId":"claude-sonnet-4-6"}}}'
```

```shell get-connection-guide theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get-connection-guide","arguments":{}}}'
```

Each `list-models` entry looks like:

```json theme={"dark"}
{
  "id": "claude-sonnet-4-6",
  "name": "Claude Sonnet 4.6",
  "provider": "Anthropic",
  "latency": "medium",
  "reasoning": "advanced",
  "blocked": false,
  "pricing": { "inputPer1mTokens": 3, "outputPer1mTokens": 15 }
}
```

## One-shot inference (`send-message`)

Requires the `mcp:messages` scope. Sends one prompt through the gateway **as the connected
user** — billed, rate-limited, and visible in usage analytics exactly like their own
traffic. Respects the org's model policy (blocked models are refused; omitted `modelId`
uses the org default).

> *"Ask kimi-k2 to summarize this changelog."* · *"Run this prompt against the org default
> model."*

| Input | Type | Notes |
| - | - | - |
| `prompt` | string, required | Up to 32,000 characters |
| `modelId` | string | From `list-models`; defaults to the org default model |
| `system` | string | Optional system prompt, up to 8,000 characters |
| `maxOutputTokens` | int | 1–8,192; default 1,024 |

```shell send-message theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"send-message","arguments":{"prompt":"One sentence: what is an LLM gateway?","modelId":"claude-sonnet-4-6","maxOutputTokens":200}}}'
```

Returns `{ "model", "text", "finishReason", "usage": { "inputTokens", "outputTokens" } }`.
Budget refusals are relayed in plain language (spend cap reached, wallet balance too low).

## Personal (`personal-query`, `personal-action`)

Every role. The caller's own usage, budget, keys, and preferences.

> *"How much have I spent this week, and on which models?"* · *"List my API keys with
> 30-day usage and revoke the one I stopped using."* · *"Make gemini-3-flash my default
> model."*

| Operation | What it does | Runs |
| - | - | - |
| `get_my_usage_summary` | Usage for your visible scope (self / team / org by role): totals, top models, active users, spend leaderboard; 1, 7, or 30 days; admins and team leads can drill into a team or member | immediately |
| `get_my_budget_status` | Your spend cap and team budget with remaining headroom | immediately |
| `list_my_api_keys` | Your API keys, masked, with ids and optional 30-day request counts | immediately |
| `create_api_key` | Mint a personal inference key | portal link |
| `revoke_api_key` | Revoke one of your own keys (irreversible) | after confirm |
| `set_default_model` | Set or clear (`null`) your personal default chat model | immediately |

```shell get_my_usage_summary theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-query","arguments":{"query":{"action":"get_my_usage_summary","input":{"days":7}}}}}'
```

```shell get_my_budget_status theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-query","arguments":{"query":{"action":"get_my_budget_status","input":{}}}}}'
```

```shell list_my_api_keys theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-query","arguments":{"query":{"action":"list_my_api_keys","input":{"includeUsage":true}}}}}'
```

```shell create_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-action","arguments":{"proposal":{"action":"create_api_key","input":{"name":"CI pipeline"}}}}}'
```

```shell revoke_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-action","arguments":{"proposal":{"action":"revoke_api_key","input":{"keyId":"<key-uuid>"}}}}}'
```

```shell set_default_model theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"personal-action","arguments":{"proposal":{"action":"set_default_model","input":{"modelId":"claude-sonnet-4-6"}}}}}'
```

## Organization API keys (`api-keys-query`, `api-keys-action`)

Enterprise admins. The org's gateway credentials: listing, usage, minting, revocation,
compaction, and live self-tests.

> *"List all our API keys and flag the ones idle for 30 days."* · *"Mint an org key named
> 'ETL prod' bound to Priya for attribution."* · *"Revoke key 4354cccc — verify the id
> against the list first."* · *"Run a test ping through the new key."*

| Operation | What it does | Runs |
| - | - | - |
| `list_client_api_keys` | Every org key — id, masked key, binding (user / team / organization), status, last use | immediately |
| `get_client_api_key_usage` | Per-key request/token/cost totals, optional `startDate`/`endDate` | immediately |
| `get_client_api_key_trends` | 30-day request count and last-use per key — idle-key detection | immediately |
| `check_copilot_key_traffic` | Whether a Copilot connect key has served traffic beyond its self-test | immediately |
| `create_client_api_key` | Mint an org key, optionally bound to a member (`userId`) for attribution and user-scope quota | portal link |
| `create_team_api_key` | Mint a team-scoped key | portal link |
| `revoke_client_api_key` | Revoke any org key (irreversible) | after confirm |
| `set_api_key_compaction` | Toggle always-on context compaction for one key | immediately |
| `test_api_key` | One-token live ping through a key — verifies auth, model policy, caps, provider (a real metered call) | immediately |

```shell list_client_api_keys theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-query","arguments":{"query":{"action":"list_client_api_keys","input":{}}}}}'
```

```shell get_client_api_key_usage theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-query","arguments":{"query":{"action":"get_client_api_key_usage","input":{"startDate":"2026-08-01","endDate":"2026-08-19"}}}}}'
```

```shell get_client_api_key_trends theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-query","arguments":{"query":{"action":"get_client_api_key_trends","input":{}}}}}'
```

```shell check_copilot_key_traffic theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-query","arguments":{"query":{"action":"check_copilot_key_traffic","input":{"keyId":"<key-uuid>"}}}}}'
```

```shell create_client_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-action","arguments":{"proposal":{"action":"create_client_api_key","input":{"name":"ETL prod","userId":"<user-uuid>"}}}}}'
```

```shell create_team_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-action","arguments":{"proposal":{"action":"create_team_api_key","input":{"teamId":"<team-uuid>","name":"Data science shared"}}}}}'
```

```shell revoke_client_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-action","arguments":{"proposal":{"action":"revoke_client_api_key","input":{"keyId":"<key-uuid>"}}}}}'
```

```shell set_api_key_compaction theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-action","arguments":{"proposal":{"action":"set_api_key_compaction","input":{"keyId":"<key-uuid>","enabled":true}}}}}'
```

```shell test_api_key theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"api-keys-action","arguments":{"proposal":{"action":"test_api_key","input":{"keyId":"<key-uuid>"}}}}}'
```

> [!NOTE]
>
> Key minting is always a **portal link** — the fresh secret renders once in the signed-in
> portal and never crosses the API. The two-step flow exists so an LLM-driven channel can
> never exfiltrate a live credential.

## Members (`members-query`, `members-action`)

Enterprise admins (`invite_user` also team leads, restricted to regular users on a team in
their subtree). Account directory, per-member usage, invitations, roles, lifecycle.

> *"Invite [ada@acme.com](mailto:ada@acme.com) to the Data team and send her the onboarding email."* · *"Who are
> our top spenders this month, by model?"* · *"Deactivate Sam's account."* · *"Promote
> Priya to enterprise admin."* · *"Send Marco a password reset."*

| Operation | What it does | Runs |
| - | - | - |
| `list_org_users` | Search accounts (email/name), filter by role, include inactive and soft-deleted, paged | immediately |
| `get_member_usage_totals` | Token and spend totals for up to 25 members by id | immediately |
| `get_member_usage_by_model` | One member's usage broken down by model | immediately |
| `get_shared_key_usage` | Usage from shared org/team keys attributed to no user | immediately |
| `get_shared_key_usage_by_model` | The same, broken down by model | immediately |
| `invite_user` | Create an account (role `user` or `enterprise_admin`, optional team) and optionally email the sign-in link | after confirm |
| `update_member_profile` | Edit name, phone, address, contact notes | immediately |
| `assign_member_team` | Move a member onto a team, or `null` for Unassigned | immediately |
| `set_member_active` | Activate or deactivate an account (deactivation locks out every session) | after confirm |
| `set_user_org_role` | Promote/demote between `user` and `enterprise_admin` (forces re-sign-in) | after confirm |
| `delete_user` | Soft-delete the account and permanently purge their stored conversations | after confirm |
| `restore_user` | Restore a soft-deleted account and email a fresh sign-in link | after confirm |
| `send_password_reset` | Email a live password-reset link | after confirm |
| `send_onboarding_email` | Send or resend the onboarding email | after confirm |

Guard rails the server enforces on every transport: you cannot deactivate or delete
yourself, you cannot change your own role, and the last enterprise admin can never be
demoted or locked out.

```shell list_org_users theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-query","arguments":{"query":{"action":"list_org_users","input":{"search":"ada"}}}}}'
```

```shell get_member_usage_totals theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-query","arguments":{"query":{"action":"get_member_usage_totals","input":{"userIds":["<user-uuid>"],"startDate":"2026-08-01","endDate":"2026-08-19"}}}}}'
```

```shell get_member_usage_by_model theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-query","arguments":{"query":{"action":"get_member_usage_by_model","input":{"userId":"<user-uuid>"}}}}}'
```

```shell get_shared_key_usage theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-query","arguments":{"query":{"action":"get_shared_key_usage","input":{}}}}}'
```

```shell get_shared_key_usage_by_model theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-query","arguments":{"query":{"action":"get_shared_key_usage_by_model","input":{"teamId":"<team-uuid>"}}}}}'
```

```shell invite_user theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"invite_user","input":{"email":"ada@acme.com","name":"Ada Park","role":"user","teamId":"<team-uuid>","sendOnboardingEmail":true}}}}}'
```

```shell update_member_profile theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"update_member_profile","input":{"userId":"<user-uuid>","name":"Ada Park-Reyes"}}}}}'
```

```shell assign_member_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"assign_member_team","input":{"userId":"<user-uuid>","teamId":"<team-uuid>"}}}}}'
```

```shell set_member_active theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"set_member_active","input":{"userId":"<user-uuid>","active":false}}}}}'
```

```shell set_user_org_role theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"set_user_org_role","input":{"userId":"<user-uuid>","role":"enterprise_admin"}}}}}'
```

```shell delete_user theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"delete_user","input":{"userId":"<user-uuid>"}}}}}'
```

```shell restore_user theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"restore_user","input":{"userId":"<user-uuid>"}}}}}'
```

```shell send_password_reset theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"send_password_reset","input":{"userId":"<user-uuid>"}}}}}'
```

```shell send_onboarding_email theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"send_onboarding_email","input":{"userId":"<user-uuid>"}}}}}'
```

## Teams & budgets (`teams-budgets-query`, `teams-budgets-action`)

Enterprise admins; team leads can move members within their own subtree, allocate budget to
teams strictly below their own node, and grant/revoke manager status inside their org.
The envelope model: **org cap → team allocations → Unassigned pool → per-user caps**.

> *"Create a Research sub-team under Engineering and give it $2,000."* · *"Show the
> allocation table — who has headroom?"* · *"Cap Anna at $150 with 60 requests a minute."*
> · *"Move these five people to Platform."* · *"Make Jordan a manager."*

| Operation | What it does | Runs |
| - | - | - |
| `get_team_allocations` | The full budget table: org cap, per-team allocations and spend, Unassigned pool, headroom | immediately |
| `list_user_spend_caps` | Per-user caps with lifetime spend (only capped users appear) | immediately |
| `get_client_spend_summary` | Org-wide cap, current spend, budget period | immediately |
| `create_team` | New team, optionally under `parentTeamId` | immediately |
| `rename_team` | Rename a team | immediately |
| `delete_team` | Delete an **empty** team (refused while it has members or sub-teams) | after confirm |
| `assign_user_to_team` | Move one member to a team or Unassigned (`null`; admins only for Unassigned) | immediately |
| `bulk_assign_users_to_team` | Move up to 25 members atomically | after confirm |
| `set_team_cap` | Set a team's total (subtree) allocation in USD | immediately |
| `remove_team_cap` | Remove a team's explicit allocation | immediately |
| `set_unassigned_pool_cap` | Cap the Unassigned pool | immediately |
| `remove_unassigned_pool_cap` | Team-less users fall back to the org cap | immediately |
| `set_user_boss_status` | Grant or dissolve a member's manager role (their own org node) | after confirm |
| `set_user_spend_cap` | Personal spend cap in USD, optional requests/minute and requests/day | immediately |
| `remove_user_spend_cap` | Back to team/org limits | immediately |
| `set_client_spend_cap` | Set or clear (`null`) the org-wide ceiling — all traffic stops when reached | after confirm |

```shell get_team_allocations theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-query","arguments":{"query":{"action":"get_team_allocations","input":{}}}}}'
```

```shell list_user_spend_caps theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-query","arguments":{"query":{"action":"list_user_spend_caps","input":{}}}}}'
```

```shell get_client_spend_summary theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-query","arguments":{"query":{"action":"get_client_spend_summary","input":{}}}}}'
```

```shell create_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"create_team","input":{"name":"Research","parentTeamId":"<team-uuid>"}}}}}'
```

```shell rename_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"rename_team","input":{"teamId":"<team-uuid>","name":"Applied Research"}}}}}'
```

```shell delete_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"delete_team","input":{"teamId":"<team-uuid>"}}}}}'
```

```shell assign_user_to_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"assign_user_to_team","input":{"userId":"<user-uuid>","teamId":"<team-uuid>"}}}}}'
```

```shell bulk_assign_users_to_team theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"bulk_assign_users_to_team","input":{"userIds":["<user-uuid>","<user-uuid>"],"teamId":"<team-uuid>"}}}}}'
```

```shell set_team_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"set_team_cap","input":{"teamId":"<team-uuid>","budgetLimitUsd":2000}}}}}'
```

```shell remove_team_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"remove_team_cap","input":{"teamId":"<team-uuid>"}}}}}'
```

```shell set_unassigned_pool_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"set_unassigned_pool_cap","input":{"budgetLimitUsd":500}}}}}'
```

```shell remove_unassigned_pool_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"remove_unassigned_pool_cap","input":{}}}}}'
```

```shell set_user_boss_status theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"set_user_boss_status","input":{"userId":"<user-uuid>","makeBoss":true}}}}}'
```

```shell set_user_spend_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"set_user_spend_cap","input":{"userId":"<user-uuid>","budgetLimitUsd":150,"requestsPerMinute":60}}}}}'
```

```shell remove_user_spend_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"remove_user_spend_cap","input":{"userId":"<user-uuid>"}}}}}'
```

```shell set_client_spend_cap theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"teams-budgets-action","arguments":{"proposal":{"action":"set_client_spend_cap","input":{"capUsd":10000}}}}}'
```

## Analytics (`analytics-query`)

Enterprise admins, read-only (there is no `analytics-action`). Compact aggregates by
design — top-5 lists, one 20-row log page, capped vocabularies — with request **metadata
only**: prompt and response content never crosses this surface.

> *"What did we spend last month, split input/output/cached?"* · *"Show failed gateway
> requests from yesterday."* · *"Which business functions drive our AI spend?"* · *"Give me
> a usage summary for June 1 to June 30."*

| Operation | What it does | Runs |
| - | - | - |
| `get_spend_breakdown` | 30-day USD split: input / output / cached, plus request count | immediately |
| `get_gateway_usage_stats` | Aggregate totals (requests, tokens, spend, latency, errors) filtered by date / model / provider / status / user | immediately |
| `get_gateway_request_log` | One page (≤20 rows) of the request log: who called which model, when, cost, status; cursor-paged over a stable snapshot | immediately |
| `get_business_function_usage` | Usage grouped by business function and team, top 25 by cost | immediately |
| `get_gateway_filter_options` | The legal filter values for the two ops above | immediately |
| `get_analytics_dashboard` | Analytics summary for a preset (1/7/30 days) or custom range (≤366 days), scoped to org, a team subtree, or a member set | immediately |
| `get_model_usage_year` | Trailing-365-day model rollup, top 5 by spend | immediately |

```shell get_spend_breakdown theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_spend_breakdown","input":{}}}}}'
```

```shell get_gateway_usage_stats theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_gateway_usage_stats","input":{"startDate":"2026-08-01","endDate":"2026-08-19","model":"claude-sonnet-4-6"}}}}}'
```

```shell get_gateway_request_log theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_gateway_request_log","input":{"startDate":"2026-08-18","status":"failure","limit":20}}}}}'
```

```shell get_business_function_usage theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_business_function_usage","input":{"startDate":"2026-08-01"}}}}}'
```

```shell get_gateway_filter_options theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_gateway_filter_options","input":{}}}}}'
```

```shell get_analytics_dashboard theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_analytics_dashboard","input":{"from":"2026-06-01","to":"2026-06-30"}}}}}'
```

```shell get_model_usage_year theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"analytics-query","arguments":{"query":{"action":"get_model_usage_year","input":{}}}}}'
```

## Models & routing (`models-routing-query`, `models-routing-action`)

Enterprise admins. The org's model policy (default model, selection lock, blocklist) and the
Auto-router (enrollment, tuning, bring-your-own endpoint).

> *"Set the org default to Auto routing."* · *"Block the models that train on inputs."* ·
> *"Rebalance the router 60% smarter / 30% cheaper / 10% faster."* · *"Which providers
> serve Kimi K2 right now, and at what price and uptime?"*

| Operation | What it does | Runs |
| - | - | - |
| `get_model_provider_endpoints` | Live per-provider pricing, uptime, and throughput for one catalog model | immediately |
| `set_org_default_model` | Set the org default chat model — a model id, `"auto"` for Auto Routing, or `null` for the platform default | immediately |
| `set_model_governance` | Lock model selection to the default and/or replace the org blocklist or its blocked-maker list (`blockedModelMakers`, every current and future model of a maker; each list is a full replacement and `[]` clears it) | immediately |
| `update_router_selections` | Replace Auto-router enrollment and/or its blocklist (full replacement; `[]` clears) | immediately |
| `update_router_tuning` | Rebalance smarter/cheaper/faster (must sum to 100) and/or replace the plain-language routing rules | after confirm |
| `update_provider_preference` | Choose which host serves open-weight models served by several providers: a preset (`cheapest`, `fastest`, `most_reliable`, `balanced`) or `custom` price/latency/reliability weights, provider exclusions, and conversation stickiness | after confirm |
| `set_router_endpoint` | Live-test a bring-your-own router URL and save it only if the test passes | after confirm |
| `clear_router_endpoint` | Back to the built-in Auto router | after confirm |

```shell get_model_provider_endpoints theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-query","arguments":{"query":{"action":"get_model_provider_endpoints","input":{"modelId":"anthropic/claude-sonnet-4.6"}}}}}'
```

```shell set_org_default_model theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"set_org_default_model","input":{"modelId":"auto"}}}}}'
```

```shell set_model_governance theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"set_model_governance","input":{"modelSelectionLocked":false,"blockedModelIds":["deepseek-chat"]}}}}}'
```

```shell update_router_selections theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"update_router_selections","input":{"routerModelIds":["anthropic/claude-sonnet-4.6","openai/gpt-5.5"]}}}}}'
```

```shell update_router_tuning theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"update_router_tuning","input":{"tuning":{"smarter":60,"cheaper":30,"faster":10}}}}}}'
```

```shell update_provider_preference theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"update_provider_preference","input":{"preset":"cheapest","excludedProviders":["baseten"]}}}}}'
```

```shell set_router_endpoint theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"set_router_endpoint","input":{"endpointUrl":"https://router.acme.com/route","method":"POST"}}}}}'
```

```shell clear_router_endpoint theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"models-routing-action","arguments":{"proposal":{"action":"clear_router_endpoint","input":{}}}}}'
```

## Org settings (`org-settings-query`, `org-settings-action`)

Enterprise admins. Org-wide chat text, privacy controls, branding, sign-in access, and
business-function classification review.

> *"Turn off storage of prompt and response text."* · *"Set content retention to 30 days."*
> · *"Open self-serve sign-up for acme.com."* · *"What classification questions are waiting
> on me?"* · *"What needs my attention today?"*

| Operation | What it does | Runs |
| - | - | - |
| `get_stored_content_count` | How many conversation rows a purge would delete | immediately |
| `get_org_branding` | Whitelabeling flag, window title, logo presence | immediately |
| `list_signin_domains` | Verified sign-in email domains and their self-serve status | immediately |
| `list_needs_input_classifications` | Keys/teams/users whose classification awaits an admin answer | immediately |
| `list_classification_records` | Classification records with date/category/state filters, cursor-paged | immediately |
| `get_classification_summary` | Labeled-coverage totals | immediately |
| `get_classification_provenance` | Why one usage row carries its label | immediately |
| `get_needs_attention` | Today's admin to-dos: budget alerts, stale keys, spend spikes | immediately |
| `update_org_instructions` | Replace/toggle the org-wide chat instructions | after confirm |
| `update_org_context` | Replace/toggle the org context text shared with every chat | after confirm |
| `set_content_logging` | Turn storage of prompt/response text on or off | immediately |
| `set_content_retention` | Days before the scheduled purge deletes stored chat content (`null` = keep) | after confirm |
| `purge_stored_content` | Permanently delete ALL stored conversation content | after confirm |
| `set_whitelabeling` | Toggle whitelabeled branding | immediately |
| `set_window_title` | Set or clear (`""`) the custom browser title | immediately |
| `remove_org_logo` | Remove the logo (also disables whitelabeling) | after confirm |
| `set_domain_auto_provision` | Open or close self-serve sign-up for a verified domain | after confirm |
| `set_classification_enabled` | Toggle business-function classification of new usage | immediately |
| `answer_classification_question` | Answer an open question — re-buckets all usage under that key/team/user | immediately |
| `confirm_classification` | Confirm or correct one usage row's label | immediately |
| `clear_classification` | Clear one usage row's label | immediately |
| `dismiss_attention_items` | Dismiss the current needs-attention items | immediately |

```shell get_needs_attention theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"get_needs_attention","input":{}}}}}'
```

```shell get_stored_content_count theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"get_stored_content_count","input":{}}}}}'
```

```shell get_org_branding theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"get_org_branding","input":{}}}}}'
```

```shell list_signin_domains theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"list_signin_domains","input":{}}}}}'
```

```shell list_needs_input_classifications theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"list_needs_input_classifications","input":{"limit":10}}}}}'
```

```shell list_classification_records theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"list_classification_records","input":{"state":"needs_input","pageSize":10}}}}}'
```

```shell get_classification_summary theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"get_classification_summary","input":{"startDate":"2026-08-01"}}}}}'
```

```shell get_classification_provenance theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-query","arguments":{"query":{"action":"get_classification_provenance","input":{"usageLogId":"<usage-row-uuid>"}}}}}'
```

```shell update_org_instructions theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"update_org_instructions","input":{"text":"Answer in the metric system. Cite internal wiki pages where relevant.","enabled":true}}}}}'
```

```shell update_org_context theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"update_org_context","input":{"text":"Acme builds industrial robotics. Fiscal year starts in February.","enabled":true}}}}}'
```

```shell set_content_logging theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_content_logging","input":{"enabled":false}}}}}'
```

```shell set_content_retention theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_content_retention","input":{"days":30}}}}}'
```

```shell purge_stored_content theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"purge_stored_content","input":{}}}}}'
```

```shell set_whitelabeling theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_whitelabeling","input":{"enabled":true}}}}}'
```

```shell set_window_title theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_window_title","input":{"title":"Acme AI"}}}}}'
```

```shell remove_org_logo theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"remove_org_logo","input":{}}}}}'
```

```shell set_domain_auto_provision theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_domain_auto_provision","input":{"domainId":"<domain-uuid>","enabled":true}}}}}'
```

```shell set_classification_enabled theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"set_classification_enabled","input":{"enabled":true}}}}}'
```

```shell answer_classification_question theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"answer_classification_question","input":{"assignmentId":"<assignment-uuid>","category":"engineering"}}}}}'
```

```shell confirm_classification theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"confirm_classification","input":{"usageLogId":"<usage-row-uuid>","category":"sales"}}}}}'
```

```shell clear_classification theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"clear_classification","input":{"usageLogId":"<usage-row-uuid>"}}}}}'
```

```shell dismiss_attention_items theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"org-settings-action","arguments":{"proposal":{"action":"dismiss_attention_items","input":{}}}}}'
```

## Files (`files-query`, `files-action`)

Enterprise admins. The organization's stored files. Uploads stay in the portal (an API
can't supply file bytes through a consent card); everything else is here.

> *"List our shared files — anything named 'onboarding'?"* · *"Get me a download link for
> the Q2 board deck."* · *"Delete the stale export from May."*

| Operation | What it does | Runs |
| - | - | - |
| `list_org_files` | Shared files with name, type, size, upload date; searchable, paged | immediately |
| `get_file_download_link` | Mint a one-hour signed download URL (a bearer capability, so it renders in the portal only) | portal link |
| `delete_org_file` | Delete a stored file (irreversible) | after confirm |

```shell list_org_files theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"files-query","arguments":{"query":{"action":"list_org_files","input":{"search":"onboarding"}}}}}'
```

```shell get_file_download_link theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"files-action","arguments":{"proposal":{"action":"get_file_download_link","input":{"documentId":"<document-uuid>"}}}}}'
```

```shell delete_org_file theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"files-action","arguments":{"proposal":{"action":"delete_org_file","input":{"documentId":"<document-uuid>"}}}}}'
```

## Billing (`billing-query`, `billing-action`)

Enterprise admins. The yield-to-compute wallet, the immutable ledger mirror, and CARR
reporting. Money movements are the most conservative operations on the surface — every one
confirms, and none can be undone.

> *"What's our wallet balance and last epoch's yield?"* · *"List the credits into the
> wallet this quarter."* · *"Close the July ledger period and generate the CARR summary."*

| Operation | What it does | Runs |
| - | - | - |
| `get_wallet_summary` | Current wallet balance and last-epoch yield | immediately |
| `list_wallet_credits` | Credits into the wallet — funding, sweeps, transfers in | immediately |
| `get_ledger_balance` | Ledger rollup: opening/closing balance, additions, consumption, recent events | immediately |
| `list_ledger_periods` | Closed-and-hashed periods with record counts and hashes | immediately |
| `generate_carr_report` | CARR summary figures for a period (file exports stay on `/admin/carr`) | immediately |
| `transfer_client_funds` | Move USD from your wallet to another client's — requires a caller-minted `idempotencyKey` (reuse the same key on retry; a fresh key is a second transfer) | after confirm |
| `close_ledger_period` | Close a usage period and anchor it into the immutable hash chain — can never be reopened | after confirm |

```shell get_wallet_summary theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-query","arguments":{"query":{"action":"get_wallet_summary","input":{}}}}}'
```

```shell list_wallet_credits theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-query","arguments":{"query":{"action":"list_wallet_credits","input":{}}}}}'
```

```shell get_ledger_balance theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-query","arguments":{"query":{"action":"get_ledger_balance","input":{}}}}}'
```

```shell list_ledger_periods theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-query","arguments":{"query":{"action":"list_ledger_periods","input":{}}}}}'
```

```shell generate_carr_report theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-query","arguments":{"query":{"action":"generate_carr_report","input":{"periodStart":"2026-07-01T00:00:00Z","periodEnd":"2026-07-31T23:59:59Z"}}}}}'
```

```shell transfer_client_funds theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-action","arguments":{"proposal":{"action":"transfer_client_funds","input":{"toClientId":"<client-uuid>","amountUsd":250,"idempotencyKey":"<mint-one-uuid-per-transfer>"}}}}}'
```

```shell close_ledger_period theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"billing-action","arguments":{"proposal":{"action":"close_ledger_period","input":{"periodStart":"2026-07-01T00:00:00Z","periodEnd":"2026-07-31T23:59:59Z"}}}}}'
```

## GPU compute (`compute-query`, `compute-action`)

Enterprise admins. The provider-hidden GPU flow from the Compute › GPUs page: price a
machine, launch it with persistent storage, see how to connect, stop it when done. The
same placement check and wallet spend gate as the portal run on every call; no provider,
data-center or tenancy identifier ever enters or leaves these tools. **Quote first, then
launch with the `quoteId`** — the user approves the exact all-in price they were shown.

> *"Quote one H100 with 200 GB of persistent storage in Europe, then launch it under
> \$4/hour."* · *"List my GPU machines and stop anything idle."* · *"How do I SSH into
> train-7?"*

| Operation | What it does | Runs |
| - | - | - |
| `list_gpu_offers` | GPU models in stock now with per-GPU hourly price and stock level | immediately |
| `quote_gpu_instance` | All-in price (GPU, root disk, optional new or attached persistent volume) and a `quoteId`; creates nothing | immediately |
| `launch_gpu_instance` | Launch from a `quoteId`, or from a request plus a `maxHourlyPrice` ceiling; opens hourly billing | after confirm |
| `list_gpu_machines` | Machines with state, GPUs, hourly rate, attached volume | immediately |
| `get_gpu_machine` | One machine: image, ports, volume, recovery, and the SSH command / exposed URLs | immediately |
| `get_gpu_machine_logs` | The last \~200 lines of container output | immediately |
| `stop_gpu_machine` / `start_gpu_machine` | Pause and resume (root disk lost on stop; a persistent volume survives) | immediately |
| `terminate_gpu_machine` | Destroy the machine and its root disk | after confirm |
| `list_gpu_volumes` | Persistent volumes: size, region, storage rate, state, attached machine | immediately |
| `delete_gpu_volume` | Delete a detached volume and its data | after confirm |

```shell quote_gpu_instance theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute-query","arguments":{"query":{"action":"quote_gpu_instance","input":{"accelerator":"H100_80GB","count":1,"region":"europe","storage":{"persistentGb":200,"mountPath":"/data"},"maxHourlyPrice":"4.00"}}}}}'
```

```shell launch_gpu_instance theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute-action","arguments":{"proposal":{"action":"launch_gpu_instance","input":{"quoteId":"<quoteId-from-the-quote>","name":"train-7","sshPublicKey":"ssh-ed25519 AAAA…"}}}}}'
```

```shell get_gpu_machine theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute-query","arguments":{"query":{"action":"get_gpu_machine","input":{"podId":"<machine-uuid>"}}}}}'
```

```shell stop_gpu_machine theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute-action","arguments":{"proposal":{"action":"stop_gpu_machine","input":{"podId":"<machine-uuid>"}}}}}'
```

A `launch_gpu_instance` with a persistent `storage` block creates the volume in the GPU's
location inside the same transaction as the machine; pass an existing `volumeId` instead to
pin placement to where that volume already lives. A `no_capacity` refusal carries the
reason (`price_ceiling`, `volume_location`, `no_persistent_storage`, `no_stock`), the
cheapest eligible price and alternatives, so the agent can propose what would work.

## Containers (`containers-query`, `containers-action`)

Enterprise admins. Containers & Orchestration › Elastic Container Service, end to end:
enable the organization's own AWS account behind the [ECS passthrough](/containers/ecs),
mint an ECS credential (a real AWS access key pair — it renders in the portal, never to
the agent), get the exact `~/.aws/config` lines that repoint ECS and CloudWatch Logs at the
gateway, deploy an image to an HTTPS URL, scale, redeploy, read logs, clean up. Web holds
no AWS credential on any path; the gateway signs each call in the organization's account.

> *"Enable Containers, create an ECS credential and set up an `aireserve` AWS profile so
> `aws ecs list-clusters` works."* · *"Deploy ghcr.io/acme/api:1.4 as a public service in
> us-east-1 and tail its logs."* · *"Scale the worker service to zero overnight."*

| Operation | What it does | Runs |
| - | - | - |
| `get_containers_account` | Enabled? Lifecycle state (`requested → vending → provisioning → active`), AWS account id, credentials (names and key hints) | immediately |
| `get_containers_connection_guide` | Endpoint URL, the `~/.aws/config` profile, env vars, SDK one-liners, verify commands | immediately |
| `enable_containers` | Create the organization's AWS account (idempotent; active within minutes) | after confirm |
| `create_ecs_credential` | Mint an AWS access key pair; the `~/.aws/credentials` block renders once in the portal | portal link |
| `revoke_ecs_credential` | Revoke a pair | after confirm |
| `list_ecs_clusters` / `get_ecs_cluster` | Clusters in a region with counts and this month's Fargate usage; one cluster's services and tasks | immediately |
| `get_ecs_service` / `get_ecs_task` | A service (with its HTTPS URL, image, size, scaling, log group when deployed from here); a task's containers and log streams | immediately |
| `list_ecs_task_definitions` | Families with their latest revision | immediately |
| `get_ecs_logs` | CloudWatch events for a task or service, newest 200, optional filter | immediately |
| `deploy_container_service` | Image in, `https://<name>.ecs.<region>.on.aws` out (ECS Express Mode) | after confirm |
| `update_container_service` | New image, size, variables or scaling bounds on a deployed service | immediately |
| `scale_ecs_service` / `redeploy_ecs_service` / `stop_ecs_task` / `create_ecs_cluster` | The everyday buttons | immediately |
| `delete_ecs_service` / `delete_ecs_cluster` | Remove a service (and its URL); remove an empty cluster | after confirm |

```shell enable_containers theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"containers-action","arguments":{"proposal":{"action":"enable_containers","input":{}}}}}'
```

```shell create_ecs_credential theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"containers-action","arguments":{"proposal":{"action":"create_ecs_credential","input":{"name":"my laptop"}}}}}'
```

```shell get_containers_connection_guide theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"containers-query","arguments":{"query":{"action":"get_containers_connection_guide","input":{}}}}}'
```

```shell deploy_container_service theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"containers-action","arguments":{"proposal":{"action":"deploy_container_service","input":{"region":"us-east-1","image":"ghcr.io/acme/api:1.4","containerPort":8080,"minTasks":1,"maxTasks":4}}}}}'
```

```shell get_ecs_logs theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"containers-query","arguments":{"query":{"action":"get_ecs_logs","input":{"region":"us-east-1","logGroupName":"/ecs/api","sinceMinutes":30}}}}}'
```

The agent's happy path for a new organization: `enable_containers` → `create_ecs_credential`
(hand the user the portal link; they paste the pair into `~/.aws/credentials`) →
`get_containers_connection_guide` (write the `[profile aireserve]` block into
`~/.aws/config`) → `aws ecs list-clusters --profile aireserve` → `deploy_container_service`.

## Completing a confirmation

Any operation marked *after confirm* returns a `confirmToken` on the first call. After a
human approves the returned `summary`, repeat the identical call with the token added
alongside the proposal:

```shell confirm-retry theme={"dark"}
curl https://api.aireserve.com/mcp \
  -H "Authorization: Bearer $AIRESERVE_MCP_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"members-action","arguments":{"proposal":{"action":"set_member_active","input":{"userId":"<user-uuid>","active":false}},"confirmToken":"<confirmToken-from-step-1>"}}}'
```

The token binds the exact operation, input, and caller the human saw; it expires after 10
minutes, and if the target row changed in between, execution refuses with a fresh summary
to re-approve.

## Not on this surface

By design, the MCP server never exposes:

* **Platform (cross-tenant) operations** — funding client wallets, wallet enforcement
  toggles, ledger syncs, sign-in-domain registration, cross-org lookups. Super admins are
  de-escalated to their own tenant here; platform work stays in the portal.
* **Secrets in responses** — key material and signed download URLs only ever render in the
  signed-in portal via [redemption links](/connect/mcp#consent-and-secrets).
* **Impersonation** and **file-byte uploads** — both remain portal page flows.
* **Prompt/response content** — analytics reads return request metadata only.


# Microsoft Office
Source: https://docs.aireserve.com/connect/microsoft-office

Deploy Anthropic's Claude add-in through AI Reserve in Excel, PowerPoint, and Word, or use GPT for Work, Office Scripts, and Power Automate.

There are several distinct Microsoft integrations. Choose the one that matches
where you want Claude to run:

* **Anthropic's Claude for Microsoft 365 add-in** puts Claude directly inside
  Excel, PowerPoint, and Word. An organization admin deploys one manifest and
  employees just open Claude, with usage billed to the organization's AI Reserve account.
* **GPT for Work** is a separate third-party add-in for Word and Excel. It
  accepts an AI Reserve API key and an OpenAI-compatible endpoint.
* **Office Scripts** and **Power Automate** are do-it-yourself automation
  options that call the OpenAI-compatible API.
* **Microsoft Copilot** is Microsoft's own product. Its model connection cannot
  be redirected to AI Reserve.
* The **Microsoft 365 connector** lets Claude access Outlook, SharePoint,
  OneDrive, and Teams. It does not install Claude inside Office.

## Anthropic's Claude for Microsoft 365 add-in

Anthropic's official
[Claude for Microsoft 365 add-in](https://claude.com/docs/office-agents/third-party-platforms)
runs inside Excel, PowerPoint, and Word. AI Reserve organization admins can
generate a ready-to-deploy manifest from the
[Office deployment page](https://portal.aireserve.com/connect/microsoft-office).
Each download automatically creates a dedicated organization API key and embeds
it in the XML. Employees just open Claude; they do not need to paste a key or
complete a Microsoft Entra sign-in or consent flow for the gateway connection.

Usage is shared at the organization level, not attributed to individual employee
identities, and follows the organization's normal AI Reserve billing and policies.
Earlier download keys stay active until an administrator explicitly revokes them
in the selected organization's **API Keys** page, linked from the deployment page.
Downloading again does not rotate or revoke an existing deployment's key.

### Deploy the default organization-credential manifest

You need an AI Reserve enterprise administrator for the organization (or a super
administrator who selects it), Microsoft 365 administrator access to deploy the
add-in, and Office licenses for the assigned users. The AI Reserve environment
must have `GATEWAY_BASE_URL` configured. Microsoft tenant verification and
`OFFICE_ENTRA_*` configuration are **not** prerequisites for this download.

**1. Choose your AI Reserve organization**

Open the [Office deployment page](https://portal.aireserve.com/connect/microsoft-office). Enterprise administrators
are scoped to their organization; super administrators select the organization whose account will cover usage.

**2. Download the manifest**

Select **Download Office manifest**. AI Reserve creates a dedicated organization key automatically and returns the
configured XML. Keep version `1.0.0.2` for a first deployment. When replacing an installed add-in, use a version
higher than its installed version: Microsoft 365 caches add-ins by ID and version.

**3. Deploy from Microsoft 365 Admin Center**

Open **Settings → Integrated apps → Upload custom apps**, choose **Office Add-in**, upload the XML, and assign a
pilot group or the whole organization. Microsoft says propagation can take up to 24 hours.

**4. Open Claude and verify usage**

After deployment, open **Home → Add-ins** in Excel, PowerPoint, or Word and launch **Claude**. The add-in connects
automatically. Test a workbook edit, a document edit, and a presentation edit, then confirm the selected
organization's usage and charges before broad deployment.

> [!NOTE]
>
> The XML contains an organization credential: treat it like an API key and share it only with trusted deployment
> administrators and assigned users. To replace a credential, deploy a new download with a higher version, verify it
> works, then revoke the old key in **API Keys**. Revoking a key stops deployments that still use it.

One manifest covers Excel, PowerPoint, and Word. Outlook uses a different
Microsoft `MailApp` schema and therefore needs a separate Anthropic manifest;
the AI Reserve deployment page intentionally does not generate or deploy the
Outlook add-in.

### What the default manifest configures

The page starts from Anthropic's current canonical manifest and uses its
[documented static gateway configuration](https://github.com/anthropics/financial-services/blob/main/claude-for-msft-365-install/commands/manifest.md):

* `gateway_url=https://api.aireserve.com` (or the configured gateway for your environment)
* `gateway_api_format=anthropic`
* `gateway_token=<dedicated-organization-key>` in the task-pane URL's `#` fragment, not its query string
* `gateway_auth_header=authorization`
* `auto_connect=1`
* an Office client marker for usage attribution

The gateway URL uses the host root because the add-in speaks Anthropic's native
`/v1/messages` format. Fragment placement does not make the XML secret-free: anyone
with the XML can read its credential. The default download does **not** enable
Entra SSO, employee identity attribution, bootstrap, or automatic MCP registration.
Anthropic's static gateway mode requires no Entra consent.

> [!NOTE]
>
> This admin manifest configures the add-in but is not a network policy. Organizations that require a hard route through
> AI Reserve should also enforce approved egress and identity at their network boundary.

### Optional legacy Entra identity setup

The deployment page retains **Optional Microsoft identity setup** for existing
Entra-based integrations. It is independent of the default organization-credential
download: connecting a tenant, granting consent, or configuring the settings below
does not switch the downloaded XML to employee sign-in. The current default
download does **not** generate an Entra-authenticated manifest.

In the separate legacy flow, an Entra-configured manifest requests an employee's
Microsoft access token as the gateway credential and uses
`bootstrap_url=https://api.aireserve.com/office/bootstrap`. Its bootstrap response
can register AI Reserve's remote MCP server, which each employee authorizes
separately through OAuth; inference credentials never gain MCP management
permissions. These identity and MCP behaviors do not apply to the default static
credential mode.

The following technical setup and acceptance checks are only for operators
maintaining that separate Entra flow.

#### Platform setup: Entra application metadata

AI Reserve operators configure one multitenant application in a company-owned
Microsoft Entra workforce tenant. Do not host the production registration in an
expiring developer sandbox. No Microsoft client secret, employee password, or
provider key is needed for this user-token verification flow.

In **Entra ID → App registrations → New registration**, choose accounts in any
organizational directory. For the simplest setup, use one registration for the
Office client and its resource API:

* Copy **Application (client) ID** from **Overview**, not **Object ID** or **Directory (tenant) ID**.
* Under **Expose an API**, set the Application ID URI to `api://<application-id>`
  and add the admin-consent-enabled delegated scope `access_as_user`.
* Configure the resource API to issue v2 access tokens (`api.requestedAccessTokenVersion: 2`
  in the Microsoft Graph-format application manifest).
* Under **API permissions**, add that exposed scope as a delegated permission.
* Under **Authentication → Single-page application**, register
  `brk-multihub://pivot.claude.ai` and `https://pivot.claude.ai/msal-redirect.html`.
* Register the admin-consent return URL `${APP_URL}/connect/microsoft-office`
  under **Web**, matching the web service's deployed `APP_URL` exactly. Production
  deploys use `https://portal.aireserve.com/connect/microsoft-office`. UAT requires
  its own exact portal return URL.
* To enable **Connect with Microsoft** (the one-click admin sign-in that derives
  and verifies the tenant), register `${APP_URL}/api/office/signin/callback` for
  each environment under **Mobile and desktop applications**, and turn on **Allow
  public client flows** under **Authentication → Advanced settings**. The flow is
  a secretless server-side authorization-code + PKCE exchange, so a **Web**
  redirect (which expects a client secret) or an **SPA** redirect (cross-origin
  only) will be rejected by Microsoft. Then set `OFFICE_ENTRA_SIGNIN_ENABLED=true`
  in that environment's `deploy-config/<environment>.env`. The sign-in targets the
  `/organizations` endpoint, so only workforce (Entra) tenants — not personal
  Microsoft accounts — can complete it. Leave the flag unset to keep manual entry.

Set these **public configuration values**, not Secret Manager credentials, in
`apps/web/deploy-config/<environment>.env`; both the web and gateway deploy scripts
read this file:

```dotenv theme={"dark"}
OFFICE_ENTRA_CLIENT_ID=<application-id-guid>
OFFICE_ENTRA_AUDIENCE=<application-id-guid>
OFFICE_ENTRA_REQUIRED_SCOPE=access_as_user
```

Microsoft v2 access tokens use the resource API's **bare GUID** as `aud`, while
consent and the Office manifest request `api://<audience-guid>/access_as_user`.
Never put `api://` in `OFFICE_ENTRA_AUDIENCE`. With separate client and API
registrations, `CLIENT_ID` identifies the calling app (`azp`), and `AUDIENCE`
identifies the API (`aud`); the generated scope uses the API's GUID. This setup
requires the resource API's default `api://<audience-guid>` Application ID URI;
custom resource URIs are not supported by these settings.

Before activation, verify migration `0082` is applied, deploy both services through
the normal environment deployment process, and confirm the manifest's gateway and
bootstrap URLs target that same environment. Keep all three settings empty until
registration is ready. Pre-create pilot users in the correct AI Reserve organization
with matching Microsoft sign-in emails; validate real sign-in, Office edits,
usage attribution, token renewal, and policy enforcement before production rollout.

See [Microsoft's token claims reference](https://learn.microsoft.com/en-us/entra/identity-platform/access-token-claims-reference)
and [Anthropic's third-party Office deployment guide](https://claude.com/docs/office-agents/third-party-platforms).

#### Legacy Entra pilot acceptance

An Entra application showing **Activated**, or a successful default manifest
download, does not validate the separate Entra integration. For an independently
configured Entra-authenticated manifest, first confirm:

* The configured web and gateway revisions are serving traffic in the same environment.
* The pilot tenant is ownership-verified and the employee has an active AI Reserve
  account in that organization, with a matching Microsoft sign-in email and usable balance.
* Microsoft 365 licenses or a trial provide the Office hosts; an Azure/Entra account
  alone does not license Excel, Word, or PowerPoint.
* Real Microsoft sign-in yields bootstrap 200 and a non-empty allowed model list.
* A synthetic workbook edit succeeds; repeat with a document and presentation before
  advertising all three hosts. Verify the resulting employee, organization, and cost attribution.
* Token renewal works and blocked models/integrations or exhausted spending allowances fail as intended.
* AI Reserve MCP, if enabled for the pilot, authorizes separately through OAuth.

The admin-consent return message is informational, not proof of consent or tenant
ownership: its query parameters can be edited by a browser user. Confirm consent
in Microsoft Entra and validate it by signing in to the installed add-in.
Publisher verification is a separate Microsoft process recommended before wider
customer rollout; customer consent/security policies may require it.

#### Manage legacy tenant connections

Under **Optional Microsoft identity setup** on the
[Office deployment page](https://portal.aireserve.com/connect/microsoft-office),
use **Connect with Microsoft** when configured to derive and verify the directory
from an administrator's sign-in. Alternatively, enter the Directory (tenant) ID
manually. An authenticated enterprise administrator's connection is activated
immediately, and AI Reserve emails the organization's enterprise administrators so
an unexpected connection can be reviewed and disconnected.

For the legacy identity flow, select **Grant consent** after connecting the tenant
and have its Microsoft administrator approve AI Reserve's application. Validate
that flow with its separately configured Entra manifest and the checks above—not
with the default organization-credential download.

## Word and Excel — GPT for Work add-ins

[GPT for Excel](https://gptforwork.com/docs/gpt-for-excel/setup/manage-models/connect-to-api-endpoints)
and [GPT for Word](https://gptforwork.com/docs/gpt-for-word/setup/manage-models/connect-to-api-endpoints)
(Talarian's **GPT for Work** suite) are the leading Office add-ins that
connect to any OpenAI-compatible endpoint. A space owner or admin configures
the endpoint once in the
[GPT for Work dashboard](https://gptforwork.com/docs/admin/ai-configuration/manage-api-endpoints)
— **Custom API endpoints** in the sidebar — and every user in the space gets
the gateway models. Custom endpoints require their Business or Enterprise plan
or pay-as-you-go pricing.

There are two endpoint types, on separate tabs:

* **Bulk models** (Excel and Word) — the Chat Completions path, used by bulk
  prompting and the spreadsheet functions. Add an **OpenAI-compatible endpoint
  (Chat Completions API)** with:

  * **Endpoint URL**: `https://api.aireserve.com` — host root, no `/v1`
    (unlike most tools in these guides: GPT for Work appends the
    `/v1/models` and `/v1/chat/completions` resource paths itself, so a
    `/v1` suffix here would double up).
  * **API key**: your `aireserve_api_…` key.
  * **Display name** (optional): e.g. `AI Reserve` — prefixed to model names
    in the model switcher (`custom/` by default).

  Click **Check** — the add-in validates the connection — then **Save**. The
  switcher then lists the gateway's full catalog under **Connected models**
  (`/v1/models` is the discovery call — it excludes client-exclusive models
  but does include consent-gated ones, so a model your org hasn't opted into
  will list here and refuse at call time with the reason).

* **Agent models** (Excel only) — the agent sidebar, which drives the
  workbook. Add an **OpenAI-compatible endpoint (Responses API)** with the
  same Endpoint URL and key, plus a model ID copied from the gateway catalog.
  GPT for Work requires the endpoint to serve `/v1/responses` over public
  HTTPS and the model to have at least a 32K-token context — the gateway serves the
  [Responses format](/connect/codex) for every model, and the flagship models
  all clear the context bar.

> [!NOTE]
>
> **Why this just works.** GPT for Work runs inside Office's embedded browser, so it calls the endpoint straight from
> the client — which is why it requires public HTTPS and CORS support. The gateway has both (it answers cross-origin
> browser requests on `/v1/models`, `/v1/chat/completions`, and `/v1/responses`), so both endpoint types validate as-is.
> No proxy, no relay.

GPT for Work covers Word and Excel only. There is no PowerPoint add-in in the
suite, and we haven't found a comparably mature PowerPoint add-in with a
custom-endpoint field — only small open-source projects. For slides, the
practical route today is drafting in Word or [chat](https://chat.aireserve.com)
and pasting across.

## Excel — Office Scripts

Office Scripts can call the gateway directly with `fetch`
([external calls are supported](https://learn.microsoft.com/en-us/office/dev/scripts/develop/external-calls)
when the script runs in the Excel application). This script reads the prompt
from `A1` and writes the answer to `B1`:

> [!WARNING]
>
> Office Scripts have no secret store — the key sits in the script text, and anyone who can open or edit the workbook
> can read it. Mint a dedicated, spend-capped key for workbook scripts and rotate it if the file is shared.

```typescript theme={"dark"}
interface ChatCompletion {
  choices: { message: { content: string } }[];
}

async function main(workbook: ExcelScript.Workbook) {
  const sheet = workbook.getActiveWorksheet();
  const prompt = String(sheet.getRange("A1").getValue());

  const response = await fetch("https://api.aireserve.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: "Bearer aireserve_api_...", // your key
    },
    body: JSON.stringify({
      model: "gpt-5.4-mini",
      messages: [{ role: "user", content: prompt }],
    }),
  });

  if (!response.ok) {
    // 401/403/429/402 return an OpenAI error body — surface it instead of
    // failing later on a missing field.
    throw new Error(`Gateway error ${response.status}: ${await response.text()}`);
  }

  const completion: ChatCompletion = (await response.json()) as ChatCompletion;
  sheet.getRange("B1").setValue(completion.choices[0].message.content);
}
```

Two boundaries, both Microsoft's:
[external calls fail when a script runs through Power Automate](https://learn.microsoft.com/en-us/office/dev/scripts/develop/external-calls#external-calls-from-power-automate)
(`fetch is not defined` at runtime — use the Power Automate path below
instead), and scripts stored on SharePoint can't make external calls at all.
Tenant admins can also block external calls outright, so if the snippet fails
on a managed machine, ask IT before debugging.

## Power Automate

For flows, skip Office Scripts and call the gateway from the flow itself —
that's
[Microsoft's own guidance](https://learn.microsoft.com/en-us/office/dev/scripts/develop/external-calls#external-calls-from-power-automate).
Add an **HTTP** action:

| Field | Value |
| - | - |
| Method | `POST` |
| URI | `https://api.aireserve.com/v1/chat/completions` |
| Headers | `Authorization`: `Bearer aireserve_api_…` · `Content-Type`: `application/json` |
| Body | `{ "model": "gpt-5.4-mini", "messages": [{ "role": "user", "content": "…" }] }` |

Pull the reply out with the expression
`body('HTTP')?['choices']?[0]?['message']?['content']` and hand it to any
Office connector — write it to Excel rows, draft Outlook mail, fill a Word
template. HTTP actions are
[premium-class connectors in Power Automate](https://learn.microsoft.com/en-us/connectors/webcontentsv2/),
so the flow owner needs a
[Power Automate Premium license](https://learn.microsoft.com/en-us/power-platform/admin/power-automate-licensing/types).
Store the key in a secured environment variable or Azure Key Vault rather
than inline.

## Microsoft 365 connector — separate from the add-in

Claude's
[Microsoft 365 connector](https://support.claude.com/en/articles/12542951-set-up-the-microsoft-365-connector)
connects Claude to Outlook, SharePoint, OneDrive, and Teams through Microsoft
Graph. It is useful when Claude needs to search or act on organization data,
but it does **not** put a Claude task pane inside Excel, PowerPoint, or Word.

The connector has its own Entra service principals, admin consent, and
permissions. It does not use the Office XML manifest, the GPT for Work API
key, Office Scripts, or Power Automate configuration described above. Deploy
the official add-in and the connector independently if your organization needs
both experiences.

## Microsoft Copilot — the boundary

Microsoft 365 Copilot (now named simply **Microsoft Copilot**) cannot be
pointed at a third-party endpoint. Its models are
[chosen, hosted, and operated by Microsoft](https://learn.microsoft.com/en-us/microsoft-365/copilot/microsoft-365-copilot-application-card)
— Azure OpenAI Service, plus Anthropic and OpenAI models under Microsoft's
subprocessor arrangements — and the product has no base-URL or API-key
setting anywhere, so there is nothing to configure. A gateway can't serve a
request Copilot never sends.

Microsoft's extensibility story —
[custom engine agents](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/overview-custom-engine-agent)
via Copilot Studio or the Microsoft 365 Agents SDK — lets an organization
bring its own agent (and behind it, its own models) *into* the Copilot UI.
That's a build-and-host-a-bot surface, not a paste-a-key setting, and it's
out of scope for this guide.

***

The default official Claude add-in deployment uses a shared organization key and
is attributed to **Claude for Office** in usage analytics, not to individual
employee identities. Each manifest download creates its own dedicated key. For
the other key-based integrations, mint a dedicated key per surface (one for the
GPT for Work space, one per flow) to keep spend and revocation separate.


# OpenAI SDK
Source: https://docs.aireserve.com/connect/openai-sdk

Point the official openai package — or any OpenAI-compatible framework — at the gateway with a base-URL swap.

Keep the official `openai` package: change the base URL, use your AI Reserve API key,
and every gateway model — not just GPT — answers the same call.

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",  # note the /v1 suffix
    api_key=os.environ["AIRESERVE_API_KEY"],
)

# Works with GPT models — and with Claude/Gemini/... model IDs too.
res = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "hello"}],
)
print(res.choices[0].message.content)

# Streaming works unchanged too:
for chunk in client.chat.completions.create(
    model="claude-sonnet-4-6",  # cross-provider: Claude via the OpenAI SDK
    messages=[{"role": "user", "content": "hello"}],
    stream=True,
):
    # The final chunk carries usage and an empty `choices` list.
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1", // note the /v1 suffix
  apiKey: process.env.AIRESERVE_API_KEY,
});

// Works with GPT models — and with Claude/Gemini/... model IDs too.
const res = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "hello" }],
});
```

## Fallback models

Send an ordered list and the gateway tries the next model when the one before
it fails. `models` is shorthand for `model` + `fallbacks`; the Python SDK takes
gateway extensions through `extra_body`.

```python theme={"dark"}
res = client.chat.completions.create(
    model="claude-fable-5-1",
    messages=[{"role": "user", "content": "hello"}],
    extra_body={"fallbacks": ["gpt-6-astra", "kimi-k3-fireworks"]},
)
```

Which model answered, how entries are policy-checked, and how this interacts
with your organization's portal defaults: [Fallback models](/capabilities/fallbacks).

## Vercel AI SDK (and other OpenAI-compatible providers)

```typescript theme={"dark"}
import { createOpenAI } from "@ai-sdk/openai";
import { streamText } from "ai";

const aireserve = createOpenAI({
  baseURL: "https://api.aireserve.com/v1", // /v1 suffix
  apiKey: process.env.AIRESERVE_API_KEY,
});

const result = streamText({
  model: aireserve.chat("gpt-4o-mini"),
  prompt: "hello",
});
```

Migrating an existing OpenAI codebase? The [Migrating from OpenAI](/migrate/from-openai)
guide covers the full concept mapping — keys, error shapes, and what carries over verbatim.


# OpenCode
Source: https://docs.aireserve.com/connect/opencode

Add the AI Reserve gateway to OpenCode as a custom provider — one JSON block, every gateway model.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — every OpenCode session is then
> metered and billed through your organization.

OpenCode takes custom providers in `opencode.json` — globally at
`~/.config/opencode/opencode.json` or per project
([OpenCode's provider docs](https://opencode.ai/docs/providers/)). One
OpenAI-compatible block serves every gateway model, Claude included:

```json theme={"dark"}
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "aireserve": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "AI Reserve",
      "options": {
        "baseURL": "https://api.aireserve.com/v1",
        "apiKey": "{env:AIRESERVE_API_KEY}"
      },
      "models": {
        "gpt-5.4-mini": { "name": "AI Reserve GPT-5.4 Mini" },
        "claude-sonnet-4-6": { "name": "AI Reserve Claude Sonnet 4.6" }
      }
    }
  }
}
```

The `{env:…}` reference keeps the secret out of the file — export the key and
run:

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_…"   # your key
opencode                                     # models appear under "AI Reserve"
```

Model ids in the `models` map must match the gateway's ids exactly — the
list is one `GET https://api.aireserve.com/v1/models` away.

## Verify

Run a one-shot prompt against the provider you just added:

```bash theme={"dark"}
opencode run -m aireserve/gpt-5.4-mini "Reply with exactly: gateway-ok"
```

The reply streams back through the gateway, and the request appears on your
[Spend page](https://portal.aireserve.com/spend) — metered against your
key.


# OpenHands
Source: https://docs.aireserve.com/connect/openhands

Run the OpenHands CLI and agent server on the AI Reserve gateway with three LLM_* environment variables.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — every OpenHands agent step is
> then metered and billed through your organization.

OpenHands routes all model traffic through LiteLLM, so the gateway plugs in
with the standard three variables
([OpenHands custom-endpoint docs](https://docs.openhands.dev/openhands/usage/llms/local-llms)).
The `openai/` prefix on the model id means "OpenAI-compatible endpoint" — it
routes Claude models too:

```bash theme={"dark"}
export LLM_MODEL="openai/gpt-5.4-mini"              # or openai/claude-sonnet-4-6
export LLM_BASE_URL="https://api.aireserve.com/v1"  # /v1 suffix
export LLM_API_KEY="$AIRESERVE_API_KEY"             # your aireserve_api_… key
```

Install the CLI and run a task headlessly (`uv tool install openhands`, or
`pipx install openhands`):

```bash theme={"dark"}
openhands --headless --override-with-envs -t "write a hello-world script"
```

> [!NOTE]
>
> **`--override-with-envs` is required.** Without it the CLI ignores the
> `LLM_*` variables in favor of `~/.openhands/` settings — and on a fresh
> install it waits for the interactive first-run wizard instead. Interactive
> sessions (`openhands` with no flags) can also set the same three values in
> the settings UI: Custom Model, Base URL, API Key.

The Docker GUI takes the same three variables as `-e LLM_MODEL=…`,
`-e LLM_BASE_URL=…`, `-e LLM_API_KEY=…` on `docker run`.

## Verify

Run the headless one-liner above from an empty directory. The agent completes
the task and exits, and each LLM step appears on your
[Spend page](https://portal.aireserve.com/spend) — one request per agent
turn, all metered against your key.


# Roo Code
Source: https://docs.aireserve.com/connect/roo-code

Connect Roo Code's VS Code agent to the AI Reserve gateway with the OpenAI Compatible provider.

> **[Create your API key →](https://portal.aireserve.com/keys)**
>
> Mint an `aireserve_api_…` key in the portal — every Roo Code request is then
> metered and billed through your organization.

Roo Code configures providers per profile inside VS Code
([Roo's OpenAI-compatible guide](https://docs.roocode.com/providers/openai-compatible)).
Open **Roo Code → Settings (gear icon) → Providers** and set:

| Field | Value |
| - | - |
| API Provider | `OpenAI Compatible` |
| Base URL | `https://api.aireserve.com/v1` |
| API Key | your `aireserve_api_…` key |
| Model | `gpt-5.4-mini` (or any gateway model) |

Claude models work through the same OpenAI Compatible entry
(`claude-sonnet-4-6` as the model id) — the gateway bridges them. If you
prefer Roo's native **Anthropic** provider instead, enable its custom base
URL option and use the **host root** `https://api.aireserve.com` (no `/v1`;
Roo appends `/v1/messages` itself).

> [!NOTE]
>
> **Streaming usage chunks are served.** Roo Code requests
> `stream_options: {"include_usage": true}` and reads the final usage chunk
> to price each request in its context bar. The gateway returns that chunk on
> streamed completions, so Roo's token and cost tracking work as they do
> against first-party endpoints.

## Verify

Start any task in Roo Code (for example, "explain this file") and watch it
stream. The request appears on your
[Spend page](https://portal.aireserve.com/spend) seconds later — metered
against the key in the profile you just configured.


# Slack
Source: https://docs.aireserve.com/connect/slack

Mention @aireserve in any channel — every gateway model, no keys to paste. On us in your shared channel with AI Reserve; metered to your wallet in your own workspace.

Your whole model catalog, right where your team already talks. Mention
**`@aireserve`** in a channel and it answers in a thread — the gateway picks
the best model for the request (or you name one), and each answer footnotes
which model served it. No API keys in Slack, no per-seat AI subscriptions.
In the shared channel with the AI Reserve team the usage is on us; in your
own workspace it meters to your organization's wallet like any API call.

```text theme={"dark"}
@aireserve what's our wallet balance and what did we spend this month?

@aireserve how do we set an IP allowlist on a key?

@aireserve summarize this thread and draft a reply

@aireserve claude-opus-5 write the migration plan for the schema above

@aireserve use deepseek: explain this stack trace
```

## What you get

* **It knows your account.** In the shared channel with the AI Reserve
  team, ask it about your organization and it looks the answer up for you:
  wallet balance, spend this month and the models behind it, which API keys
  exist (names only, never the secret), which models you can use and what
  they cost, and any recent errors on your traffic. It only ever sees your
  own organization's data.
* **It has read the docs.** How-to questions ("how do I connect Claude
  Code?", "how do I rotate a key?") come back with the answer and a link to
  the exact documentation page.
* **Every model, one mention.** The same model catalog as the API. No
  model named? The gateway's [auto-router](/models) picks the right one for
  the request. Name one — an exact id like `claude-opus-5` or plain prose
  like "use deepseek" — and that model serves it.
* **Answers in threads, with receipts.** Replies land in a thread on your
  message, and every answer ends with `served by <model>` so there's never a
  question of what ran. (Error notes skip the footer — nothing ran.)
* **It keeps up with the conversation.** Mention it inside a thread and it
  reads the recent discussion before answering — and once it has replied in
  a thread, you can keep asking follow-ups there without tagging it again.
* **On us in the shared channel.** In the Slack Connect channel you share
  with the AI Reserve team, the assistant is provided at no charge: nothing
  meters to your organization's wallet, and each answer there says so in
  its footer. In a workspace you install the app into, mentions meter to
  your wallet at normal model rates, attributed to the Slack user who asked.
* **Your model catalog still applies.** The bot only serves models your org
  has enabled — naming one it hasn't gets an honest note with real options,
  never a quietly substituted model. Busy channels are rate-limited so one
  thread can't monopolize it.

## Two ways to connect

> **Install in your workspace**
>
> An org admin installs the AI Reserve app into your Slack workspace from
> the portal. Once linked, invite `@aireserve` to any channel — public or
> private — and everyone in it can use it.

> **Shared channel with us**
>
> Already have a Slack Connect channel with the AI Reserve team? Mention
> `@aireserve` right there — we link the channel to your org during
> onboarding, nothing to install.

### Installing in your own workspace

1. An **AI Reserve org admin** starts the install from the portal — the
   install link is minted for your organization, so the workspace binds to
   your org and nobody else's.
2. Approve the app in Slack (a Slack workspace admin may need to allow it).
3. **Invite the bot** to the channels where you want it:
   `/invite @aireserve`.
4. Mention it. That's the whole setup — keys and model access ride the link
   to your org, and usage meters to your org's wallet at normal model rates.

> [!NOTE]
>
> The app only answers in workspaces linked to an AI Reserve organization.
> If it's installed but not linked, it replies with a short note instead of
> serving — the link is what decides whose model catalog applies.
> Uninstalling the app severs the link and revokes its workspace credentials
> immediately.

## Mentioning the bot

The mention can sit anywhere in the message — leading, trailing, or
mid-sentence — and the rest of the message is the question:

```text theme={"dark"}
@aireserve what does this error mean?

where does this config live @aireserve

hey @aireserve can you sanity-check the math above
```

Tagging teammates in the same message is fine — their mentions are read as
part of the question ("what did @alex mean here?"), not as commands. While
the bot is working it marks your message with a 👀 reaction, which clears
when the answer posts.

## Picking a model

| You write | What serves |
| - | - |
| `@aireserve <question>` | The gateway auto-router picks the best model for the request |
| `@aireserve claude-opus-5 <question>` | Exactly `claude-opus-5` (exact id as the first word) |
| `@aireserve use deepseek: <question>` | The catalog's matching DeepSeek model |
| `@aireserve using grok 4.5, <question>` | The model reference is understood mid-prose — here `grok-4-5` |
| `@aireserve use sonnet to <task>` | A bare family name picks that family's current model from your org's catalog |
| `@aireserve use a cheaper model: <question>` | Stays on the auto-router — cost/speed trade-offs are its job — and the reply footer adds a tip showing how to name a model |

Two honesty rules back all of this:

* **The footer never lies.** Every answer ends with `served by <model>`,
  naming the model that actually ran — whichever path chose it, including
  the auto-router's pick.
* **No silent substitutes.** A model ask that can't be served is answered
  honestly instead of quietly serving a different model that role-plays the
  one you asked for: a leading ask that names a model family we carry at a
  version we can't serve ("use grok-9 …"), or an exact id that isn't in
  your org's catalog, gets real options to pick from. A mid-prose reference
  we can't recognize as a model at all is treated as ordinary text and the
  question auto-routes — the footer still names what actually ran.

## Threads and follow-ups

**Mention it in a thread and it reads the thread.** The recent conversation
rides along as context, and the answer lands in the same thread — no forked
side-threads. Mention it top-level and the reply starts a thread under your
message.

**Keep talking — no re-tagging needed.** Once the bot has replied in a
thread, plain follow-up messages there ("is this an easy fix?", "what about
the second option?") get answered without another `@aireserve`. It is
deliberately conservative about when it speaks up uninvited:

* It only follows threads **where it has already replied** — never
  conversations it was not part of.
* It stays silent when your message **tags any person by name** — tagging
  a teammate makes it their conversation, and tagging the bot is just a
  normal mention.
* Only plain, human-written messages qualify — never bots, message edits,
  or system messages.
* Whenever it can't be sure a follow-up is meant for it, it stays quiet —
  and it never posts busy/error chatter into a thread over a message that
  didn't tag it (in a briefly rate-limited channel, a follow-up is simply
  dropped). A fresh `@aireserve` always works.

In a follow-up, name a model in prose — "use opus to redo that". A bare
model id at the start of a follow-up reads as ordinary text, because the
message wasn't addressed to the bot.

> [!NOTE]
>
> Follow-ups and the 👀 reaction use newer Slack permissions. If they don't
> appear and the app is installed in **your own workspace**, an AI Reserve
> org admin can reinstall from the portal (your org's admin page → Add to
> Slack) — one click, nothing else changes. In a **shared channel** with
> the AI Reserve team, just tell us and we'll refresh it on our side.

## Formatting and replies

Answers render as native Slack formatting — bold, code blocks, bullets, and
links the way Slack draws them, not raw Markdown syntax. Replies are kept
chat-length and conversational rather than report-length, with enough
headroom for reasoning models to think before they write.

When a mention runs into trouble, the bot says so in plain language instead
of going quiet (unprompted follow-ups prefer silence — see above):

* **Model not available** — a model your org hasn't enabled gets an honest
  note with real options to pick from (or tag without a model id and let the
  auto-router choose).
* **Provider trouble** — when a model's provider is having an outage, the
  bot says that and suggests retrying or dropping the model id.
* **Busy or slow** — rate-limited channels and timed-out generations get a
  short "try again" note.
* **Nothing came back** — if a model burns its whole budget thinking or a
  provider safety filter blocks the output, the bot says exactly that
  (still with the `served by` footer — the model did run).

## Billing and privacy

Where the mention happens decides who pays. In the Slack Connect channel
you share with the AI Reserve team, the assistant is on us: nothing meters
to your wallet, no spend cap is consumed, and every answer there carries a
short footer saying so. In a workspace you installed the app into, mentions
meter to your organization's wallet at normal model rates and appear in your
usage analytics, attributed to the Slack user who asked; if your wallet runs
dry the bot says so plainly. Your org's model catalog decides which models
it can name in both places.

Message content passes through the gateway to the serving model exactly like
an API call — see [Data & privacy](/trust/data-privacy) for the full
data-handling posture.


# Zed
Source: https://docs.aireserve.com/connect/zed

Run Zed's agent panel and inline assistant through the AI Reserve gateway with one language_models block in settings.json.

> **[Connect Zed with a guided setup →](https://portal.aireserve.com/connect/zed)**
>
> The guided connect page mints your key, lets you pick models from the live
> catalog, and generates the exact `settings.json` block below for them —
> then confirms the moment your first request arrives.

Everything below is the manual equivalent.

Zed reads custom providers from `settings.json` under
`language_models.openai_compatible`
([Zed's OpenAI-compatible provider docs](https://zed.dev/docs/ai/llm-providers#openai-api-compatible)).
One `aireserve` entry pointed at the gateway's OpenAI surface serves every
gateway model — Claude models included, since the gateway bridges them —
with streaming, tool calls, and image input intact.

## 1. Merge the settings block

Open `settings.json` (in Zed press `⌘,` or run **zed: open settings**) and
merge this block. If you already have a
`language_models` section, add the `aireserve` entry inside it:

```json theme={"dark"}
{
  "language_models": {
    "openai_compatible": {
      "aireserve": {
        "api_url": "https://api.aireserve.com/v1",
        "available_models": [
          {
            "name": "claude-sonnet-4-6",
            "display_name": "Claude Sonnet 4.6",
            "max_tokens": 1000000,
            "max_output_tokens": 128000,
            "capabilities": { "tools": true, "images": true }
          },
          {
            "name": "claude-fable-5",
            "display_name": "Claude Fable 5",
            "max_tokens": 1000000,
            "max_output_tokens": 128000,
            "capabilities": { "tools": true, "images": true }
          },
          {
            "name": "gpt-5.4-mini",
            "display_name": "GPT-5.4 Mini",
            "max_tokens": 400000,
            "max_output_tokens": 128000,
            "capabilities": { "tools": true, "images": true }
          }
        ]
      }
    }
  }
}
```

Add any other gateway model the same way — `name` is the gateway model id
(see [Models](/models)), and Zed requires `max_tokens` (the model's context
window) on every entry. `max_output_tokens` and `capabilities` are optional;
the guided page fills all three from the catalog for the models you pick.

> [!NOTE]
>
> **Keep the `/v1` suffix on `api_url`.** Zed appends `/chat/completions` to
> it — without `/v1` every request 404s.

## 2. Give Zed your key

The settings block deliberately holds no secret — Zed never reads API keys
from `settings.json`, so the block is safe to commit to dotfiles. Provide the
key one of two ways:

* **In Zed:** open the agent panel, choose **Settings** (or run **agent: open
  settings**), find the `aireserve` provider you just added, and paste your
  `aireserve_api_…` key. Zed stores it in its credential store.
* **From the shell:** Zed derives the env var from the provider id
  (uppercase + `_API_KEY`), which lands exactly on the gateway's convention:

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # your key
```

Restart Zed after exporting so it picks the variable up.

## Verify

Open the agent panel, pick an AI Reserve model in the model selector, and send
any message. The reply streams back through the gateway, and the request
appears on your [usage page](https://portal.aireserve.com/profile) seconds
later — metered and billed to your organization's wallet.

## Changing models later

Rerun the [guided page](https://portal.aireserve.com/connect/zed) with a
different selection and paste the fresh block over the `aireserve` entry, or
edit `available_models` by hand. Revoking the key from your
[API keys](https://portal.aireserve.com/keys) cuts Zed off immediately.


# Repoint Amazon ECS to AI Reserve
Source: https://docs.aireserve.com/containers/ecs

Four client settings move an existing ECS setup onto AI Reserve. Every command, SDK call, task definition, and deploy script stays as it is.

Four settings, no code changes. Whatever you use to drive ECS today — the AWS
CLI, a shell script, boto3, the JavaScript, Go, or Java SDK, Terraform — takes
these and keeps working:

| Setting | Value | Notes |
| - | - | - |
| ECS endpoint | `https://api.aireserve.com` | Set it for the **ECS service**, plus EC2 and CloudWatch Logs if you want the [read-only lookups](#network-ids-and-logs) below; other AWS services keep their normal endpoints. |
| `aws_access_key_id` | your ECS credential's access key id (`AIRA…`, 20 characters) | Create one in the portal under **Containers & Orchestration › Elastic Container Service › Create credential**, or let your coding agent mint it over [MCP](/connect/mcp-tools#containers-containers-query-containers-action). |
| `aws_secret_access_key` | its secret access key (40 characters) | Shown once when the credential is created. Signs every request, exactly as an AWS secret does. |
| region | a real AWS region, e.g. `us-east-1` | Where your clusters, services, and tasks run. Use the one your resources are in. |

**The pair works like an AWS one.** Every AWS SDK signs requests with SigV4
and puts the access key id in the `Authorization` header's `Credential` field.
AI Reserve looks the id up, recomputes the signature with the secret that
pairs with it, and refuses the request with AWS's own
`InvalidSignatureException` if they differ — so the secret never crosses the
wire, and a wrong secret fails the way it would against AWS. The region in
that same field tells us which regional endpoint you meant.

> **Using an aireserve\_api\_ key instead**
>
> Any of your organization's `aireserve_api_…` keys still works as the `aws_access_key_id` with any non-empty
> `aws_secret_access_key` (the key itself is the bearer secret, carried over TLS). The pair form above is the one the
> portal issues and the one to use in new setups; nothing you have configured the old way stops working.

## Step by step

**1. Create a credential**

In the portal, open **Containers & Orchestration › Elastic Container Service**, click **Create credential**, name it after the
environment that will use it, and copy both values. The secret access key is shown once.

```bash theme={"dark"}
export AWS_ACCESS_KEY_ID="AIRA…"
export AWS_SECRET_ACCESS_KEY="…"
```

**2. Repoint your client**

Pick the one that matches how you call ECS today.

**AWS CLI**

One-off, per command:

```bash theme={"dark"}
aws ecs list-clusters --region us-east-1 --endpoint-url https://api.aireserve.com
```

For a whole shell session, the service-specific endpoint variable keeps every other AWS service on its normal
endpoint:

```bash theme={"dark"}
export AWS_ENDPOINT_URL_ECS=https://api.aireserve.com
export AWS_ENDPOINT_URL_EC2=https://api.aireserve.com    # optional: subnet / security-group lookups
export AWS_ENDPOINT_URL_CLOUDWATCH_LOGS=https://api.aireserve.com   # optional: read your tasks' logs
export AWS_ENDPOINT_URL_SECRETS_MANAGER=https://api.aireserve.com   # optional: secrets your tasks inject at start
export AWS_ENDPOINT_URL_SSM=https://api.aireserve.com               # optional: Parameter Store
export AWS_ENDPOINT_URL_ECR=https://api.aireserve.com               # optional: your private image registry
export AWS_DEFAULT_REGION=us-east-1

aws ecs list-clusters
aws ecs describe-services --cluster <your-cluster> --services <your-service>
```

**Shared config / profile**

A named profile makes the switch per command (`--profile aireserve`) or per environment
(`AWS_PROFILE=aireserve`), and every SDK honors it too.

`~/.aws/config`:

```ini theme={"dark"}
[profile aireserve]
region = us-east-1
services = aireserve

[services aireserve]
ecs =
  endpoint_url = https://api.aireserve.com
ec2 =
  endpoint_url = https://api.aireserve.com
cloudwatch_logs =
  endpoint_url = https://api.aireserve.com
secrets_manager =
  endpoint_url = https://api.aireserve.com
ssm =
  endpoint_url = https://api.aireserve.com
ecr =
  endpoint_url = https://api.aireserve.com
```

The variable and key names come from each service id: "CloudWatch Logs" is `CLOUDWATCH_LOGS` /
`cloudwatch_logs` (not `LOGS`), and "Secrets Manager" is `SECRETS_MANAGER` / `secrets_manager`
(not `SECRETSMANAGER`). A mis-named one is silently ignored and the CLI calls AWS itself, which answers
`UnrecognizedClientException`.

`~/.aws/credentials`:

```ini theme={"dark"}
[aireserve]
aws_access_key_id = AIRA…
aws_secret_access_key = …
```

```bash theme={"dark"}
aws ecs list-clusters --profile aireserve
```

**Python (boto3)**

```diff theme={"dark"}
 import boto3

-ecs = boto3.client("ecs", region_name="us-east-1")
+ecs = boto3.client(
+    "ecs",
+    endpoint_url="https://api.aireserve.com",
+    aws_access_key_id=os.environ["AWS_ACCESS_KEY_ID"],
+    aws_secret_access_key=os.environ["AWS_SECRET_ACCESS_KEY"],
+    region_name="us-east-1",
+)

 # every call site is unchanged
 ecs.run_task(cluster="demo", taskDefinition="web:7", launchType="FARGATE", ...)
 for page in ecs.get_paginator("list_tasks").paginate(cluster="demo"):
     ...
 ecs.get_waiter("services_stable").wait(cluster="demo", services=["web"])
```

**JavaScript / TypeScript**

```diff theme={"dark"}
 import { ECSClient, RunTaskCommand } from "@aws-sdk/client-ecs";

-const ecs = new ECSClient({ region: "us-east-1" });
+const ecs = new ECSClient({
+  endpoint: "https://api.aireserve.com",
+  region: "us-east-1",
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
+  },
+});

 await ecs.send(new RunTaskCommand({ cluster: "demo", taskDefinition: "web:7", launchType: "FARGATE", /* … */ }));
```

**Go**

```go theme={"dark"}
cfg, err := config.LoadDefaultConfig(ctx,
    config.WithRegion("us-east-1"),
    config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(
        os.Getenv("AWS_ACCESS_KEY_ID"), os.Getenv("AWS_SECRET_ACCESS_KEY"), "")),
)
if err != nil { log.Fatal(err) }

client := ecs.NewFromConfig(cfg, func(o *ecs.Options) {
    o.BaseEndpoint = aws.String("https://api.aireserve.com")
})

out, err := client.ListClusters(ctx, &ecs.ListClustersInput{})
```

**Java**

```java theme={"dark"}
EcsClient ecs = EcsClient.builder()
    .region(Region.US_EAST_1)
    .endpointOverride(URI.create("https://api.aireserve.com"))
    .credentialsProvider(StaticCredentialsProvider.create(
        AwsBasicCredentials.create(System.getenv("AWS_ACCESS_KEY_ID"), System.getenv("AWS_SECRET_ACCESS_KEY"))))
    .build();

ListClustersResponse clusters = ecs.listClusters();
```

**Terraform**

Use a dedicated provider alias for your `aws_ecs_*` resources so the rest of your configuration keeps
talking to AWS. The `skip_*` flags stop the provider from calling STS, which is not served yet.

```hcl theme={"dark"}
provider "aws" {
  alias  = "aireserve_ecs"
  region = "us-east-1"

  access_key = var.aireserve_access_key_id
  secret_key = var.aireserve_secret_access_key

  skip_credentials_validation = true
  skip_requesting_account_id  = true
  skip_metadata_api_check     = true

  endpoints {
    ecs  = "https://api.aireserve.com"
    ec2  = "https://api.aireserve.com"   # data "aws_subnets" / "aws_security_group" lookups
    logs = "https://api.aireserve.com"   # data "aws_cloudwatch_log_group"
  }
}

resource "aws_ecs_cluster" "demo" {
  provider = aws.aireserve_ecs
  name     = "demo"
}
```

**3. Verify**

```bash theme={"dark"}
aws ecs list-clusters --endpoint-url https://api.aireserve.com --region us-east-1
```

An empty `clusterArns` list is a success — you are talking to ECS through AI Reserve. An
`InvalidSignatureException` means the secret access key does not match the access key id (or
your clock is more than 15 minutes off); an `AccessDeniedException` means the credential is
unknown, revoked, or paused — check it under **Containers & Orchestration › Elastic Container Service** in the portal.

**4. Run what you already run**

Your existing `register-task-definition`, `create-service`, `update-service`, `run-task`, `describe-*`,
`list-*`, `execute-command`, waiters, and paginators work unchanged. See [what to expect](#what-to-expect)
for the handful of things that differ from your own AWS account.

## Deploy a container and get a URL

The fastest path from an image to a running HTTPS service is Amazon ECS
**Express Mode**: one call, and ECS creates the load balancer, target group,
security groups, CPU autoscaling and rollback alarms in your account and gives
the service a URL at `https://<name>.ecs.<region>.on.aws/` on an AWS-managed
certificate. The portal's **Deploy a container** button is this call; from the
CLI it is:

```bash theme={"dark"}
aws ecs create-express-gateway-service \
  --service-name storefront \
  --primary-container image=public.ecr.aws/nginx/nginx:latest,containerPort=80 \
  --execution-role-arn arn:aws:iam::<your account id>:role/AireserveEcsTaskExecution \
  --infrastructure-role-arn arn:aws:iam::<your account id>:role/AireserveEcsInfrastructure \
  --health-check-path / \
  --cpu 1024 --memory 2048 \
  --scaling-target minTaskCount=1,maxTaskCount=4,autoScalingMetric=AVERAGE_CPU,autoScalingTargetValue=60

aws ecs describe-express-gateway-service --service-arn <the ARN it returned>   # until status ACTIVE; the URL is under ingressPaths
```

The two roles already exist in your account: `AireserveEcsTaskExecution` pulls
the image, writes logs and reads secrets at start; `AireserveEcsInfrastructure`
is what ECS assumes to create the load balancer and friends (the AWS console's
"Create new role" button, pre-created). Where the AWS console asks you to create
them, you do not.

Everything an Express service runs on is an ordinary ECS resource in your
account: the service appears in `list-services`, its tasks in `list-tasks`,
its logs under the log group ECS created, so the rest of this page and all of
`aws ecs` apply to it unchanged. Change the image, size, variables or scaling
with `update-express-gateway-service` (the portal's service page has a button
for each); ECS rolls the change out and rolls back on its own if the new tasks
fail health checks or raise 5xx. `delete-express-gateway-service` removes the
load balancer and URL with the service.

The Fargate task-hours are billed as described under [Billing](#billing). The
load balancer ECS creates is an AWS resource in your account too (AWS lists it
at \$0.0225 per hour plus traffic); it is metered on the same hourly basis.

## Infrastructure as code

**Terraform** works through the provider alias above: the AWS provider calls
the ECS API directly, so pointing its `ecs` endpoint at AI Reserve moves
`aws_ecs_cluster`, `aws_ecs_task_definition`, `aws_ecs_service`, and the other
`aws_ecs_*` resources. Keep references to roles, subnets, security groups, and
log groups set to the identifiers AI Reserve provisions for you.

**CloudFormation and the AWS CDK** deploy through AWS's own control plane,
which calls ECS from inside your AWS account — there is no endpoint to
repoint. Drive ECS with the CLI, an SDK, or Terraform instead, or keep using
CloudFormation for the stacks that stay in your account.

## What to expect

**The whole ECS API.** AI Reserve does not keep a list of supported
operations; it forwards whatever you send and returns whatever ECS answers.
New ECS features work the day AWS ships them.

### Network ids and logs

A Fargate task needs a subnet and a security group, and once it runs you
will want its output. Both live in your container account, so point the EC2
and CloudWatch Logs services at the same endpoint and call them as you would
against AWS. AI Reserve forwards every operation of both services the same
way it forwards ECS; what your account's role permits is what succeeds, and
anything it does not is AWS's own `UnauthorizedOperation` (EC2) or
`AccessDeniedException` (Logs). Today the role grants the reads a Fargate
tenant needs:

| Service | Granted today | Typical use |
| - | - | - |
| EC2 | `DescribeSubnets`, `DescribeVpcs`, `DescribeSecurityGroups` | `aws ec2 describe-subnets --filters Name=default-for-az,Values=true` |
| CloudWatch Logs | `DescribeLogGroups`, `DescribeLogStreams`, `GetLogEvents`, `FilterLogEvents` | `aws logs tail /your/group --follow` |

Your account comes with a default VPC in every region, so the subnets and the
`default` security group those commands return are ready to use in
`run-task`'s `awsvpcConfiguration`. Set `awslogs-create-group=true` in a task
definition's log configuration and the group is created on first run.

The portal's **Elastic Container Service** page shows the same clusters, services,
tasks and logs (per task and per service, with a live follow), and every row
there carries the exact `aws ecs …` / `aws logs …` command that reproduces
it. Streams are named `<awslogs-stream-prefix>/<container name>/<task id>`.

**Responses are Amazon ECS's.** Pagination tokens, waiters, and error types
are the real ones, so SDK code written against ECS behaves identically —
including retries, which key off the status codes ECS returns.

**Resources live in an AWS account that is yours alone.** When an admin
enables Containers in the portal (Compute › Containers), AI Reserve creates
an AWS account for your organization inside its AWS Organization — no ticket,
no waiting on us; it is active within a few minutes and the page shows its
12-digit id. Every ECS call you make is signed in that account, so ARNs carry
its id, `list-clusters` returns only your clusters, and nothing of any other
organization's is reachable, listable, or even nameable from it. That is
AWS's own account boundary doing the isolating, not a filter in front of it.
A service-control policy caps the account to ECS on Fargate and what tasks
need (image pulls, logs, networking), and an `AireserveEcsTaskExecution`
role is ready to reference as your task definitions' `executionRoleArn`.
Public images (Docker Hub, ECR Public, GitHub Container Registry) pull as-is.

**Pick the region you mean.** The region in your client configuration is the
region your clusters and tasks run in, exactly as with AWS.

**ECS Exec works.** `aws ecs execute-command` goes through AI Reserve; the
session it returns connects your Session Manager plugin directly to AWS.

**Errors from AI Reserve arrive in the AWS envelope.** Your SDK raises its
normal typed exceptions:

| Situation | Error type | Status |
| - | - | - |
| Unknown, revoked, or paused credential; IP/country policy | `AccessDeniedException` | 403 |
| Secret access key does not match the id; clock off by more than 15 minutes | `InvalidSignatureException` | 403 |
| Containers not enabled for your organization yet | `AccessDeniedException` (names Compute › Containers) | 403 |
| Rate limit or spending cap | `ThrottlingException` (`Retry-After` set) | 429 |
| Request is not an ECS operation | `UnknownOperationException` | 400 |
| Region in the credential isn't an AWS region | `InvalidParameterException` | 400 |
| ECS unreachable / slow | `ServiceUnavailableException` / `RequestTimeoutException` | 503 / 504 |

Everything else — `ClusterNotFoundException`, `InvalidParameterException`
from a bad task definition, `ServerException` — is ECS's own answer, relayed.

## Open the AWS console

Your container account is a real AWS account, and the portal can sign you
into its AWS Management Console. On **Containers & Orchestration › Elastic
Container Service**, choose a region and click **Open AWS Console**: a new tab
lands on the ECS clusters page of your account, signed in as you. The session
lasts an hour, then AWS sends you back to the portal.

This is AWS's own federated sign-in. The portal is the identity provider: an
organization admin's portal session is exchanged for temporary credentials in
your account, with your email as the session name, so every console action
is attributed to you in your account's CloudTrail. No AWS user or password
exists for you, nothing to rotate, and leaving the organization removes the
access. Members can read everything in the portal; opening the console is an
admin action, because a console session can run, scale and delete.

What you see is your account and nothing else: no other organization's
resources, no AI Reserve platform resources. The console shows the same
permission boundary the API has. Pages outside the ECS product (EC2
instances, IAM, S3) answer **Access denied**; that is the account's ceiling,
not a fault.

## Billing

Fargate tasks you run through AI Reserve are billed to your organization's
wallet at AWS's on-demand list price for the region — per vCPU-hour and per
GB-hour of the task's requested `cpu` and `memory`, plus ephemeral storage
above the included 20 GiB and the Windows licence fee where they apply —
from image pull until the task stops, with AWS's one-minute minimum.

Each task-hour appears as its own line in **Observe › Event Log** and in
**Financials**, model `ecs:fargate-task`, provider `aws-ecs`, with the task
and cluster ARN in its details, so what you see in the console matches what
`aws ecs describe-tasks` tells you. Metering enumerates your organization's
own AWS account every five minutes, so tasks started by an ECS service
scheduler — which never pass through AI Reserve — are billed like any other,
and nothing another organization runs can ever land on your bill. A task
that stopped may take one cycle to settle its last partial hour.

If your wallet cannot cover an hour, the hour stays recorded as unpaid and
is retried as funds arrive; your running tasks are not stopped by AI
Reserve. Tasks on the `EC2` or `EXTERNAL` launch types are not billed per
task (the instances are) — talk to your account team before using them.

> [!NOTE]
>
> Containers & orchestration is in early access. Talk to your account team before pointing production traffic at it.


# Containers & orchestration
Source: https://docs.aireserve.com/containers/index

Run your existing Amazon ECS setup through AI Reserve: repoint the endpoint, swap the credential, keep every command, SDK call, and script exactly as it is.

AI Reserve serves the **Amazon ECS API** at `https://api.aireserve.com`. Point
the AWS SDK or CLI you already use at that endpoint, use your AI Reserve API
key as the access key, and every ECS operation you call today (clusters, task
definitions, services, tasks, ECS Exec, tags, settings) runs on infrastructure
AI Reserve provisions for you. Nothing about your code, your task definitions,
or your deploy scripts changes beyond the client configuration.

> **[Repoint Amazon ECS](/containers/ecs)**
>
> The four client settings, for the CLI, shared config, boto3, JavaScript, Go, Java, and Terraform.

> **[Get an API key](/getting-started/get-an-api-key)**
>
> One key works for ECS, inference, and GPU infrastructure.

## How it works

The same shape as our OpenAI- and Anthropic-compatible endpoints: your client
talks to AI Reserve exactly as it would talk to the provider, and AI Reserve
talks to the provider on your behalf.

| Your client sends | AI Reserve does | You get back |
| - | - | - |
| A normal ECS request, SigV4-signed with your AI Reserve key as the access key id | Authenticates the key, re-signs the untouched request with its AWS credentials, forwards it to the regional ECS endpoint | Amazon ECS's own response, byte for byte |
| Any operation in the ECS API, in any region | No operation list, no translation, no rewriting — if ECS accepts it, it works | Standard ECS pagination, waiters, and typed exceptions |

Because the response is AWS's, every SDK feature built on the wire keeps
working: `aws ecs wait services-stable`, boto3 paginators, the JavaScript
SDK's `waitUntilTasksRunning`, typed `ClusterNotFoundException` handling, and
the SDK's own retry policy.

## What is different from calling AWS directly

* **The infrastructure lives in AI Reserve's AWS account.** Cluster, service,
  and task ARNs carry our account id, and the companion resources a task
  definition references — task execution roles, VPC subnets, security groups,
  CloudWatch log groups, private registry credentials — are ones we provision
  for you during onboarding and hand you the identifiers for. Public container
  images work as-is.
* **One credential.** Your AI Reserve API key replaces the AWS access key; the
  AWS secret key is unused (any value). Rotating or pausing the key in the
  [portal](https://portal.aireserve.com/keys) takes effect on the next call.
* **Our gates apply before AWS sees the request.** API-key checks, your
  organization's IP and country policies, and rate limits answer in the AWS
  error envelope (`AccessDeniedException`, `ThrottlingException`) so your
  existing error handling already covers them.
* **ECS only.** The endpoint serves Amazon ECS. Point other AWS services at
  AWS as you do today.

> [!NOTE]
>
> Containers & orchestration is in early access. Talk to your account team before pointing production traffic at it —
> they will set up the roles, networks, and registry access your task definitions reference.


# Secrets Manager
Source: https://docs.aireserve.com/containers/secrets

Keep the secrets your tasks read in your organization's own AWS account: create and rotate them in the portal or with the AWS CLI through AI Reserve, inject them with secrets[].valueFrom, roll back by version.

Your organization's AWS container account comes with **AWS Secrets Manager**.
A secret you create there is injected into a task at start through the task
definition's `secrets[].valueFrom`, read by the AWS CLI or any SDK with an
[ECS credential](/containers/ecs), and listed, versioned, deleted and restored
from the portal under **Secrets › Secrets Manager**. The portal never shows a
value: it is written once, and read only by the task or your shell.

Isolation is AWS's own account boundary — the same one that keeps your
clusters yours. A secret's ARN carries your account id, and nothing in any
other organization's account is reachable from it.

## One setting

The same endpoint override you set for ECS, for the Secrets Manager service:

| Setting | Value |
| - | - |
| Environment variable | `AWS_ENDPOINT_URL_SECRETS_MANAGER=https://api.aireserve.com` |
| Shared-config key (`[services aireserve]`) | `secrets_manager =` / `endpoint_url = https://api.aireserve.com` |
| Credential | the ECS credential pair from **Containers & Orchestration › Elastic Container Service › Create credential** |

```bash theme={"dark"}
export AWS_ACCESS_KEY_ID="AIRA…"
export AWS_SECRET_ACCESS_KEY="…"
export AWS_DEFAULT_REGION="us-east-1"
export AWS_ENDPOINT_URL_SECRETS_MANAGER="https://api.aireserve.com"

aws secretsmanager list-secrets --include-planned-deletion
```

An empty `SecretList` is a success. Or, in `~/.aws/config`, next to the ECS lines:

```ini theme={"dark"}
[services aireserve]
ecs =
  endpoint_url = https://api.aireserve.com
cloudwatch_logs =
  endpoint_url = https://api.aireserve.com
secrets_manager =
  endpoint_url = https://api.aireserve.com
```

## Create and read

```bash theme={"dark"}
# The value comes from stdin so it never lands in shell history.
printf '%s' "$DATABASE_URL" | aws secretsmanager create-secret \
  --name prod/api/database-url \
  --description "Postgres URL the api service reads at start" \
  --secret-string file:///dev/stdin \
  --tags Key=aireserve:managed,Value=cli

aws secretsmanager get-secret-value --secret-id prod/api/database-url \
  --query SecretString --output text
```

The portal's **Create secret** button is `create-secret` (tagged
`aireserve:managed=portal`); its detail panel carries this exact
`get-secret-value` line with the endpoint export above it, ready to paste.
Names are up to 512 characters of letters, numbers and `/ _ + = . @ -`; a
path such as `prod/api/database-url` reads well in a task definition.

## Inject into a task

Reference the secret by ARN in a container's `secrets` array; ECS resolves
it when the task starts and sets the environment variable:

```json theme={"dark"}
{
  "name": "DATABASE_URL",
  "valueFrom": "arn:aws:secretsmanager:us-east-1:123456789012:secret:prod/api/database-url-AbCdEf"
}
```

For a JSON-valued secret, one key: append `:key::` to the ARN
(`…:secret:prod/api/credentials-AbCdEf:password::`). The task execution
role your account ships with (`AireserveEcsTaskExecution`) may read secrets,
so nothing else is needed. The portal's secret detail panel copies this entry
with the ARN filled in; the **Variables** dialog of a deployed service takes
the same `NAME=<ARN>` lines.

## Versions and rollback

Every `put-secret-value` (the portal's **Update value**) stores a new
version and moves the `AWSCURRENT` label onto it; the version that was
current becomes `AWSPREVIOUS`. Tasks that start from then on, and every
`get-secret-value`, read `AWSCURRENT`; tasks already running keep what they
started with until they are replaced (a **Redeploy** does that).

```bash theme={"dark"}
printf '%s' "$NEW_DATABASE_URL" | aws secretsmanager put-secret-value \
  --secret-id prod/api/database-url --secret-string file:///dev/stdin

aws secretsmanager list-secret-version-ids --secret-id prod/api/database-url --include-deprecated
```

To roll back, move `AWSCURRENT` to an older version — the portal's **Make
current** button on the Versions list:

```bash theme={"dark"}
aws secretsmanager update-secret-version-stage --secret-id prod/api/database-url \
  --version-stage AWSCURRENT \
  --move-to-version-id <older version id> \
  --remove-from-version-id <current version id>
```

No value changes; only the label moves.

## Delete and restore

Deletion is scheduled, never immediate: a 7–30 day recovery window
(the portal offers 7, 14 or 30; 30 is the default) during which the secret
is recoverable with `restore-secret`. Tasks that reference a scheduled
secret fail to start right away, and no version can be read — that is the
signal to restore.

```bash theme={"dark"}
aws secretsmanager delete-secret --secret-id prod/api/database-url --recovery-window-in-days 30
aws secretsmanager restore-secret --secret-id prod/api/database-url
```

The portal's **Delete** asks for the recovery window and shows the date;
**Restore** appears on a secret while it is scheduled. There is no
force-delete from the portal.

## From an agent

The [MCP containers domain](/connect/mcp-tools#containers-containers-query-containers-action)
has `list_secrets`, `get_secret` (metadata and versions only),
`promote_secret_version`, `delete_secret` and
`restore_secret`. A value an agent stores is one the user handed it; no value
ever comes back over that connection — the agent points the user at the
`get-secret-value` line instead.

> [!NOTE]
>
> Secrets Manager's own charges (per secret per month, per 10,000 API calls) are AWS resources in your account and are
> metered to your wallet like the rest of it. Rotation with a Lambda function is not available in the container account
> today; rotate with `put-secret-value`.


# Getting started for your team
Source: https://docs.aireserve.com/getting-started/for-your-team

The eight things a new organization asks on day one — chat, model choices, specialists, API keys, coding tools, routing, spend, and privacy — with the exact clicks.

New to AI Reserve — or new to AI altogether? These are the eight questions
every organization asks in its first week, answered with the exact clicks.
Everything below is a setting you can see in the portal today; nothing needs a
support ticket. Admin steps live under **Admin → your organization** in the
sidebar and apply organization-wide within about a minute.

## 1. Chat

Sign in at [portal.aireserve.com](https://portal.aireserve.com) and open
**Chat** in the sidebar. Chat is off for every new organization until an admin
turns on **Web chat** under **Admin → your organization → Privacy**; once it is
on, everyone on the team can ask anything in the box. Leave the model on
**Auto** — the gateway picks the best model for each message, so nobody has to
know one model from another. The **Auto** button next to the send arrow opens
the picker: **Auto** ("Best model per task") sits at the top, followed by every
model your organization allows, grouped by provider, with search, favorites,
and recents. The **Specialist** button beside it is where specialists appear
once an admin enables them ([section 3](#3-turning-on-the-investment-advisor-specialist)).

![The AI Reserve chat screen: the message box with the Specialist and Auto buttons next to the send arrow, and the Get started checklist.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/chat.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=746797e804b8b107b92a95ccf5a9377c)

## 2. Models from China-based providers are off by default

Some catalog models are served by providers operating under PRC (China)
jurisdiction. They are **off for every new organization** and stay off until an
enterprise admin turns them on: **Admin → your organization → Models → Model
data guarantees → Models on PRC servers**. The same card holds two sibling
switches — **Models with unverified data retention** and **Models that may train
on your data** — and all three start off; locked models appear greyed out in the
catalog below with the missing consent named. While a switch is off, those
models are excluded everywhere: the chat picker, Auto routing, and API traffic
on your keys. Every affected model carries a **China-based** label in model
lists.

The test is who operates the serving endpoint, not where the model was made —
Chinese-origin open weights served by US providers (for example
`deepseek-v4-pro` or `qwen-3.7-max`) are not China-hosted and are not covered
by the switch. To keep those off your team's menu too, block them one by one
from the model catalog on the same page; the **Router selections & blocklist**
panel shows what you have blocked. The full list of affected models is in
[China-hosted models](/models#china-hosted-models).

To rule out a whole company instead of chasing its releases one by one, use
**Block a maker** on the **Model defaults** card of the same page. Pick a maker
(DeepSeek, Z.ai, Moonshot, Alibaba, …) and every model they make — the ones in
the catalog today and any added later — is treated exactly like a model you
blocked by hand: greyed out in the chat picker, skipped by Auto routing, and
left out of the model lists your MCP clients and Office add-ins see. Everything
from other makers stays allowed, including new models. If your organization's
default model comes from a maker you block, new chats start on Auto routing
until you pick another default.

![The Model data guarantees card with its three switches: Models with unverified data retention, Models that may train on your data, and Models on PRC servers — all off.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/prc-servers-switch.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=01b8c97a4b2d94a3787444398c376d30)

## 3. Turning on the Investment Advisor specialist

Specialists are optional expert modes a user can attach to a single
conversation; every chat starts with the standard assistant. They are off until
an admin enables them: open **Admin → your organization → Privacy**, and in the
**Web chat** section check **Investment Advisor** on the **Chat specialists**
card. It adds investment-grade research on private companies and funds —
company, fund, contact, and team lookups across AI Reserve's market datasets,
comparable analysis, and diligence questions — for the conversations where
someone picks it; every other chat is unchanged. Unchecking takes effect within
about a minute: conversations that had it attached fall back to the standard
assistant on their next message, and no history is lost. What the lookups
reach, and the per-conversation caps, are in
[Chat specialists](/capabilities/chat-specialists).

![The Web chat section of the Privacy page: the Web chat switch on, and the Chat specialists card with Investment Advisor checked.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/specialists.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=59ecce98f1d4ea63bcfeaca41559ce12)

## 4. Create an API key

Open **API Keys** in the sidebar and click **Create Key**. The key is shown
once — copy it straight into your secret manager or an environment variable,
because the platform keeps only a hashed fingerprint. Keys look like
`aireserve_api_…` and are sent as the bearer token against the base URL
`https://api.aireserve.com/v1`. Revoke any key from the same page at any time —
access stops immediately — and see each key's usage in **Analytics**, filtered
by API key. How the SDKs pick the key up is in
[Get an API key](/getting-started/get-an-api-key).

![The API Keys page with one active organization key and the Create Key button.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/api-keys.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=37df2b8fca778593dcfb7a10cb7d1d60)

## 5. Connect a coding tool

Any tool that speaks the OpenAI or Anthropic API can run on your key: change
the base URL, paste the key, keep everything else. [Connect your
tool](/connect) has a page per tool with the exact fields — start with
[GitHub Copilot](/connect/github-copilot) for VS Code and the Copilot CLI, or
[Zed](/connect/zed) for the Zed editor. Every request those tools make is
metered on the key you gave them, so it shows up in Analytics within seconds.

## 6. Routing for cost

**Auto** picks a model per request, so most of your team never chooses one.
Admins decide what Auto optimizes for: **Admin → your organization → Routing →
Tune Router** shows a triangle with **Cheaper**, **Smarter**, and **Faster** at
the corners — drag the dot toward the corner you care about and the current
balance updates beside it, and the **Instruct Router** box takes plain-language
rules such as "for coding tasks, use Claude". Developers calling the API get
the same lever per request: append `:floor` to a model ID for the cheapest
provider currently serving those weights, or `:nitro` for the fastest.

```bash theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash:floor",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

Whenever a request is answered by something other than exactly what you asked
for (a failover, a `:nitro` / `:floor` routing variant, or a same-weights pool),
the response carries an `x-aireserve-served-model` header naming the model that
actually answered, and `x-aireserve-served-provider` when your organization has
pinned a model to a provider. No header means the request was served as
requested. Details in [Provider routing variants](/models#provider-routing-variants).

![The Tune Router card: a triangle with Smarter, Cheaper, and Faster at the corners, the current balance in percentages, and the Instruct Router text box.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/tune-router.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=0b9e23bb1c7de40fd3f8ada81020af9a)

## 7. Seeing spend

**Analytics** in the sidebar is where spend shows up. The top card shows
spend this period, requests, tokens, active API keys, and models used;
**Usage by Model** lists tokens, requests, **Cache Hits**, **Speed** (typical
and slowest response times), and share of spend per model; the member and
API-key filters break the same numbers down by person, team, or key; and
**Admin → your organization → Analytics** stacks spend by business function per
team. Savings show up in the same tables: a balance dragged toward Cheaper or
a `:floor` request shifts share of spend toward lower-cost models, cache hits
from providers that support prompt caching are passed through to you and appear
in the **Cache Hits** column, and because every provider bills to one wallet,
the whole picture is on one page.

## 8. Privacy in plain terms

* **API traffic is never stored.** Prompts and responses sent with your API
  keys pass through the gateway in memory only; the platform keeps usage
  metadata (model, tokens, cost, timestamps) for billing and nothing else.
  There is no setting that changes this.
* **Web chat is stored only if you want it.** Under **Admin → your organization
  → Privacy → Chat content storage**, switch **Store chat prompt & response
  content** off and no chat text is written — conversations disappear when the
  page closes. On the same card, **Automatically delete old content** sets a
  retention window (30 days to a year, or keep until deleted), and **Delete
  stored content** permanently removes everything stored so far, whether
  storage is on or off. Users can also delete their own chats and documents
  from their profile (**Delete my data**), or delete their account entirely.
* **No training on your data.** AI Reserve does not use identifiable customer
  data to train AI models, and every provider in the default catalog serves
  under no-training terms; providers whose terms allow training sit behind the
  consent switches in [section 2](#2-models-from-china-based-providers-are-off-by-default)
  and stay locked until an admin opts in.
* **Where it runs.** One Google Cloud project in the United States, encrypted in
  transit and at rest, with each organization's data logically separated and
  access restricted by role.
* **Certifications, honestly.** Our own SOC 2 Type II examination is in progress
  and no report has been issued yet — we do not claim our own certification.
  The Google Cloud infrastructure the platform runs on carries Google's SOC 2
  Type II and ISO 27001 certifications (Google's, not ours).

![The Chat content storage card: the Store chat prompt & response content switch with the Delete stored content button, and the Automatically delete old content selector set to Keep until deleted.](https://mintcdn.com/ai-reserve/yMuucmb07au9AMdN/images/team-onboarding/chat-storage.png?fit=max\&auto=format\&n=yMuucmb07au9AMdN\&q=85\&s=13612c8af81807697c554b9390c5a6f0)

![Diagram: API clients and portal users send requests into AI Reserve's single Google Cloud project, where the API gateway, billing and policy proxy, and routing engine pass prompts and responses in transit only to the model providers your organization allows; only usage metadata is kept.](https://mintcdn.com/ai-reserve/xmqnBxL3ALGbqaph/images/team-onboarding/data-flow.png?fit=max\&auto=format\&n=xmqnBxL3ALGbqaph\&q=85\&s=0fe0b014139c9f7a3e92712deb168c38)

The authoritative documents, kept current in one place: the
[Trust Center](https://trust.aireserve.com), the
[Data Privacy & Security Overview](https://privacy.aireserve.com), the
per-provider [Provider Data Handling](https://privacy.aireserve.com/data-handling)
table, and the [Data Processing Agreement](https://aireserve.com/legal/dpa).


# Get an API key
Source: https://docs.aireserve.com/getting-started/get-an-api-key

Every request authenticates with a single bearer key issued from your AI Reserve workspace — no region, no credential chain, no IAM role, and no signing.

Every request authenticates with a single bearer key issued from your
[AI Reserve workspace](https://portal.aireserve.com/keys) (**API Keys** in the sidebar →
**Create Key**; you'll be asked to sign in first) — keys look like `aireserve_api_…` (older
`audacity_api_…` keys keep working). There is **no region, no credential chain,
no IAM role, and no signing**. The SDKs resolve the key the way the AWS SDKs resolve
credentials, in priority order:

| Priority | Source |
| - | - |
| 1 | Explicit constructor / builder value |
| 2 | `AIRESERVE_API_KEY` environment variable (base URL: `AIRESERVE_BASE_URL`) |
| 3 | Defaults — base URL `https://api.aireserve.com`, timeout 120 s, 2 retries |

If no key can be resolved, the SDK fails fast with a clear client-side error
(`MissingApiKeyError` or the language equivalent) — before any network call is made.
Keep keys in a secret manager or environment variable; never commit them.

> **[Get an API key](https://portal.aireserve.com/keys)**
>
> Sign in to the portal, open **API Keys** in the sidebar, and click **Create Key**.

## Restrict where a key can be used

Admins can narrow where requests carrying a key may come from. Every control
below is evaluated at the API edge before any model work or spend, and a
rejected request gets a clear `403` naming the control (never the observed
address or country, and never the configured lists). The **organization-level**
controls also apply to portal sessions: a signed-in user on a blocked network
or in a disallowed country sees a short notice instead of the app until they
are back on an allowed connection.

### IP allowlists and the organization IP blocklist

* **Per key** — an **IP allowlist** of IPv4/IPv6 addresses or CIDR ranges
  (API Keys page → the key's **IP access**). Requests from any other address
  are rejected with `ip_address_not_allowed`.
* **Per organization** — an **IP blocklist** (dashboard → Governance →
  **IP blocklist**). Matching API requests are rejected with
  `ip_address_blocked` regardless of the key, and matching portal sessions are
  blocked.

### Country restrictions

Country lists work on the **source country of the request** — the country the
request's network address resolves to — so an admin can think in "US only" or
"US + Canada" instead of address ranges.

| Level | Setting | Effect |
| - | - | - |
| Organization | **Allowed countries** | API requests and portal sessions from any other country are rejected. Empty = all countries allowed. |
| Organization | **Blocked countries** | API requests and portal sessions from these countries are always rejected, even if the country is also allowed. |
| API key | **Allowed countries** | Narrows the organization's allowed set for that key only. |

Organization lists cover every API key, domain sign-in (OIDC), and portal
session; MCP traffic is not covered. Platform operators (super admins) are
exempt so a mistaken list can always be corrected.

Rules worth knowing:

* **A key can only narrow, never widen.** The effective set for a key is the
  intersection of the organization allowlist (if any) and the key allowlist
  (if any). A key list containing a country the organization does not allow
  admits nothing for that country; the portal warns before saving such a
  list. The organization blocklist always applies on top.
* **Unknown country fails closed under an allowlist.** If the source country
  cannot be determined (the lookup failed, the address has no country, or it
  is a private address), the request is rejected whenever any allowlist is
  set. With only a blocklist configured there is nothing to match, so the
  request proceeds.
* **Requests the platform makes on your behalf come from our infrastructure**
  in the United States — the Slack agent, the portal's "Test key" button, and
  similar integrations. An organization allowlist that excludes `US` will
  reject those too.
* Rejections use the code `country_not_allowed` and the message
  `Requests from your current country are not permitted by your organization's country restrictions…`.
  The platform's own geographic screen is separate and unchanged; its
  rejections keep the `unsupported_country_region_territory` code.

> [!NOTE]
>
> Country restrictions are about **where a request comes from**, not where it
> is processed. They are not a data-residency control: requests are processed
> in the United States regardless of the countries you allow — see
> [Data privacy](/trust/data-privacy).

Manage them from the dashboard → Governance → **Country restrictions**
(organization) and the API Keys page → the key's **Countries** column (per
key). Both accept one-click presets — United States only, US + Canada, EU/EEA,
United Kingdom — and every change is recorded in the admin activity log.


# SDK quickstart
Source: https://docs.aireserve.com/getting-started/quickstart

Install an official AI Reserve SDK and make your first request — a complete round trip in five languages.

## Packages & installation

| Language | Package | Requires | Runtime dependencies |
| - | - | - | - |
| Python | `audacity-sdk` (PyPI) | Python 3.9+ | None — stdlib only |
| TypeScript / JS | `@audacity/sdk` (npm) | Node ≥ 18 or Bun | None — global fetch, dual ESM/CJS, full `.d.ts` |
| Go | `github.com/Audacity-Investments/audacity-sdk-go` | Go 1.22+ | None — stdlib only |
| Java | `com.audacityinvestments:audacity-sdk` (Maven Central) | Java 11+ | Gson only — uses `java.net.http` |
| Rust | `audacity-sdk` (crates.io) | Rust (tokio) | `reqwest`, `serde`, `tokio` |

```bash Python theme={"dark"}
pip install audacity-sdk
```

```bash TypeScript theme={"dark"}
npm install @audacity/sdk
# or
bun add @audacity/sdk
```

```bash Go theme={"dark"}
go get github.com/Audacity-Investments/audacity-sdk-go
```

```xml Java theme={"dark"}
<dependency>
  <groupId>com.audacityinvestments</groupId>
  <artifactId>audacity-sdk</artifactId>
  <version>0.6.0</version>
</dependency>
```

```toml Rust theme={"dark"}
[dependencies]
audacity-sdk = "0.6.0"
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
```

> [!NOTE]
>
> The Python distribution is named `audacity-sdk`, but the import stays
> `audacity` — exactly the boto3 pattern of installing one name and importing another.

## Your first request

A complete request/response round trip with the official AI Reserve SDKs. Set
`AIRESERVE_API_KEY` in your environment, pick a model, and run — the shapes below
will look familiar to anyone who has used Bedrock's `Converse`. (Using the OpenAI
or Anthropic SDK instead? See [connect what you already use](/connect).)

```python Python theme={"dark"}
from audacity import Audacity

client = Audacity(api_key="aireserve_api_…")   # or set AIRESERVE_API_KEY

response = client.converse(
    modelId="gpt-5.4-mini",
    messages=[{"role": "user", "content": [{"text": "What is 2+2?"}]}],
    inferenceConfig={"maxTokens": 256, "temperature": 0.0},
)

print(response["output"]["message"]["content"][0]["text"])
print(response["stopReason"])   # "end_turn"
print(response["usage"])        # {"inputTokens": …, "outputTokens": …, "totalTokens": …}
print(response["metrics"])      # {"latencyMs": …}
```

```typescript TypeScript theme={"dark"}
import { AudacityRuntimeClient, ConverseCommand } from "@audacity/sdk";

const client = new AudacityRuntimeClient({ apiKey: process.env.AIRESERVE_API_KEY });

const response = await client.send(
  new ConverseCommand({
    modelId: "gpt-5.4-mini",
    messages: [{ role: "user", content: [{ text: "Hello!" }] }],
    inferenceConfig: { maxTokens: 500, temperature: 0.2 },
  })
);

console.log(response.output?.message?.content?.[0]?.text);
// response.stopReason, response.usage, response.metrics.latencyMs also populated
```

```go Go theme={"dark"}
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Audacity-Investments/audacity-sdk-go"
    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime"
    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime/types"
)

func main() {
    // Reads AIRESERVE_API_KEY from the environment.
    client := audacityruntime.New(audacityruntime.Options{})

    resp, err := client.Converse(context.Background(), &audacityruntime.ConverseInput{
        ModelId: audacity.String("gpt-5.4-mini"),
        Messages: []types.Message{{
            Role:    types.ConversationRoleUser,
            Content: []types.ContentBlock{
                &types.ContentBlockMemberText{Value: "Hello, world!"},
            },
        }},
        InferenceConfig: &types.InferenceConfiguration{
            MaxTokens:   audacity.Int32(500),
            Temperature: audacity.Float32(0.2),
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    out := resp.Output.(*types.ConverseOutputMemberMessage)
    text := out.Value.Content[0].(*types.ContentBlockMemberText).Value
    fmt.Println(text)
}
```

```java Java theme={"dark"}
import com.audacity.sdk.*;

var client = AudacityRuntimeClient.builder()
    .apiKey(System.getenv("AIRESERVE_API_KEY"))
    .build();

ConverseResponse response = client.converse(request -> request
    .modelId("gpt-5.4-mini")
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(ContentBlock.fromText("What is 2 + 2?"))
        .build())
    .inferenceConfig(cfg -> cfg.maxTokens(500).temperature(0.2f)));

System.out.println(response.output().message().content().get(0).text());
System.out.printf("Stop reason : %s%n", response.stopReason());
System.out.printf("Input tokens: %d%n", response.usage().inputTokens());
System.out.printf("Latency ms  : %d%n", response.metrics().latencyMs());
```

```rust Rust theme={"dark"}
use audacity_sdk::{Client, ContentBlock, ConversationRole, Message};

#[tokio::main]
async fn main() -> Result<(), audacity_sdk::Error> {
    // Reads AIRESERVE_API_KEY from the environment.
    let client = Client::from_env()?;

    let response = client.converse()
        .model_id("gpt-5.4-mini")
        .messages(
            Message::builder()
                .role(ConversationRole::User)
                .content(ContentBlock::Text("Hello!".into()))
                .build()?
        )
        .inference_config(
            audacity_sdk::InferenceConfiguration::builder()
                .max_tokens(500)
                .temperature(0.2)
                .build()
        )
        .send()
        .await?;

    let text = response
        .output().unwrap()
        .as_message().unwrap()
        .content().first().unwrap()
        .as_text().unwrap();

    println!("{text}");
    Ok(())
}
```

## If your first request fails

The fastest diagnosis: open the portal, find your key under
**Profile → API Keys**, and click **Test** — it fires one real
request through the gateway with that key and translates any failure into the fix.
The same translations, keyed to what the error response says:

| What the error says | What it means | Fix |
| - | - | - |
| 401/403 — `invalid_api_key`, `AUTHENTICATION_ERROR` | This key can't sign in — it was revoked or its owner was deactivated | Create a new key in the portal and update your app to use it |
| 403 — `MODEL_NOT_ALLOWED` | The model isn't enabled for your organization | Pick a model from your organization's allowed list, or ask your admin to enable it |
| 404 — `MODEL_NOT_FOUND` | The model name wasn't recognized | Check the model ID for typos against [the model list](/models) |
| 402/429 — `usage_cap_exceeded`, `BUDGET_EXCEEDED` | Your organization's spend cap was reached | Requests resume when the cap resets or an admin raises it (Wallet page) |
| 429 — `rate_limit_exceeded` | Too many requests right now | Wait a few seconds and retry — honors `Retry-After`; this passes on its own |
| 5xx — `UPSTREAM_ERROR`, `TIMEOUT_ERROR` | The AI provider is having trouble — not your setup | Retry in a few minutes; the SDKs retry these automatically |
| Anything else | An unexpected failure | Retry once, then contact support with the `requestId` |

> [!NOTE]
>
> **Tip:** every server-derived error carries a `requestId` — quote it
> to support and they can find the exact request. Full exception taxonomy in
> [Errors & retries](/api-reference/errors).


# Multi-node clusters
Source: https://docs.aireserve.com/gpu-infrastructure/clusters

Launch 2–8 interconnected GPU nodes as one resource for distributed training and large-model inference.

A cluster is `nodes` identical machines of `gpusPerNode` GPUs each, placed in
one location on a private high-bandwidth interconnect, and managed as a single
resource: one quote, one launch, one price, one terminate. Use it when a model
does not fit one machine (DeepSeek-V3 or Kimi-K2 class) or for distributed
training.

The normalized contract guarantees private node connectivity, not a specific
fabric such as InfiniBand, RDMA, or NVLink. It does not expose enough provider
identity to verify one after placement. If a fabric is a hard requirement,
deploy through the provider passthrough from the outset and verify it there.

## What every node gets

| On every node | Value |
| - | - |
| `MASTER_ADDR` / `PRIMARY_ADDR` | Address of the rank-0 node on the interconnect |
| `MASTER_PORT` / `PRIMARY_PORT` | Rendezvous port; every port is open between nodes |
| `NODE_RANK` | This node's global rank; `0` is the primary |
| `NCCL_SOCKET_IFNAME` | `ens1`, so NCCL uses the interconnect, not the public interface |
| Image, env, ports, SSH keys, start command | Identical on every node |
| Shared volume | One persistent volume mounted at the same path on every node |

Set `MALLOC_ARENA_MAX=1` in `env` for tensor-parallel workloads. The
provider-agnostic cluster contract does not currently expose `/dev/shm`
sizing; workloads that require a larger shared-memory mount need a
provider-native deployment path.

## Shapes

Self-serve clusters are 2 to 8 nodes of 1 to 8 GPUs each (16 to 64 GPUs at
full width). Larger clusters are arranged through sales. `gpusPerNode` cannot
exceed what the accelerator offers per machine.

`orchestrator` picks the topology:

| `orchestrator` | What you get |
| - | - |
| `none` | Bare nodes with the variables above; bring your own launcher (default) |
| `slurm` | A managed Slurm controller on rank 0 and compute nodes elsewhere |
| `ray` | A managed Ray head on rank 0 and workers elsewhere |

## Quote, then launch

**1. Quote the shape**

```bash theme={"dark"}
aireserve gpu clusters quote \
  --accelerator H200_141GB \
  --nodes 2 \
  --gpus-per-node 8 \
  --persistent-gb 1000 \
  --max-hourly-price 100
```

The quote prices the whole cluster: every node's GPUs, every root disk,
and the shared volume. Inter-node networking is included in the rate.
`availability` is the stock signal for one node of this shape; whether
every node can be placed together is confirmed only at launch.

**2. Launch from the quote**

```bash theme={"dark"}
aireserve gpu clusters launch --quote-id <quote-id> \
  --env-file ./train.env \
  --ssh-key-id <key-id> \
  --wait
```

Workload settings (`env`, `ports`, SSH keys, `dockerStartCmd`) can be added
at launch without changing the price. Repeating a priced field with a
different value answers `409 price_changed`.

**3. Connect**

```bash theme={"dark"}
aireserve gpu clusters connections <cluster-id>
aireserve gpu clusters logs <cluster-id> --node 1
```

`connections` lists the primary node's SSH, every node's SSH and its
address on the interconnect. Logs stream per node; rank 0 by default.

Direct REST:

```http theme={"dark"}
POST /v1/gpu/clusters/quote
Content-Type: application/json

{ "accelerator": "H200_141GB", "nodes": 2, "gpusPerNode": 8, "storage": { "persistentGb": 1000 }, "maxHourlyPrice": "100" }
```

```http theme={"dark"}
POST /v1/gpu/clusters
Idempotency-Key: launch-kimi-2026-10-13
Content-Type: application/json

{ "quoteId": "<quote-id>", "env": { "HF_TOKEN": "..." }, "sshKeyIds": ["<key-id>"] }
```

## Storage

A cluster mounts at most one persistent volume, shared by every node at the
same path. Create it with the cluster (`storage`) so it lands in the cluster's
location, or mount an existing one (`volumeId`), which pins placement to where
that volume lives. The volume survives terminate and bills until you delete
it; you cannot delete or grow it while a cluster is attached.

Weights for a 600 GB to 1 TB model take 35 to 70 minutes to download at
typical rates. Put them on the shared volume once and relaunch against it.

## Lifecycle

| Status | Meaning |
| - | - |
| `provisioning` | The provider is placing nodes |
| `running` | Every node verified running on the expected hardware; billing starts here (`readyAt`) |
| `degraded` | Some nodes left `running` after the cluster was admitted. Billing continues; recover or terminate |
| `failed` | The cluster never came up (see `lastError`); nothing is billed |
| `terminated` | Every node released; only the shared volume keeps billing |

`running` is infrastructure readiness. It does not probe a model server,
distributed rendezvous, or application health endpoint. Make the shared
command rank-aware and run your own readiness check before admitting traffic.

There is no stop. A cluster bills from `readyAt` until you terminate it:

```bash theme={"dark"}
aireserve gpu clusters terminate <cluster-id> --wait
```

Terminate is always accepted, even mid-provision. If payment grace expires on
an unpaid hour, the cluster is terminated (not stopped); the shared volume is
kept.

## Recover a degraded cluster

A cluster that loses a node after it was admitted goes `degraded` and keeps
billing at the locked rate until you act. By default AI Reserve leaves it for
you. Opt into automatic recovery per cluster:

```bash theme={"dark"}
aireserve gpu clusters recovery <cluster-id> --mode restart --max-attempts 3 --cooldown-minutes 5
```

On the next health pass every node that is not running is brought back one by
one through the provider's own restart or start, on the same hardware, with
the same interconnect address. Healthy nodes, the shared volume and the rate
are untouched, so a distributed job that tolerates a node restart can resume
without a relaunch. Attempts are bounded per unhealthy episode exactly as for
instances, the `recovery` object on the cluster reports the episode, and
`nodes[].status` shows each member. Make one attempt now with:

```bash theme={"dark"}
aireserve gpu clusters recover <cluster-id> --wait
```

A node the provider cannot bring back is skipped and the attempt resolves on
the remaining nodes; once every attempt is spent the cluster stays `degraded`
with `lastError: recovery_exhausted` and terminate is the way out.

## Pricing

```
usdPerHour = gpusPerNode × nodes × perGpuUsdPerHour + diskGbPerNode × nodes × rootDiskRate
```

Per-GPU pricing uses the provider's cluster rate, which differs from the
single-machine rate for the same accelerator. The whole cluster accrues hourly
while any node runs, at the rate locked in the quote.

## Errors

| When | Error | What to do |
| - | - | - |
| At quote | `409 no_capacity` with `reason` and the shape | Try fewer GPUs per node, another region, or a higher ceiling |
| At launch | `409 price_changed` | Request a fresh quote |
| At launch | `403 quota_exceeded` | Nodes count as machines and every GPU counts; raise org limits |
| After accept | operation `failed`, `provider_rejected:no_capacity` | Every node could not be placed together after retries; nothing billed. Re-quote |
| After accept | operation `failed`, `provider_rejected:validation` | The image or request was refused; fix and relaunch |


# GPU Infrastructure
Source: https://docs.aireserve.com/gpu-infrastructure/index

Provision raw GPU compute with predictable pricing, durable operations, and provider-neutral controls.

GPU Infrastructure gives you a container on dedicated GPU capacity for training,
batch jobs, development, and self-hosted services. Choose the accelerator and
spending boundary; AI Reserve handles provider placement, current stock, and
price checks.

> **[Launch your first GPU](/gpu-infrastructure/quickstart)**
>
> Quote, launch, connect over SSH, and clean up safely.

> **[Serve a frontier model](/gpu-infrastructure/playbooks)**
>
> Follow versioned GLM, Kimi, and DeepSeek deployment playbooks from weights to production acceptance.

> **[Configure an instance](/gpu-infrastructure/launch-instances)**
>
> Choose hardware, region, image, ports, and storage.

> **[Connect and manage](/gpu-infrastructure/manage-instances)**
>
> Inspect state, retrieve connections, stream logs, and control lifecycle.

> **[Keep files between runs](/gpu-infrastructure/storage)**
>
> Understand ephemeral root disks and persistent volumes.

> **[Launch a cluster](/gpu-infrastructure/clusters)**
>
> Run large models across interconnected GPU nodes with one quote and lifecycle.

## Pick the right GPU product

| You need | Use | What you manage |
| - | - | - |
| A GPU machine for training, development, batch work, or a custom service | **GPU Infrastructure** | Container image, files, ports, connections, and lifecycle |
| A model served behind an OpenAI-compatible inference endpoint | [**Dedicated GPU endpoints**](/capabilities/dedicated-gpu-endpoints) | Model and deployment lifecycle; AI Reserve manages the serving endpoint |
| 2–8 interconnected machines for distributed training or a model that does not fit one node | [**Multi-node clusters**](/gpu-infrastructure/clusters) | Same as an instance, applied to every node; one shared volume |

GPU Infrastructure is raw compute. It does not autoscale your application or
turn a container into a managed inference API.

## The core workflow

**Request → quote → launch.** Describe the accelerator, region, spending
boundary, and storage lifecycle you need. AI Reserve returns the complete hourly
price before creating anything, then exposes connection and lifecycle controls
through one normalized instance resource.

Follow the [quickstart](/gpu-infrastructure/quickstart) for a complete SSH
round trip, or read [Configure and launch](/gpu-infrastructure/launch-instances)
for every request control and quote caveat.

Deploying open weights? Start with the
[frontier model serving playbooks](/gpu-infrastructure/playbooks) for pinned
artifacts, model-specific runtimes, behavioral tests, and the production
acceptance bar.

## What stays stable

The Instances API uses provider-independent accelerator and region names.
Adding another infrastructure backend does not change the request shape or your
resource IDs. Instance responses intentionally expose normalized lifecycle,
storage, price, and connection information rather than provider placement IDs.

| Surface | Start here |
| - | - |
| CLI | `aireserve gpu instances` with `quote`, `launch`, `list`, `get`, `connections`, `start`, `stop`, or `terminate` |
| REST | `/v1/gpu/instances`, `/v1/gpu/instances/quote`, and `/v1/gpu/operations/{operationId}` |
| Storage | `aireserve gpu volumes` with `list`, `create`, `get`, `grow`, or `delete`; REST uses `/v1/gpu/volumes` |
| Clusters | `aireserve gpu clusters` with `quote`, `launch`, `list`, `get`, `connections`, `logs`, or `terminate`; REST uses `/v1/gpu/clusters` |
| Reference | Generated request and response schemas under [API Reference](/api-reference) |

> [!WARNING]
>
> Running instances accrue compute charges. Persistent volumes accrue storage charges until you delete them, including
> while detached or while an instance is stopped.


# Configure and launch
Source: https://docs.aireserve.com/gpu-infrastructure/launch-instances

Choose accelerator, region, image, networking, and storage without binding your integration to one provider.

An instance request describes the outcome you need. AI Reserve maps that
request to eligible infrastructure, chooses a location, and returns a
normalized resource.

## Quote first

The recommended workflow is **request → quote → launch**:

```bash theme={"dark"}
aireserve gpu instances quote \
  --accelerator H100_80GB \
  --count 1 \
  --region europe \
  --persistent-gb 200
```

A quote:

* runs the same placement selection used by a direct launch;
* includes GPU, root-disk, and requested persistent-storage prices;
* shows what continues billing after stop or termination;
* creates and charges nothing;
* expires after 120 seconds and does not reserve capacity.

Launch the priced configuration and add workload-only settings:

```bash theme={"dark"}
aireserve gpu instances launch \
  --quote-id <quote-id> \
  --name trainer-01 \
  --env-file ./trainer.env \
  --ssh-public-key-file ~/.ssh/id_ed25519.pub \
  --wait
```

Hardware, region, root disk, image, and storage stay as quoted. If their price
changes before acceptance, launch fails with `price_changed` and creates
nothing. Request a fresh quote.

## Launch without a quote

For automation that already has a spending policy, launch directly with a
ceiling:

```bash theme={"dark"}
aireserve gpu instances launch \
  --accelerator H100_80GB \
  --max-hourly-price 3.50 \
  --ssh-public-key-file ~/.ssh/id_ed25519.pub \
  --wait
```

The ceiling applies to the new running commitment: GPU, ephemeral root disk,
and any persistent storage created by this request. The launch is refused
before provisioning when no eligible placement fits.

## Request controls

| CLI flag | REST field | Default | Purpose |
| - | - | - | - |
| `--accelerator` | `accelerator` | Required unless launching from a quote | Stable accelerator ID |
| `--count` | `count` | `1` | GPUs in one instance |
| `--region` | `region` | Any eligible region | Geographic requirement |
| `--max-hourly-price` | `maxHourlyPrice` | None | Required for direct launch; maximum new running commitment |
| `--disk-gb` | `diskGb` | `50` | Ephemeral root disk in GiB |
| `--persistent-gb` | `storage.persistentGb` | None | Create a persistent volume beside the GPU |
| `--volume-id` | `volumeId` | None | Attach an existing volume and pin placement to its location |
| `--mount-path` | `storage.mountPath` or `volumeMountPath` | `/workspace` | Persistent-storage mount path |
| `--image` | `image` | Maintained PyTorch/CUDA image | Docker-compatible image reference |
| `--name` | `name` | Generated | Human-readable name |
| `--ssh-public-key-file` | `sshPublicKey` | None | Inject one public key and open SSH |
| `--ssh-key-id` | `sshKeyIds` | `[]` | Inject registered organization keys |
| `--registry-id` | `registryCredentialId` | None | Stored private-registry credential |
| `--env-file` | `env` | `{}` | Write-only environment values |
| `--docker-start-cmd` | `dockerStartCmd` | Image default | JSON string array passed to the image's entrypoint |
| `--port` | `ports` | `[]` | Expose an HTTP or TCP port |

`--persistent-gb` and `--volume-id` are mutually exclusive. If you provide both
`region` and an existing volume, the region must include the volume's location.
AI Reserve rejects a contradiction rather than moving the volume.

## Accelerator IDs

Use an AI Reserve accelerator family such as `H100_80GB`, not a provider catalog
name. The generated [API Reference](/api-reference) is the source of truth for
the currently accepted enum; provider-specific SKUs can map into one stable
family.

## Custom images and secrets

```bash theme={"dark"}
aireserve gpu instances quote \
  --accelerator A100_80GB \
  --image ghcr.io/acme/trainer:2026-10-01

aireserve gpu instances launch \
  --quote-id <quote-id> \
  --env-file ./trainer.env \
  --registry-id <registry-credential-id> \
  --wait
```

Environment values are accepted at launch and are never returned. The
normalized instance resource does not currently expose their key names. Use a
[stored registry credential](/gpu-infrastructure/supporting-resources#private-container-registries)
for private images instead of placing a registry password in an environment
variable.

## Model-serving containers

The provider-hidden API can launch any compatible container without adding a
model-specific preset. Pass simple image arguments as a JSON string array.
The current backend serializes that array into the provider's command field,
so put complex shell logic in the image or a mounted script instead of relying
on quoting here:

```bash theme={"dark"}
aireserve gpu instances launch \
  --accelerator H200_141GB \
  --count 8 \
  --max-hourly-price 60 \
  --image vllm/vllm-openai:<pinned-version> \
  --docker-start-cmd '["--model","<hub-owner>/<model>","--tensor-parallel-size","8"]' \
  --env-file ./model.env \
  --wait
```

Pin an image version or digest. The exact model revision, quantization,
parallelism, CUDA compatibility, and memory requirement are workload choices;
AI Reserve does not infer them from the model name. An instance reaching
`running` confirms the requested infrastructure is present, not that the
model server has loaded its weights. Watch
`aireserve gpu instances logs <instance-id> --follow` for startup. The stock
vLLM image does not provide SSH or an authenticated health route, so this
private launch is not yet a production endpoint. To serve traffic, package an
authenticating proxy in your image, expose the proxy rather than vLLM
directly, and probe that authenticated proxy before admitting traffic.

## Public services

Expose an HTTP port only when the process inside the container enforces its own
authentication:

```bash theme={"dark"}
aireserve gpu instances launch \
  --accelerator A40_48GB \
  --max-hourly-price 1.00 \
  --port 8000/http \
  --public-ports-acknowledged \
  --wait
```

The explicit acknowledgement is required for HTTP ports. Retrieve public URLs
with `aireserve gpu instances connections <instance-id>` after the instance is
running.

## Direct REST

The CLI maps to `POST /v1/gpu/instances/quote` and
`POST /v1/gpu/instances`. Launch mutations require an `Idempotency-Key` and
return `202 Accepted` with `operationId` and `resourceId`. Use the generated
[API Reference](/api-reference) for exact schemas and [Operations, pricing, and
errors](/gpu-infrastructure/operations) for reliable polling and retry behavior.


# Connect and manage
Source: https://docs.aireserve.com/gpu-infrastructure/manage-instances

Inspect state, retrieve connection details, stream logs, and control the instance lifecycle.

Instance mutations are asynchronous. Add `--wait` when you want the CLI to poll
the returned operation until it succeeds, fails, or is cancelled.

## Inspect your instances

```bash theme={"dark"}
aireserve gpu instances list
aireserve gpu instances get <instance-id>
```

`get` shows normalized state, accelerator, region, price, storage, and lifecycle
capabilities. It intentionally omits provider resource IDs and placement IDs.
Use capability flags instead of assuming every future backend supports the same
actions.

## Connect over SSH or HTTP

```bash theme={"dark"}
aireserve gpu instances connections <instance-id>
```

Connections are available after the instance is running. The response contains
a structured SSH command when SSH was configured and public HTTP URLs for any
HTTP ports requested at launch.

* AI Reserve stores public SSH keys, never private keys.
* Public HTTP applications must implement their own authentication.
* The normalized connection response does not expose raw provider connection
  objects.

## Stream workload logs

The normalized REST API exposes a transient server-sent event stream:

```bash theme={"dark"}
aireserve gpu instances logs <instance-id> --follow
```

or directly:

```bash theme={"dark"}
curl -N "https://api.aireserve.com/v1/gpu/instances/<instance-id>/logs?tail=200" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Accept: text/event-stream"
```

Each event contains a timestamp, source, and line. AI Reserve relays active
workload output and does not maintain a workload-log archive.

A single stream response lasts at most 270 seconds. When that window ends the
relay sends a standard SSE `retry:` hint and closes the connection cleanly; the
pod and its logs are unaffected. Reconnect with the `Last-Event-ID` header set
to the last `id:` you received and the stream resumes from that point.
The `aireserve gpu instances logs --follow` CLI mode implements this
reconnect contract for you, as does the Python SDK's `instances.logs(...)`
iterator (aireserve-sdk 0.8.1 and later). The TypeScript SDK does not yet
expose a GPU logs helper, so there use the REST stream and implement the
reconnect loop in your client. An `event: error` frame is sent only when the
provider stream itself fails. Any client must preserve `Last-Event-ID`; do not
treat a normal 270-second close as workload failure.

## Stop and start

```bash theme={"dark"}
aireserve gpu instances stop <instance-id> --wait
aireserve gpu instances start <instance-id> --wait
```

Stopping an instance:

* releases GPU compute;
* stops compute accrual after the stop is confirmed;
* destroys the ephemeral root disk on the current backend;
* keeps an attached persistent volume and its storage billing;
* does not reserve GPU capacity for the next start.

A later start can fail when compatible capacity is unavailable. Check the
instance's `capabilities.start`, `capabilities.stop`, and
`capabilities.stopPreservesRootDisk` fields before automating lifecycle actions.

## Recover an instance that stopped on its own

An instance that was running and then left `running` without a stop from you
(the container exited, the provider reported an error) stays where the
provider put it. By default AI Reserve leaves it for you: `status` reads
`stopped` or `failed`, `desiredState` stays `running`, and nothing is billed
for a released accelerator.

Opt into automatic recovery per instance:

```bash theme={"dark"}
aireserve gpu instances recovery <instance-id> --mode restart --max-attempts 3 --cooldown-minutes 5
```

With `mode: restart`, the next health pass restarts the container in place
when the machine is still allocated, or starts the instance again on the same
hardware when it was released, up to `maxAttempts` times per unhealthy
episode and no more often than every `cooldownMinutes`. Recovery never
relaunches on different hardware, never re-quotes, and never changes the
locked rate. The episode counter resets once the instance is observed running
again.

Read where it stands on the instance:

```json theme={"dark"}
"recovery": {
  "policy": { "mode": "restart", "maxAttempts": 3, "cooldownMinutes": 5 },
  "attempts": 1,
  "maxAttempts": 3,
  "lastAttemptAt": "2026-10-14T18:40:00.000Z",
  "lastOutcome": "recovering"
}
```

| `lastOutcome` | Meaning |
| - | - |
| `recovering` | An attempt is in flight; the instance is starting |
| `recovered` | The last attempt brought it back; the counter resets on the next healthy pass |
| `failed` | The last attempt did not bring it back; another follows after the cooldown |
| `exhausted` | Every attempt was spent; `lastError` reads `recovery_exhausted` and the instance waits |

Make one attempt now, regardless of the cooldown and the cap:

```bash theme={"dark"}
aireserve gpu instances recover <instance-id> --wait
```

It counts toward the episode and answers `409 operation_conflict` when the
instance is running, was never admitted, or another operation is in flight.
Turn automatic recovery off with `--mode none`.

## Terminate

```bash theme={"dark"}
aireserve gpu instances terminate <instance-id> --yes --wait
```

Termination is irreversible. It releases the accelerator and destroys the root
disk. An attached persistent volume survives, remains attached in the resource
model until termination completes, and continues billing until you delete it.

```bash theme={"dark"}
aireserve gpu volumes delete <volume-id> --yes --wait
```

## Resume after a process restart

Save the operation ID when your process may exit before a mutation completes.
[Operations, pricing, and errors](/gpu-infrastructure/operations#wait-for-completion)
shows how to retrieve and resume it. Resource and action labels currently retain
some legacy `pod` terminology; treat the operation ID and status as the stable
integration points.


# Migrate from RunPod
Source: https://docs.aireserve.com/gpu-infrastructure/migrate-from-runpod

Move a common secure, on-demand GPU Pod workflow to AI Reserve and understand where the contracts differ.

AI Reserve GPU Instances is a provider-neutral compute contract, not a
wire-compatible RunPod API. The common single-container GPU workflow maps
cleanly, but request fields, IDs, operation polling, and response models change.

## A common request

A secure, on-demand RunPod request conceptually like:

```json theme={"dark"}
{
  "name": "trainer",
  "gpu": { "id": "NVIDIA H100 80GB HBM3", "count": 1 },
  "image": "ghcr.io/acme/trainer:latest",
  "disk": 100,
  "env": { "RUN_NAME": "experiment-42" },
  "ports": ["8000/http"]
}
```

becomes this AI Reserve request:

```json theme={"dark"}
{
  "name": "trainer",
  "accelerator": "H100_80GB",
  "count": 1,
  "image": "ghcr.io/acme/trainer:latest",
  "diskGb": 100,
  "env": { "RUN_NAME": "experiment-42" },
  "ports": [{ "port": 8000, "protocol": "http" }],
  "publicPortsAcknowledged": true,
  "maxHourlyPrice": "4.00"
}
```

The exact RunPod GPU SKU and data center are deliberately absent. AI Reserve
selects eligible secure capacity and returns its own resource ID.

## Call-flow changes

| Direct RunPod pattern | AI Reserve pattern |
| - | - |
| Create a Pod and receive the provider resource | Quote optionally, then launch and receive `202 Accepted` |
| Store a RunPod Pod ID | Store the AI Reserve instance UUID and operation ID |
| Poll provider Pod status | Poll `/v1/gpu/operations/{operationId}`, then fetch the instance |
| Read connections from provider metadata | Call `/v1/gpu/instances/{id}/connections` |
| Retry create according to client policy | Reuse the same `Idempotency-Key` after an ambiguous result |
| Compare provider status enums | Use normalized desired and observed instance states |

The CLI's `--wait` flag handles operation polling. Follow the
[quickstart](/gpu-infrastructure/quickstart) for the complete command sequence.

## Field mapping

| RunPod concept | AI Reserve | Notes |
| - | - | - |
| Exact GPU product | `accelerator` | Canonical family such as `H100_80GB`; exact provider SKU is abstracted |
| GPU count | `count` | Supported from 1 through 16, subject to current stock |
| Data center | `region` | Optional broad region; exact placement remains internal |
| Container image | `image` | Supported |
| Container disk | `diskGb` | Ephemeral root disk |
| Network volume | `volumeId` | Existing volume pins placement to its location |
| New network volume | `storage.persistentGb` | AI Reserve can create it beside the GPU in the same launch |
| Environment | `env` | Write-only values |
| Ports | `{port, protocol}` objects | HTTP requires `publicPortsAcknowledged: true` |
| Registry credential | `registryCredentialId` | Register an AI Reserve credential; provider IDs are not reusable |
| SSH | `sshPublicKey` or `sshKeyIds` | Register with AI Reserve or inject a public key at launch |
| Price policy | `maxHourlyPrice` | Decimal string; bounds the new running commitment |

## What AI Reserve adds

* placement and fallback across mapped provider capacity;
* an optional non-spending quote with a complete price breakdown;
* storage-aware placement and inline persistent-volume creation;
* durable operations and idempotent mutations;
* normalized capacity refusals with a reason and alternatives;
* wallet, quota, and Compute-key policy at one API boundary.

## Provider-specific features not currently normalized

A migration needs redesign—or may not be possible yet—when it depends on:

* Community Cloud or spot/interruptible bids;
* CPU Pods;
* exact GPU SKU, country, data center, or compliance placement;
* minimum host RAM, vCPU, CUDA version, or bandwidth constraints;
* RunPod template IDs, provider-managed Jupyter startup, or Pod locks;
* global networking or private Pod DNS (Instant Clusters are normalized as [multi-node clusters](/gpu-infrastructure/clusters); cluster templates and rename are not);
* local persistent Pod disks or high-performance network-volume tiers;
* in-place Pod updates or a normalized restart endpoint;
* provider runtime metrics or complete launch-configuration read-back.

The normalized API accepts a deliberately smaller set of portable controls. It
does not currently offer a `providerOptions.runpod` escape hatch.

## Storage differences

Both products preserve an independent network volume after compute termination.
AI Reserve additionally places new storage with the GPU and exposes its
post-termination rate in the instance quote. It does not normalize RunPod's
exact data-center selection, volume tiers, or volume rename. See [Storage and
persistence](/gpu-infrastructure/storage) for attachment, billing, teardown,
and the transitional grow flow.

## Migration checklist

* [ ] Map each required RunPod GPU SKU to an AI Reserve accelerator family.
* [ ] Remove exact provider and data-center dependencies, or record them as blockers.
* [ ] Replace create-response assumptions with operation polling.
* [ ] Persist AI Reserve instance and operation IDs instead of RunPod IDs.
* [ ] Add idempotency keys to every mutation.
* [ ] Convert ports and decimal price fields to the normalized shapes.
* [ ] Register SSH keys and registry credentials in AI Reserve.
* [ ] Rework status comparisons and connection discovery.
* [ ] Confirm storage teardown explicitly deletes volumes when intended.
* [ ] Test one paid instance end to end before migrating automation.

For the provider-shaped compatibility API, see [GPU Compute](/capabilities/gpu-compute).
New integrations should use GPU Instances.


# Operations, pricing, and errors
Source: https://docs.aireserve.com/gpu-infrastructure/operations

Build reliable automation around asynchronous mutations, quote expiry, retries, and capacity refusals.

Every infrastructure mutation returns `202 Accepted` with an operation ID and
resource ID. The mutation has been durably accepted; the resource is not
necessarily ready yet.

Acceptance is a promise, not a receipt. A create has exactly three outcomes:

| Outcome | What you get | Whose action |
| - | - | - |
| Refused synchronously | `4xx`/`5xx` with an error code; **no resource id, nothing exists, nothing bills** | Named by the error code (see below) |
| Accepted | `202` with a resource id the provider will honor; poll the operation | Yours to wait on |
| Failed after acceptance | operation `failed` with `errorMessage` and a structured `failure` | `failure.actor` says who |

Before accepting, AI Reserve checks what it can know up front: your wallet,
your Compute limits, placement, **and its own standing with the infrastructure
provider**. A request the provider is certain to refuse for a reason that is
AI Reserve's — not yours — is answered `503 provider_unavailable` with
`details.actor: "platform"` and a `details.reference` to quote to support,
instead of a `202` that could only fail. Nothing of yours needs to change;
retry later with the same `Idempotency-Key`.

## Wait for completion

```bash theme={"dark"}
aireserve gpu operations get <operation-id>

aireserve gpu operations wait <operation-id> --timeout-sec 600
```

Terminal statuses are `succeeded`, `failed`, and `cancelled`. Save the operation
ID when your process may restart. Intermediate reconciliation details are not a
stable API contract; key automation off operation status and the final resource.

A terminal `failed` or `cancelled` operation carries `failure`, a structured
reading of `errorMessage` so you never parse `provider_rejected:<code>` by hand:

```json theme={"dark"}
{
  "status": "failed",
  "errorMessage": "provider_rejected:no_capacity",
  "failure": {
    "code": "provider_rejected:no_capacity",
    "actor": "provider",
    "message": "The infrastructure provider could not place the request: no capacity for this shape right now. Nothing was created.",
    "next": "Request a fresh quote, perhaps for another region or shape."
  }
}
```

| `failure.actor` | Meaning | What to do |
| - | - | - |
| `customer` | The request itself was refused (an image tag that does not exist, an invalid field) | Fix it and launch again with a new key |
| `provider` | Nothing to fix; the provider could not serve the shape right now | Re-quote, perhaps another region or shape |
| `platform` | AI Reserve's own standing or credentials with the provider; nothing about your request is wrong | Retry later, or contact support with the operation id |

Nothing is billed for a failed create in any of the three cases.

## Retry safely with idempotency

The CLI derives an idempotency key for instance launch and creates keys for
other mutations. For direct REST calls, send your own unique key:

```http theme={"dark"}
Idempotency-Key: instance-launch-01J...
```

* Reusing a key with the same accepted request returns the original receipt.
* Reusing it with a different request fails with `operation_conflict`.
* Two intentional launches require two different keys.
* Inline persistent storage and the instance are recorded under one key, so a
  transport retry cannot create an extra volume.

Keep the same key across network retries. Do not derive a new key after an
ambiguous timeout.

## Quote semantics

`POST /v1/gpu/instances/quote` creates and charges nothing. It records the
configuration and price selected at that moment and expires after 120 seconds.
A quote is not a capacity reservation.

At launch, AI Reserve rechecks the price and current resource state:

* `price_changed`: request a fresh quote;
* `quote_expired`: request a fresh quote;
* `volume_in_use`: wait for the current attachment to terminate;
* provider capacity may still disappear before provisioning completes.

Launching from a refreshed quote is a new CLI intent unless you explicitly
reuse the original `--idempotency-key` for the same ambiguous launch attempt.

## Common errors

| Error code | Meaning | What to do |
| - | - | - |
| `no_capacity` | The request cannot be placed; `details.reason` explains why | Follow the reason and alternatives below |
| `volume_in_use` | The volume is not ready or remains attached | Terminate the attached instance and wait, or choose another volume |
| `price_changed` | Current price differs from the quoted price or a priced field was changed | Request a new quote |
| `quote_expired` | The quote is expired or malformed | Request a new quote |
| `insufficient_funds` | The organization wallet cannot cover the new exposure | Fund or enable the wallet |
| `quota_exceeded` | The request exceeds Compute limits | Reduce the request or ask an admin to adjust limits |
| `operation_conflict` | Another mutation is active or an idempotency key conflicts | Wait, or use a new key for a new intent |
| `compute_access_required` | The API key lacks Compute Manage access | Update or replace the key |
| `provider_unavailable` | The infrastructure control plane is unavailable, or AI Reserve's provider account cannot take the order (`details.actor: "platform"`) | Retry later with the same idempotency key; quote `details.reference` to support if it persists |

## `no_capacity` reasons

A `409 no_capacity` response does not name a provider or data center. It carries
customer-actionable details:

| `details.reason` | Meaning | What to change |
| - | - | - |
| `price_ceiling` | Eligible capacity exists above the ceiling | Raise to at least `cheapestEligibleUsdPerHour` |
| `volume_location` | An existing volume pins placement where no eligible capacity fits | Raise the ceiling, or request new storage in an alternative region |
| `no_persistent_storage` | Matching GPU capacity cannot create the requested persistent storage | Use ephemeral storage or another region |
| `no_stock` | No matching accelerator/count is currently for sale | Change region, accelerator, or count and quote again |

```json theme={"dark"}
{
  "error": {
    "code": "no_capacity",
    "message": "No 1 x H100_80GB capacity can mount this volume within $3.00/hr.",
    "details": {
      "reason": "volume_location",
      "volumeRegion": "europe",
      "cheapestEligibleUsdPerHour": "3.420000",
      "alternatives": [
        {
          "region": "united_states",
          "totalRunningUsdPerHour": "2.890000"
        }
      ]
    }
  }
}
```

The CLI prints the reason, the cheapest eligible rate when known, and a suggested
next command. The current standalone SDKs expose generic API errors and do not
retain structured capacity details; inspect the REST error envelope when you
need the full refusal payload.

## Clusters: refusals after acceptance

A cluster quote reports stock for one node of the requested shape. Whether
every node can be placed together on one interconnect is known only when the
provider creates the cluster, so a `202 Accepted` launch can still end with
the operation `failed` and `errorMessage` `provider_rejected:no_capacity`.
Nothing is billed; request a fresh quote. Cluster operations are
`cluster_create` and `cluster_terminate`; there is no stop.

## Understand the price ceiling

For a direct launch, `maxHourlyPrice` bounds the new running commitment:

```text theme={"dark"}
GPU + ephemeral root disk + persistent storage created by this request
```

An existing volume is already billing independently. Its rate appears in the
quote but does not count against the new-compute ceiling.

## Billing timeline

* Compute accrues from confirmed readiness through confirmed stop or
  termination; final partial intervals are prorated.
* A stopped instance does not accrue GPU compute.
* A persistent volume accrues from volume creation until successful deletion.
* Inline storage can begin billing before its instance reaches `running` because
  the volume is provisioned first.

Review charge history with:

```bash theme={"dark"}
aireserve gpu usage
```


# Frontier model serving playbooks
Source: https://docs.aireserve.com/gpu-infrastructure/playbooks

Versioned deployment blueprints for serving frontier open-weight models on dedicated GPUs.

These playbooks turn a model release into an auditable serving recipe: exact
weights, hardware, runtime, launch flags, functional checks, load tests, and
operating limits. They cover the full path from an empty GPU allocation to an
authenticated OpenAI-compatible endpoint.

> [!WARNING]
>
> These are vendor-verified reference recipes, not AI Reserve performance
> certifications. Each page names what upstream maintainers verified and what
> still needs qualification on AI Reserve. Do not advertise a throughput,
> concurrency, or full-context service level until your exact recipe passes the
> acceptance run on the hardware you will operate.

> [!NOTE]
>
> Every playbook opens with **0. Set up your shell**: paste one block, replace
> only `AIRESERVE_API_KEY`, and every later command runs as written. Commands
> print the API's error body instead of a bare status code, and each step
> checks that it created what it claims before you continue.

> **[GLM-5.3](/gpu-infrastructure/playbooks/glm-5-3)**
>
> Native FP8 on 8×H200 with vLLM, GLM reasoning and tool parsers, and a 1M-token architecture window.

> **[Kimi K3](/gpu-infrastructure/playbooks/kimi-k3)**
>
> Native multimodal MXFP4/MXFP8 on 8×B300 with SGLang and preserved thinking history.

> **[DeepSeek V4 Pro 0813](/gpu-infrastructure/playbooks/deepseek-v4-pro-0813)**
>
> The released V4 Pro checkpoint on 8×H200 with vLLM, DeepSeek V4 encoding, and DSpark.

> **[DeepSeek V4.1 Flash](/gpu-infrastructure/playbooks/deepseek-v4-1-flash)**
>
> The released V4.1 model on 8×H200 with a V4.1-capable vLLM image and optional vision.

## Status vocabulary

Every page uses the same evidence labels:

| Label | Meaning |
| - | - |
| **Available now** | The documented AI Reserve REST operation exists today. |
| **Manual today** | The operator must perform or automate the step inside the workload; AI Reserve has no managed resource for it yet. |
| **Platform gap** | A production capability is required but is not currently provided by the Compute API or official SDKs. |
| **Vendor-verified** | The model or engine maintainer documents this artifact, topology, or behavior. AI Reserve has not independently certified it. |
| **AI Reserve verified** | Reserved for a pinned model revision and image digest that passed functional, long-context, and load acceptance on the named topology. None of these recipes has that status yet. |

The Python and TypeScript examples use the same public REST API as curl, so
they are executable now. An official `gpu` namespace for those SDKs is a
documented platform gap; the playbooks never present a future `client.gpu`
method as if it already ships.

### Target SDK ergonomics

> [!WARNING]
>
> **Target contract—not released code.** The official Python and TypeScript
> packages do not yet include these methods. Use the runnable HTTP tabs in the
> model playbooks today.

```python Python SDK target theme={"dark"}
from aireserve import AIReserve

client = AIReserve()
quote = client.gpu.instances.quote(
    accelerator="H200_141GB",
    count=8,
    volume_id=volume.id,
)
instance = client.gpu.instances.launch(quote_id=quote.id, recipe="glm-5.3").wait()
endpoint = instance.connections().http(port=8000)
```

```typescript TypeScript SDK target theme={"dark"}
import { AIReserve } from "@aireserve/sdk";

const client = new AIReserve();
const quote = await client.gpu.instances.quote({
  accelerator: "H200_141GB",
  count: 8,
  volumeId: volume.id,
});
const instance = await client.gpu.instances.launch({ quoteId: quote.id, recipe: "glm-5.3" }).wait();
const endpoint = await instance.connections.http({ port: 8000 });
```

## Pick the serving runtime

There is no universal image that safely serves every frontier checkpoint.
Architecture support often lands in an engine nightly before a stable release,
and parser names, CUDA requirements, kernels, and launch flags remain
model-specific.

| Runtime | Use it for | Do not assume |
| - | - | - |
| **vLLM** | OpenAI-compatible serving, continuous batching, tensor/expert parallelism, prefix caching, and engine-native benchmarks. It is the primary recipe for GLM-5.3 and both DeepSeek models here. | A stable image supports a newly released architecture, or one set of flags works across model generations. |
| **SGLang** | High-performance serving where its model cookbook has the stronger verified topology. It is the primary recipe for Kimi K3 here. | A floating `latest` image is reproducible, or every documented hardware path has completed final verification. |
| **Transformers / PyTorch** | Loading validation, prompt-encoding tests, conversion, and maintainer reference inference. | A production HTTP server, scheduler, batching policy, observability surface, or service-level objective. |
| **ComfyUI** | Node-based image and video generation workflows. | General LLM serving. It is not the serving runtime for any model in these playbooks. |

## Baseline matrix

| Model | Canonical artifact | Primary reference | Vendor-documented baseline used here | Important boundary |
| - | - | - | - | - |
| GLM-5.3 | `zai-org/GLM-5.3` | vLLM | 8×H200 141 GB | Text only; 1M context consumes substantial KV capacity. |
| Kimi K3 | `moonshotai/Kimi-K3` | SGLang | 8×B300 288 GB | Open checkpoint supports text and images; do not claim self-hosted video. |
| DeepSeek V4 Pro 0813 | `deepseek-ai/DeepSeek-V4-Pro-0813` | vLLM | 8×H200 141 GB, 800K configured context | Text only; `deepseek-v4-pro` is a mutable hosted alias, not an artifact revision. |
| DeepSeek V4.1 Flash | `deepseek-ai/DeepSeek-V4.1-Flash` | vLLM nightly | 8×H200 141 GB | V4.1 Flash is the only released V4.1 checkpoint; there is no plain DeepSeek V4.1 artifact. |

The hardware above is a starting topology, not a concurrency promise. A model
that fits in aggregate HBM can still miss latency targets because KV cache,
temporary buffers, communication, and long prompts need headroom.

## The production path

Each playbook follows the same sequence:

1. Review the model license and pin the model revision and serving image.
2. Quote persistent storage and GPU capacity before creating anything.
3. Stage the checkpoint onto a persistent volume and verify the snapshot.
4. Launch the serving workload with its model-specific engine contract.
5. Poll the durable operation, retrieve the protected HTTP URL, and warm the model.
6. Test normal chat, streaming, reasoning, tools, and supported modalities.
7. Sweep realistic traffic until the target TTFT, TPOT, throughput, and error-rate objectives fail.
8. Add the missing production layer—replicas, traffic draining, metrics, alerts, and rollback—before accepting customer traffic.
9. Terminate compute and explicitly delete storage when it is no longer needed.

For the API's quote, operation, idempotency, and retry behavior, read
[Operations, pricing, and errors](/gpu-infrastructure/operations). For
connection and lifecycle semantics, read
[Connect and manage](/gpu-infrastructure/manage-instances).

## What “industry-standard” means here

A successful `200` response is only a smoke test. A production acceptance
record should include:

* the model commit, engine image digest, driver/CUDA version, GPU topology, and all launch flags;
* tested input/output length buckets and the maximum context admitted in production;
* p50, p95, and p99 time to first token, inter-token latency, end-to-end latency, and queue time;
* input/output token throughput, request failures, OOMs, GPU/host memory, and KV/prefix-cache hit rate;
* tool-call validity, structured-output validity, reasoning-history behavior, and modality checks;
* speculation enabled and disabled against identical prompts, including accepted draft length;
* replica count, health policy, authentication, load-balancing behavior, drain timeout, rollback target, and alert thresholds.

Keep the acceptance record beside the deployment configuration. Re-run it
after any model revision, engine image, driver, kernel, quantization, topology,
or launch-flag change.


# Serve DeepSeek V4.1 Flash
Source: https://docs.aireserve.com/gpu-infrastructure/playbooks/deepseek-v4-1-flash

Provision 8×H200, pin the released V4.1 Flash checkpoint, and qualify text and image serving with a V4.1-capable vLLM nightly.

DeepSeek V4.1 Flash is the only released V4.1 checkpoint. There is no plain
`DeepSeek-V4.1` artifact and no released `DeepSeek-V4.1-Pro` checkpoint. This
playbook serves `deepseek-ai/DeepSeek-V4.1-Flash`.

> [!WARNING]
>
> **Vendor-verified · AI Reserve qualification pending.** The architecture is
> not served by a normal vLLM pip wheel. Use a vLLM 0.30-era nightly from
> 2026-09-10 or later, then pin the image digest that passes. Never let a
> floating `nightly` update in place under production traffic.

## Recipe contract

| Item | Pinned value |
| - | - |
| Artifact | `deepseek-ai/DeepSeek-V4.1-Flash` |
| Revision reviewed | `5254448103b6254fc646dacbca1cbbf20e9216c1` |
| Weights | Native MXFP4 experts + MXFP8 dense weights, FP8 Engram tables, BF16 embeddings; about 511 GB downloaded and about 614 GB runtime budget |
| Architecture | 552B backbone plus 196.6B Engram memory and DSpark drafter; 8B active in prefill / 16B in decode |
| Context | 1,048,576 architectural maximum |
| Primary engine | vLLM 0.30-era/nightly Docker; no supported normal pip wheel at review time |
| Reference image | `vllm/vllm-openai:nightly`; replace with a qualified digest dated 2026-09-10 or later |
| Hardware | 8×`H200_141GB` with weights resident; smaller H200 shapes require Engram host offload |
| Persistent storage | 800 GB minimum; use 1,000 GB when retaining rollback artifacts |
| Modalities | Text and images |
| License | MIT, ungated |
| Last reviewed | 2026-10-14 |

V4.1 uses a different tokenizer and parser contract from V4. Do not reuse
`deepseek_v4` flags: all three parser modes here are `deepseek_v41`.

## 0. Set up your shell

Every command on this page is copy-paste. Paste this block once per terminal
and replace only the API key; every later step reads these variables.

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # the only value you type: a key with Compute: Manage access
export API="https://api.aireserve.com"
export VLLM_API_KEY="$(openssl rand -hex 32)"  # generated for you; it protects your model server (see below)
echo "VLLM_API_KEY=$VLLM_API_KEY"               # save it: every request to the endpoint needs it
```

> [!NOTE]
>
> **Two keys, two jobs.** `AIRESERVE_API_KEY` authenticates you to AI Reserve
> and creates the volume, quote, and instance. `VLLM_API_KEY` is a password you
> invent for the vLLM server you are about to start: step 4 passes it as
> vLLM's `--api-key`, so the public HTTP port rejects anyone who does not
> send it. No vendor issues it and AI Reserve never sees it.

The Python and TypeScript tabs read the same three variables from the
environment. The shell tabs need `curl` and `jq`; the Python tabs need
`requests` (`python -m pip install requests`).

### Check stock first

A quote is free and creates nothing. Run one before creating storage, because
the volume in step 1 is placed next to this hardware and fails the same way
when none is in stock:

```bash theme={"dark"}
curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"accelerator": "H200_141GB", "count": 8, "region": "united_states", "image": "vllm/vllm-openai:nightly", "diskGb": 100}' \
  | jq '{availability, price, error}'
```

A response with `availability` and `price` means you can continue. An `error`
with `code: no_capacity` means this shape is not in stock in that region right
now: try another `region` here and in steps 1 and 2, or wait, and read
[`no_capacity` reasons](/gpu-infrastructure/operations#no_capacity-reasons).

## 1. Allocate the model volume

**Available now.** The accelerator hint places the volume in a data center
where 8×H200 has stock today, so the instance in step 4 can mount it. If step 0
reported no stock, this call fails the same way.

```bash curl theme={"dark"}
ACCEPTED=$(curl -sS -X POST "$API/v1/gpu/volumes" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: deepseek-v4-1-flash-weights-v1" \
  -d '{
    "name": "deepseek-v4-1-flash-weights",
    "region": "united_states",
    "sizeGb": 800,
    "acceleratorHint": "H200_141GB",
    "storageBillingAcknowledged": true
  }')
export VOLUME_ID=$(jq -r .resourceId <<<"$ACCEPTED")
export OPERATION_ID=$(jq -r .operationId <<<"$ACCEPTED")
jq -e .resourceId <<<"$ACCEPTED" >/dev/null \
  && echo "accepted: volume $VOLUME_ID (operation $OPERATION_ID)" \
  || { echo "The volume was not accepted:"; jq . <<<"$ACCEPTED"; }
```

```python Python theme={"dark"}
import os, requests, time

API = "https://api.aireserve.com"
AUTH = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

response = requests.post(
    f"{API}/v1/gpu/volumes",
    headers={**AUTH, "Idempotency-Key": "deepseek-v4-1-flash-weights-v1"},
    json={
        "name": "deepseek-v4-1-flash-weights",
        "region": "united_states",
        "sizeGb": 800,
        "acceleratorHint": "H200_141GB",
        "storageBillingAcknowledged": True,
    },
    timeout=60,
)
response.raise_for_status()
accepted = response.json()
volume_id = accepted["resourceId"]
operation_id = accepted["operationId"]
```

```typescript TypeScript theme={"dark"}
const API = "https://api.aireserve.com";
const auth = { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` };

const response = await fetch(`${API}/v1/gpu/volumes`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "deepseek-v4-1-flash-weights-v1",
  },
  body: JSON.stringify({
    name: "deepseek-v4-1-flash-weights",
    region: "united_states",
    sizeGb: 800,
    acceleratorHint: "H200_141GB",
    storageBillingAcknowledged: true,
  }),
});
if (!response.ok) throw new Error(await response.text());
const accepted = await response.json();
const volumeId = accepted.resourceId;
const operationId = accepted.operationId;
```

Wait for the operation to finish before you quote compute:

```bash curl theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

```python Python theme={"dark"}
def wait_for(operation_id):
    while True:
        operation = requests.get(f"{API}/v1/gpu/operations/{operation_id}", headers=AUTH, timeout=60).json()
        print("operation", operation_id, operation.get("status"))
        if operation.get("status") == "succeeded":
            return operation
        if operation.get("status") in {"failed", "cancelled"}:
            failure = operation.get("failure") or {}
            raise RuntimeError(f"{failure.get('actor', 'unknown')}: {failure.get('message', operation.get('errorMessage'))} {failure.get('next', '')}")
        time.sleep(10)

wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
async function waitFor(operationId: string) {
  while (true) {
    const response = await fetch(`${API}/v1/gpu/operations/${operationId}`, { headers: auth });
    const operation = await response.json();
    console.log("operation", operationId, operation.status);
    if (operation.status === "succeeded") return operation;
    if (["failed", "cancelled"].includes(operation.status)) {
      const failure = operation.failure ?? {};
      throw new Error(`${failure.actor ?? "unknown"}: ${failure.message ?? operation.errorMessage} ${failure.next ?? ""}`);
    }
    await new Promise((resolve) => setTimeout(resolve, 10_000));
  }
}

await waitFor(operationId);
```

## 2. Quote 8×H200

**Available now.** The quote binds the floating reference tag. For a real
release, replace it with the digest you qualified before requesting the quote.
A quote expires after 120 seconds, so run step 4 right after it; if it has
expired, run this step again.

```bash curl theme={"dark"}
QUOTE=$(curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"accelerator\": \"H200_141GB\",
    \"count\": 8,
    \"region\": \"united_states\",
    \"image\": \"vllm/vllm-openai:nightly\",
    \"diskGb\": 100,
    \"volumeId\": \"$VOLUME_ID\",
    \"volumeMountPath\": \"/models\"
  }")
export QUOTE_ID=$(jq -r .quoteId <<<"$QUOTE")
jq '{quoteId, expiresAt, availability, price, storage, error}' <<<"$QUOTE"
```

```python Python theme={"dark"}
response = requests.post(
    f"{API}/v1/gpu/instances/quote",
    headers=AUTH,
    json={
        "accelerator": "H200_141GB",
        "count": 8,
        "region": "united_states",
        "image": "vllm/vllm-openai:nightly",
        "diskGb": 100,
        "volumeId": volume_id,
        "volumeMountPath": "/models",
    },
    timeout=60,
)
response.raise_for_status()
quote = response.json()
quote_id = quote["quoteId"]
print(quote["price"], quote["availability"], quote["expiresAt"])
```

```typescript TypeScript theme={"dark"}
const quoteResponse = await fetch(`${API}/v1/gpu/instances/quote`, {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    accelerator: "H200_141GB",
    count: 8,
    region: "united_states",
    image: "vllm/vllm-openai:nightly",
    diskGb: 100,
    volumeId,
    volumeMountPath: "/models",
  }),
});
if (!quoteResponse.ok) throw new Error(await quoteResponse.text());
const quote = await quoteResponse.json();
const quoteId = quote.quoteId;
console.log(quote.price, quote.availability, quote.expiresAt);
```

## 3. Download the pinned artifact

**Manual today.** Use a loader with the persistent volume attached, or let
vLLM populate `HF_HOME` during first start. The verification command requires
the current `hf` CLI from `huggingface_hub` 1.18 or later, not the deprecated
`huggingface-cli`:

```bash theme={"dark"}
hf download deepseek-ai/DeepSeek-V4.1-Flash \
  --revision 5254448103b6254fc646dacbca1cbbf20e9216c1 \
  --local-dir /models/DeepSeek-V4.1-Flash

hf cache verify deepseek-ai/DeepSeek-V4.1-Flash \
  --revision 5254448103b6254fc646dacbca1cbbf20e9216c1 \
  --local-dir /models/DeepSeek-V4.1-Flash \
  --fail-on-missing-files
```

No official BF16, GPTQ, AWQ, or GGUF production artifact is part of this
recipe. Treat every conversion as a separate model requiring task-quality,
vision, long-context, tool, and latency acceptance.

## 4. Launch the V4.1 server

**Available now, runtime qualification pending.** This starts target-only
serving with the vision tower enabled. DSpark comes later, after the target
baseline passes. The eight-GPU topology keeps Engram resident instead of
depending on host-memory offload.

```bash curl theme={"dark"}
LAUNCH=$(jq -n \
  --arg quoteId "$QUOTE_ID" \
  --arg apiKey "$VLLM_API_KEY" \
  '{
    quoteId: $quoteId,
    name: "deepseek-v4-1-flash-vllm",
    env: {
      HF_HOME: "/models/hf",
      VLLM_ENGINE_READY_TIMEOUT_S: "3600",
      VLLM_USE_RUST_FRONTEND: "1"
    },
    ports: [{port: 8000, protocol: "http"}],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "--model=deepseek-ai/DeepSeek-V4.1-Flash",
      "--revision=5254448103b6254fc646dacbca1cbbf20e9216c1",
      "--served-model-name=deepseek-v4.1-flash",
      "--host=0.0.0.0", "--port=8000",
      "--api-key=\($apiKey)",
      "--tensor-parallel-size=8",
      "--tokenizer-mode=deepseek_v41",
      "--attention-config={\"backend\":\"FLASHINFER_MLA_SPARSE_DSV41\",\"indexer_kv_dtype\":\"mxfp4\",\"indexer_sparse_logits\":true}",
      "--kv-cache-dtype=fp8",
      "--max-model-len=1048576",
      "--max-num-seqs=128",
      "--engram-config={\"cpu_offload\":false}",
      "--tool-call-parser=deepseek_v41",
      "--enable-auto-tool-choice",
      "--reasoning-parser=deepseek_v41",
      "--mm-encoder-tp-mode=data"
    ]
  }' | curl -sS -X POST "$API/v1/gpu/instances" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "Idempotency-Key: deepseek-v4-1-flash-serve-v1" \
    --data-binary @-)
export INSTANCE_ID=$(jq -r .resourceId <<<"$LAUNCH")
export OPERATION_ID=$(jq -r .operationId <<<"$LAUNCH")
jq -e .resourceId <<<"$LAUNCH" >/dev/null \
  && echo "accepted: instance $INSTANCE_ID (operation $OPERATION_ID)" \
  || { echo "The launch was not accepted:"; jq . <<<"$LAUNCH"; }
```

```python Python theme={"dark"}
command = [
    "--model=deepseek-ai/DeepSeek-V4.1-Flash",
    "--revision=5254448103b6254fc646dacbca1cbbf20e9216c1",
    "--served-model-name=deepseek-v4.1-flash",
    "--host=0.0.0.0", "--port=8000",
    f"--api-key={os.environ['VLLM_API_KEY']}",
    "--tensor-parallel-size=8",
    "--tokenizer-mode=deepseek_v41",
    '--attention-config={"backend":"FLASHINFER_MLA_SPARSE_DSV41","indexer_kv_dtype":"mxfp4","indexer_sparse_logits":true}',
    "--kv-cache-dtype=fp8",
    "--max-model-len=1048576",
    "--max-num-seqs=128",
    '--engram-config={"cpu_offload":false}',
    "--tool-call-parser=deepseek_v41",
    "--enable-auto-tool-choice",
    "--reasoning-parser=deepseek_v41",
    "--mm-encoder-tp-mode=data",
]
response = requests.post(
    f"{API}/v1/gpu/instances",
    headers={**AUTH, "Idempotency-Key": "deepseek-v4-1-flash-serve-v1"},
    json={
        "quoteId": quote_id,
        "name": "deepseek-v4-1-flash-vllm",
        "env": {
            "HF_HOME": "/models/hf",
            "VLLM_ENGINE_READY_TIMEOUT_S": "3600",
            "VLLM_USE_RUST_FRONTEND": "1",
        },
        "ports": [{"port": 8000, "protocol": "http"}],
        "publicPortsAcknowledged": True,
        "dockerStartCmd": command,
    },
    timeout=60,
)
response.raise_for_status()
launched = response.json()
instance_id = launched["resourceId"]
operation_id = launched["operationId"]
wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
const command = [
  "--model=deepseek-ai/DeepSeek-V4.1-Flash",
  "--revision=5254448103b6254fc646dacbca1cbbf20e9216c1",
  "--served-model-name=deepseek-v4.1-flash",
  "--host=0.0.0.0", "--port=8000",
  `--api-key=${process.env.VLLM_API_KEY!}`,
  "--tensor-parallel-size=8",
  "--tokenizer-mode=deepseek_v41",
  '--attention-config={"backend":"FLASHINFER_MLA_SPARSE_DSV41","indexer_kv_dtype":"mxfp4","indexer_sparse_logits":true}',
  "--kv-cache-dtype=fp8",
  "--max-model-len=1048576",
  "--max-num-seqs=128",
  '--engram-config={"cpu_offload":false}',
  "--tool-call-parser=deepseek_v41",
  "--enable-auto-tool-choice",
  "--reasoning-parser=deepseek_v41",
  "--mm-encoder-tp-mode=data",
];
const launchResponse = await fetch(`${API}/v1/gpu/instances`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "deepseek-v4-1-flash-serve-v1",
  },
  body: JSON.stringify({
    quoteId,
    name: "deepseek-v4-1-flash-vllm",
    env: {
      HF_HOME: "/models/hf",
      VLLM_ENGINE_READY_TIMEOUT_S: "3600",
      VLLM_USE_RUST_FRONTEND: "1",
    },
    ports: [{ port: 8000, protocol: "http" }],
    publicPortsAcknowledged: true,
    dockerStartCmd: command,
  }),
});
if (!launchResponse.ok) throw new Error(await launchResponse.text());
const launched = await launchResponse.json();
const instanceId = launched.resourceId;
const operationId = launched.operationId;
await waitFor(operationId);
```

Wait for the launch operation the same way as in step 1 (`wait_for` and
`waitFor` are already defined there):

```bash theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

A running instance is not a ready model. vLLM still has to load about
511 GB of weights (downloading them first unless step 3 staged them) and
shard them across eight GPUs, which takes tens of minutes. Step 5 waits for
`/v1/models` before the first request. To watch progress:

```bash theme={"dark"}
curl -N "$API/v1/gpu/instances/$INSTANCE_ID/logs?tail=200" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

For text-only traffic, qualify a second profile with `--language-model-only`
and remove `--mm-encoder-tp-mode data`. Do not silently route image requests to
that profile.

## 5. Verify reasoning, tools, and vision

Set `ENDPOINT` to the returned port-8000 URL.

```bash curl theme={"dark"}
CONNECTIONS=$(curl -sS "$API/v1/gpu/instances/$INSTANCE_ID/connections" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY")
export ENDPOINT=$(jq -er '.http[] | select(.port == 8000) | .url' <<<"$CONNECTIONS")
[ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT" || jq . <<<"$CONNECTIONS"
```

```python Python theme={"dark"}
response = requests.get(
    f"{API}/v1/gpu/instances/{instance_id}/connections",
    headers=AUTH,
    timeout=60,
)
response.raise_for_status()
connection = next(item for item in response.json()["http"] if item["port"] == 8000)
endpoint = connection["url"]
```

```typescript TypeScript theme={"dark"}
const connectionResponse = await fetch(`${API}/v1/gpu/instances/${instanceId}/connections`, {
  headers: auth,
});
if (!connectionResponse.ok) throw new Error(await connectionResponse.text());
const connections = await connectionResponse.json();
const connection = connections.http.find((item: { port: number }) => item.port === 8000);
if (!connection) throw new Error("port 8000 is not available in instance connections");
const endpoint = connection.url;
```

Wait until the model is loaded. The first successful `/v1/models` is the
readiness signal; until then the port returns connection errors or 5xx:

```bash theme={"dark"}
until curl -fsS "$ENDPOINT/v1/models" -H "Authorization: Bearer $VLLM_API_KEY" >/dev/null 2>&1; do
  echo "model still loading..."; sleep 30
done
```

```bash curl theme={"dark"}
curl -sS "$ENDPOINT/v1/models" \
  -H "Authorization: Bearer $VLLM_API_KEY"

curl -sS "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $VLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "What is 17*19? Return only the integer."}],
    "temperature": 1,
    "top_p": 0.95,
    "max_tokens": 4096,
    "chat_template_kwargs": {"thinking": true, "reasoning_effort": 75}
  }'
```

```python Python theme={"dark"}
response = requests.post(
    f"{endpoint}/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['VLLM_API_KEY']}"},
    json={
        "model": "deepseek-v4.1-flash",
        "messages": [{"role": "user", "content": "What is 17*19? Return only the integer."}],
        "temperature": 1,
        "top_p": 0.95,
        "max_tokens": 4096,
        "chat_template_kwargs": {"thinking": True, "reasoning_effort": 75},
    },
    timeout=300,
)
response.raise_for_status()
print(response.json())
```

```typescript TypeScript theme={"dark"}
const response = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.VLLM_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "deepseek-v4.1-flash",
    messages: [{ role: "user", content: "What is 17*19? Return only the integer." }],
    temperature: 1,
    top_p: 0.95,
    max_tokens: 4096,
    chat_template_kwargs: { thinking: true, reasoning_effort: 75 },
  }),
});
if (!response.ok) throw new Error(await response.text());
console.log(await response.json());
```

### Vision smoke test

`IMAGE_URL` is any image the server can fetch; a public sample is set here so
the test runs as written. This must pass before the multimodal profile is
considered ready:

```bash theme={"dark"}
export IMAGE_URL="https://upload.wikimedia.org/wikipedia/commons/3/3f/JPEG_example_flower.jpg"  # any public image works
```

```bash curl theme={"dark"}
curl -sS "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $VLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"deepseek-v4.1-flash\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": [
        {\"type\": \"text\", \"text\": \"Describe the image in one sentence.\"},
        {\"type\": \"image_url\", \"image_url\": {\"url\": \"$IMAGE_URL\"}}
      ]
    }],
    \"max_tokens\": 1024,
    \"chat_template_kwargs\": {\"thinking\": false}
  }"
```

```python Python theme={"dark"}
response = requests.post(
    f"{endpoint}/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['VLLM_API_KEY']}"},
    json={
        "model": "deepseek-v4.1-flash",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the image in one sentence."},
                {"type": "image_url", "image_url": {"url": os.environ["IMAGE_URL"]}},
            ],
        }],
        "max_tokens": 1024,
        "chat_template_kwargs": {"thinking": False},
    },
    timeout=300,
)
response.raise_for_status()
print(response.json()["choices"][0]["message"]["content"])
```

```typescript TypeScript theme={"dark"}
const visionResponse = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.VLLM_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "deepseek-v4.1-flash",
    messages: [{
      role: "user",
      content: [
        { type: "text", text: "Describe the image in one sentence." },
        { type: "image_url", image_url: { url: process.env.IMAGE_URL } },
      ],
    }],
    max_tokens: 1024,
    chat_template_kwargs: { thinking: false },
  }),
});
if (!visionResponse.ok) throw new Error(await visionResponse.text());
console.log((await visionResponse.json()).choices[0].message.content);
```

The self-host encoder maps `low/high/xhigh/max` to `25/50/75/100`; DeepSeek's
hosted API maps its named tiers differently. Use an integer when parity
matters. Thinking defaults on, so a small output cap may be exhausted before
visible content appears.

Acceptance must also send:

* a base64 image and a remote image URL through the OpenAI multimodal message shape;
* multiple images in one prompt;
* a tool call encoded through DeepSeek's tagged markup language (DSML),
  followed by a tool result while preserving prior `reasoning_content`;
* streaming responses in thinking and non-thinking modes;
* invalid tool output to prove the application rejects it safely.

## 6. Qualify load and DSpark

Start with target-only serving:

```bash theme={"dark"}
OPENAI_API_KEY="$VLLM_API_KEY" vllm bench serve \
  --backend openai-chat \
  --base-url "$ENDPOINT" \
  --endpoint /v1/chat/completions \
  --model deepseek-v4.1-flash \
  --dataset-name random \
  --random-input-len 8192 \
  --random-output-len 1024 \
  --request-rate 1 \
  --num-prompts 64
```

Run separate text and vision sweeps. Progress through 4K, 32K, 128K, 384K,
then near-1M contexts while varying concurrency and image count. Capture
p50/p95/p99 TTFT, TPOT, queue time, throughput, errors, OOMs, HBM/host memory,
KV usage, and tool/JSON validity.

Then enable the checkpoint's five-token DSpark block with real rejection.
Never use `rejection_sample_method: synthetic` or a synthetic acceptance
length as production evidence. Compare target-only and DSpark after clean
restarts, and do not combine DSpark with prefill/decode disaggregation until
the engine documents that combination as supported.

> [!WARNING]
>
> AI Reserve raw compute does not supply production replicas, health-aware
> load balancing or a managed load balancer, autoscaling, draining, durable
> workload logs, or customer GPU metrics. Add and test those layers before
> exposing the endpoint to clients. A protected raw port plus one successful
> request is not an industry-standard service.

## 7. Clean up

```bash curl theme={"dark"}
curl -sS -X DELETE "$API/v1/gpu/instances/$INSTANCE_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: deepseek-v4-1-flash-terminate-v1"
curl -sS -X DELETE "$API/v1/gpu/volumes/$VOLUME_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: deepseek-v4-1-flash-delete-weights-v1"
```

```python Python theme={"dark"}
for path, key in [
    (f"/v1/gpu/instances/{instance_id}", "deepseek-v4-1-flash-terminate-v1"),
    (f"/v1/gpu/volumes/{volume_id}", "deepseek-v4-1-flash-delete-weights-v1"),
]:
    response = requests.delete(f"{API}{path}", headers={**AUTH, "Idempotency-Key": key}, timeout=60)
    response.raise_for_status()
```

```typescript TypeScript theme={"dark"}
for (const [path, key] of [
  [`/v1/gpu/instances/${instanceId}`, "deepseek-v4-1-flash-terminate-v1"],
  [`/v1/gpu/volumes/${volumeId}`, "deepseek-v4-1-flash-delete-weights-v1"],
] as const) {
  const response = await fetch(`${API}${path}`, {
    method: "DELETE",
    headers: { ...auth, "Idempotency-Key": key },
  });
  if (!response.ok) throw new Error(await response.text());
}
```

## Primary sources

* [DeepSeek V4.1 Flash model card](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash)
* [Pinned model snapshot](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash/tree/5254448103b6254fc646dacbca1cbbf20e9216c1)
* [Reference inference guide](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash/blob/main/inference/README.md)
* [vLLM DeepSeek V4.1 Flash recipe](https://recipes.vllm.ai/deepseek-ai/DeepSeek-V4.1-Flash)
* [SGLang DeepSeek V4.1 cookbook](https://docs.sglang.io/cookbook/autoregressive/DeepSeek/DeepSeek-V4_1)
* [DeepSeek thinking-mode contract](https://api-docs.deepseek.com/guides/thinking_mode)
* [DeepSeek V4.1 Flash license](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash/blob/main/LICENSE)


# Serve DeepSeek V4 Pro 0813
Source: https://docs.aireserve.com/gpu-infrastructure/playbooks/deepseek-v4-pro-0813

Provision 8×H200, pin the released DeepSeek V4 Pro checkpoint, and qualify a vLLM endpoint with DeepSeek encoding and DSpark.

This playbook serves the released `deepseek-ai/DeepSeek-V4-Pro-0813`
checkpoint on one 8×H200 node. It does not use the older preview weights and
does not treat the mutable hosted API ID `deepseek-v4-pro` as an artifact pin.

> [!WARNING]
>
> **Vendor-verified · AI Reserve qualification pending.** Pin a qualified
> vLLM image digest before production. The upstream recipe documents 800K
> context on H200 to preserve KV headroom; that is a configured ceiling, not a
> promise of useful concurrency at 800K.

## Recipe contract

| Item | Pinned value |
| - | - |
| Artifact | `deepseek-ai/DeepSeek-V4-Pro-0813` |
| Revision | `72e1d3230f6c080a530b0a1d46f8eb4602340597` |
| Weights | Native mixed MXFP4 experts + FP8 linears; about 892.8 GB downloaded and about 960 GB runtime budget |
| Architecture | 1.65T total / 49B active, text-only MoE with attached DSpark drafter |
| Context | 1,048,576 architectural maximum; 800,000 in this H200 recipe |
| Primary engine | vLLM 0.25.0+ |
| Reference image | `vllm/vllm-openai:v0.25.0`; replace with the qualified digest |
| Hardware | 8×`H200_141GB` |
| Persistent storage | 1,200 GB minimum; use 2,000 GB when retaining conversion or rollback artifacts |
| License | MIT, ungated |
| Last reviewed | 2026-10-14 |

DeepSeek's repository has no Jinja chat template. Production serving depends on
the engine's `deepseek_v4` tokenizer, reasoning, and tool parsers. Raw
Transformers loading is not an equivalent serving contract.

## 0. Set up your shell

Every command on this page is copy-paste. Paste this block once per terminal
and replace only the API key; every later step reads these variables.

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # the only value you type: a key with Compute: Manage access
export API="https://api.aireserve.com"
export VLLM_API_KEY="$(openssl rand -hex 32)"  # generated for you; it protects your model server (see below)
echo "VLLM_API_KEY=$VLLM_API_KEY"               # save it: every request to the endpoint needs it
```

> [!NOTE]
>
> **Two keys, two jobs.** `AIRESERVE_API_KEY` authenticates you to AI Reserve
> and creates the volume, quote, and instance. `VLLM_API_KEY` is a password you
> invent for the vLLM server you are about to start: step 4 passes it as
> vLLM's `--api-key`, so the public HTTP port rejects anyone who does not
> send it. No vendor issues it and AI Reserve never sees it.

The Python and TypeScript tabs read the same three variables from the
environment. The shell tabs need `curl` and `jq`; the Python tabs need
`requests` (`python -m pip install requests`).

### Check stock first

A quote is free and creates nothing. Run one before creating storage, because
the volume in step 1 is placed next to this hardware and fails the same way
when none is in stock:

```bash theme={"dark"}
curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"accelerator": "H200_141GB", "count": 8, "region": "united_states", "image": "vllm/vllm-openai:v0.25.0", "diskGb": 100}' \
  | jq '{availability, price, error}'
```

A response with `availability` and `price` means you can continue. An `error`
with `code: no_capacity` means this shape is not in stock in that region right
now: try another `region` here and in steps 1 and 2, or wait, and read
[`no_capacity` reasons](/gpu-infrastructure/operations#no_capacity-reasons).

## 1. Allocate persistent storage

**Available now.** The accelerator hint places the volume in a data center
where 8×H200 has stock today, so the instance in step 4 can mount it. If step 0
reported no stock, this call fails the same way.

```bash curl theme={"dark"}
ACCEPTED=$(curl -sS -X POST "$API/v1/gpu/volumes" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: deepseek-v4-pro-0813-weights-v1" \
  -d '{
    "name": "deepseek-v4-pro-0813-weights",
    "region": "united_states",
    "sizeGb": 1200,
    "acceleratorHint": "H200_141GB",
    "storageBillingAcknowledged": true
  }')
export VOLUME_ID=$(jq -r .resourceId <<<"$ACCEPTED")
export OPERATION_ID=$(jq -r .operationId <<<"$ACCEPTED")
jq -e .resourceId <<<"$ACCEPTED" >/dev/null \
  && echo "accepted: volume $VOLUME_ID (operation $OPERATION_ID)" \
  || { echo "The volume was not accepted:"; jq . <<<"$ACCEPTED"; }
```

```python Python theme={"dark"}
import os, requests, time

API = "https://api.aireserve.com"
AUTH = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

response = requests.post(
    f"{API}/v1/gpu/volumes",
    headers={**AUTH, "Idempotency-Key": "deepseek-v4-pro-0813-weights-v1"},
    json={
        "name": "deepseek-v4-pro-0813-weights",
        "region": "united_states",
        "sizeGb": 1200,
        "acceleratorHint": "H200_141GB",
        "storageBillingAcknowledged": True,
    },
    timeout=60,
)
response.raise_for_status()
accepted = response.json()
volume_id = accepted["resourceId"]
operation_id = accepted["operationId"]
```

```typescript TypeScript theme={"dark"}
const API = "https://api.aireserve.com";
const auth = { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` };

const response = await fetch(`${API}/v1/gpu/volumes`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "deepseek-v4-pro-0813-weights-v1",
  },
  body: JSON.stringify({
    name: "deepseek-v4-pro-0813-weights",
    region: "united_states",
    sizeGb: 1200,
    acceleratorHint: "H200_141GB",
    storageBillingAcknowledged: true,
  }),
});
if (!response.ok) throw new Error(await response.text());
const accepted = await response.json();
const volumeId = accepted.resourceId;
const operationId = accepted.operationId;
```

Wait for the operation to finish before you quote compute. Persistent storage
bills independently of compute and is not deleted when the instance terminates.

```bash curl theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

```python Python theme={"dark"}
def wait_for(operation_id):
    while True:
        operation = requests.get(f"{API}/v1/gpu/operations/{operation_id}", headers=AUTH, timeout=60).json()
        print("operation", operation_id, operation.get("status"))
        if operation.get("status") == "succeeded":
            return operation
        if operation.get("status") in {"failed", "cancelled"}:
            failure = operation.get("failure") or {}
            raise RuntimeError(f"{failure.get('actor', 'unknown')}: {failure.get('message', operation.get('errorMessage'))} {failure.get('next', '')}")
        time.sleep(10)

wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
async function waitFor(operationId: string) {
  while (true) {
    const response = await fetch(`${API}/v1/gpu/operations/${operationId}`, { headers: auth });
    const operation = await response.json();
    console.log("operation", operationId, operation.status);
    if (operation.status === "succeeded") return operation;
    if (["failed", "cancelled"].includes(operation.status)) {
      const failure = operation.failure ?? {};
      throw new Error(`${failure.actor ?? "unknown"}: ${failure.message ?? operation.errorMessage} ${failure.next ?? ""}`);
    }
    await new Promise((resolve) => setTimeout(resolve, 10_000));
  }
}

await waitFor(operationId);
```

## 2. Quote the H200 node

**Available now.** Inspect the all-in hourly rate before launching. A quote
expires after 120 seconds, so run step 4 right after it; if it has expired,
run this step again.

```bash curl theme={"dark"}
QUOTE=$(curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"accelerator\": \"H200_141GB\",
    \"count\": 8,
    \"region\": \"united_states\",
    \"image\": \"vllm/vllm-openai:v0.25.0\",
    \"diskGb\": 100,
    \"volumeId\": \"$VOLUME_ID\",
    \"volumeMountPath\": \"/models\"
  }")
export QUOTE_ID=$(jq -r .quoteId <<<"$QUOTE")
jq '{quoteId, expiresAt, availability, price, storage, error}' <<<"$QUOTE"
```

```python Python theme={"dark"}
response = requests.post(
    f"{API}/v1/gpu/instances/quote",
    headers=AUTH,
    json={
        "accelerator": "H200_141GB",
        "count": 8,
        "region": "united_states",
        "image": "vllm/vllm-openai:v0.25.0",
        "diskGb": 100,
        "volumeId": volume_id,
        "volumeMountPath": "/models",
    },
    timeout=60,
)
response.raise_for_status()
quote = response.json()
quote_id = quote["quoteId"]
print(quote["price"], quote["availability"], quote["expiresAt"])
```

```typescript TypeScript theme={"dark"}
const quoteResponse = await fetch(`${API}/v1/gpu/instances/quote`, {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    accelerator: "H200_141GB",
    count: 8,
    region: "united_states",
    image: "vllm/vllm-openai:v0.25.0",
    diskGb: 100,
    volumeId,
    volumeMountPath: "/models",
  }),
});
if (!quoteResponse.ok) throw new Error(await quoteResponse.text());
const quote = await quoteResponse.json();
const quoteId = quote.quoteId;
console.log(quote.price, quote.availability, quote.expiresAt);
```

## 3. Download and verify the checkpoint

**Manual today.** AI Reserve has no managed preload job. Use the exact revision
on a loader with the same persistent volume, or allow vLLM to populate
`HF_HOME` on first launch. The verification command requires the current `hf`
CLI from `huggingface_hub` 1.18 or later, not the deprecated
`huggingface-cli`:

```bash theme={"dark"}
hf download deepseek-ai/DeepSeek-V4-Pro-0813 \
  --revision 72e1d3230f6c080a530b0a1d46f8eb4602340597 \
  --local-dir /models/DeepSeek-V4-Pro-0813

hf cache verify deepseek-ai/DeepSeek-V4-Pro-0813 \
  --revision 72e1d3230f6c080a530b0a1d46f8eb4602340597 \
  --local-dir /models/DeepSeek-V4-Pro-0813 \
  --fail-on-missing-files
```

Do not replace this checkpoint with `DeepSeek-V4-Pro` preview,
`DeepSeek-V4-Pro-DSpark`, or an NVIDIA NVFP4 conversion. They are separate
artifacts with different draft modules and qualification requirements.

## 4. Launch vLLM

**Available now, runtime qualification pending.** DSpark is attached inside
the 0813 checkpoint. Probabilistic draft sampling is the upstream recommendation
for sampled chat; benchmark it against target-only serving before promotion.

```bash curl theme={"dark"}
LAUNCH=$(jq -n \
  --arg quoteId "$QUOTE_ID" \
  --arg apiKey "$VLLM_API_KEY" \
  '{
    quoteId: $quoteId,
    name: "deepseek-v4-pro-0813-vllm",
    env: {HF_HOME: "/models/hf", VLLM_USE_RUST_FRONTEND: "1"},
    ports: [{port: 8000, protocol: "http"}],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "--model=deepseek-ai/DeepSeek-V4-Pro-0813",
      "--revision=72e1d3230f6c080a530b0a1d46f8eb4602340597",
      "--served-model-name=deepseek-v4-pro-0813",
      "--host=0.0.0.0", "--port=8000",
      "--api-key=\($apiKey)",
      "--trust-remote-code",
      "--kv-cache-dtype=fp8",
      "--block-size=256",
      "--enable-expert-parallel",
      "--tensor-parallel-size=8",
      "--max-model-len=800000",
      "--gpu-memory-utilization=0.95",
      "--max-num-seqs=512",
      "--no-enable-flashinfer-autotune",
      "--compilation-config={\"mode\":0,\"cudagraph_mode\":\"FULL_DECODE_ONLY\"}",
      "--tokenizer-mode=deepseek_v4",
      "--tool-call-parser=deepseek_v4",
      "--enable-auto-tool-choice",
      "--reasoning-parser=deepseek_v4",
      "--speculative-config={\"method\":\"dspark\",\"num_speculative_tokens\":7,\"draft_sample_method\":\"probabilistic\"}"
    ]
  }' | curl -sS -X POST "$API/v1/gpu/instances" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "Idempotency-Key: deepseek-v4-pro-0813-serve-v1" \
    --data-binary @-)
export INSTANCE_ID=$(jq -r .resourceId <<<"$LAUNCH")
export OPERATION_ID=$(jq -r .operationId <<<"$LAUNCH")
jq -e .resourceId <<<"$LAUNCH" >/dev/null \
  && echo "accepted: instance $INSTANCE_ID (operation $OPERATION_ID)" \
  || { echo "The launch was not accepted:"; jq . <<<"$LAUNCH"; }
```

```python Python theme={"dark"}
command = [
    "--model=deepseek-ai/DeepSeek-V4-Pro-0813",
    "--revision=72e1d3230f6c080a530b0a1d46f8eb4602340597",
    "--served-model-name=deepseek-v4-pro-0813",
    "--host=0.0.0.0", "--port=8000",
    f"--api-key={os.environ['VLLM_API_KEY']}",
    "--trust-remote-code",
    "--kv-cache-dtype=fp8",
    "--block-size=256",
    "--enable-expert-parallel",
    "--tensor-parallel-size=8",
    "--max-model-len=800000",
    "--gpu-memory-utilization=0.95",
    "--max-num-seqs=512",
    "--no-enable-flashinfer-autotune",
    '--compilation-config={"mode":0,"cudagraph_mode":"FULL_DECODE_ONLY"}',
    "--tokenizer-mode=deepseek_v4",
    "--tool-call-parser=deepseek_v4",
    "--enable-auto-tool-choice",
    "--reasoning-parser=deepseek_v4",
    '--speculative-config={"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"probabilistic"}',
]
response = requests.post(
    f"{API}/v1/gpu/instances",
    headers={**AUTH, "Idempotency-Key": "deepseek-v4-pro-0813-serve-v1"},
    json={
        "quoteId": quote_id,
        "name": "deepseek-v4-pro-0813-vllm",
        "env": {"HF_HOME": "/models/hf", "VLLM_USE_RUST_FRONTEND": "1"},
        "ports": [{"port": 8000, "protocol": "http"}],
        "publicPortsAcknowledged": True,
        "dockerStartCmd": command,
    },
    timeout=60,
)
response.raise_for_status()
launched = response.json()
instance_id = launched["resourceId"]
operation_id = launched["operationId"]
wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
const command = [
  "--model=deepseek-ai/DeepSeek-V4-Pro-0813",
  "--revision=72e1d3230f6c080a530b0a1d46f8eb4602340597",
  "--served-model-name=deepseek-v4-pro-0813",
  "--host=0.0.0.0", "--port=8000",
  `--api-key=${process.env.VLLM_API_KEY!}`,
  "--trust-remote-code",
  "--kv-cache-dtype=fp8",
  "--block-size=256",
  "--enable-expert-parallel",
  "--tensor-parallel-size=8",
  "--max-model-len=800000",
  "--gpu-memory-utilization=0.95",
  "--max-num-seqs=512",
  "--no-enable-flashinfer-autotune",
  '--compilation-config={"mode":0,"cudagraph_mode":"FULL_DECODE_ONLY"}',
  "--tokenizer-mode=deepseek_v4",
  "--tool-call-parser=deepseek_v4",
  "--enable-auto-tool-choice",
  "--reasoning-parser=deepseek_v4",
  '--speculative-config={"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"probabilistic"}',
];
const launchResponse = await fetch(`${API}/v1/gpu/instances`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "deepseek-v4-pro-0813-serve-v1",
  },
  body: JSON.stringify({
    quoteId,
    name: "deepseek-v4-pro-0813-vllm",
    env: { HF_HOME: "/models/hf", VLLM_USE_RUST_FRONTEND: "1" },
    ports: [{ port: 8000, protocol: "http" }],
    publicPortsAcknowledged: true,
    dockerStartCmd: command,
  }),
});
if (!launchResponse.ok) throw new Error(await launchResponse.text());
const launched = await launchResponse.json();
const instanceId = launched.resourceId;
const operationId = launched.operationId;
await waitFor(operationId);
```

Wait for the launch operation the same way as in step 1 (`wait_for` and
`waitFor` are already defined there):

```bash theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

A running instance is not a ready model. vLLM still has to load about
893 GB of weights (downloading them first unless step 3 staged them) and
shard them across eight GPUs, which takes tens of minutes. Step 5 waits for
`/v1/models` before the first request. To watch progress:

```bash theme={"dark"}
curl -N "$API/v1/gpu/instances/$INSTANCE_ID/logs?tail=200" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

## 5. Verify reasoning and tools

Set `ENDPOINT` from the HTTP connection for port 8000. Start with a small
output cap only in non-thinking mode; high and max reasoning may legitimately
need very large output budgets.

```bash curl theme={"dark"}
CONNECTIONS=$(curl -sS "$API/v1/gpu/instances/$INSTANCE_ID/connections" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY")
export ENDPOINT=$(jq -er '.http[] | select(.port == 8000) | .url' <<<"$CONNECTIONS")
[ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT" || jq . <<<"$CONNECTIONS"
```

```python Python theme={"dark"}
response = requests.get(
    f"{API}/v1/gpu/instances/{instance_id}/connections",
    headers=AUTH,
    timeout=60,
)
response.raise_for_status()
connection = next(item for item in response.json()["http"] if item["port"] == 8000)
endpoint = connection["url"]
```

```typescript TypeScript theme={"dark"}
const connectionResponse = await fetch(`${API}/v1/gpu/instances/${instanceId}/connections`, {
  headers: auth,
});
if (!connectionResponse.ok) throw new Error(await connectionResponse.text());
const connections = await connectionResponse.json();
const connection = connections.http.find((item: { port: number }) => item.port === 8000);
if (!connection) throw new Error("port 8000 is not available in instance connections");
const endpoint = connection.url;
```

Wait until the model is loaded. The first successful `/v1/models` is the
readiness signal; until then the port returns connection errors or 5xx:

```bash theme={"dark"}
until curl -fsS "$ENDPOINT/v1/models" -H "Authorization: Bearer $VLLM_API_KEY" >/dev/null 2>&1; do
  echo "model still loading..."; sleep 30
done
```

```bash curl theme={"dark"}
curl -sS "$ENDPOINT/v1/models" \
  -H "Authorization: Bearer $VLLM_API_KEY"

curl -sS "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $VLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-0813",
    "messages": [{"role": "user", "content": "What is 17*19? Return only the final integer."}],
    "temperature": 1,
    "top_p": 0.95,
    "max_tokens": 4096,
    "chat_template_kwargs": {"thinking": true, "reasoning_effort": "high"}
  }'
```

```python Python theme={"dark"}
response = requests.post(
    f"{endpoint}/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['VLLM_API_KEY']}"},
    json={
        "model": "deepseek-v4-pro-0813",
        "messages": [{"role": "user", "content": "What is 17*19? Return only the final integer."}],
        "temperature": 1,
        "top_p": 0.95,
        "max_tokens": 4096,
        "chat_template_kwargs": {"thinking": True, "reasoning_effort": "high"},
    },
    timeout=300,
)
response.raise_for_status()
print(response.json())
```

```typescript TypeScript theme={"dark"}
const response = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.VLLM_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "deepseek-v4-pro-0813",
    messages: [{ role: "user", content: "What is 17*19? Return only the final integer." }],
    temperature: 1,
    top_p: 0.95,
    max_tokens: 4096,
    chat_template_kwargs: { thinking: true, reasoning_effort: "high" },
  }),
});
if (!response.ok) throw new Error(await response.text());
console.log(await response.json());
```

Run `low`, `high`, and `max`; streaming; multi-turn; and tool-call tests.
DeepSeek wraps tool calls in its tagged DeepSeek markup language (DSML), which
the engine parser converts to OpenAI-shaped `tool_calls`. With tools, preserve
every prior `reasoning_content` value. Reject malformed tool markup at the
application boundary and retry with a bounded policy rather than executing
partially parsed arguments.

## 6. Qualify performance

Run target-only and DSpark servers from clean restarts, using identical model
revision, prompts, and scheduler settings:

```bash theme={"dark"}
OPENAI_API_KEY="$VLLM_API_KEY" vllm bench serve \
  --backend openai-chat \
  --base-url "$ENDPOINT" \
  --endpoint /v1/chat/completions \
  --model deepseek-v4-pro-0813 \
  --dataset-name random \
  --random-input-len 8192 \
  --random-output-len 1024 \
  --request-rate 1 \
  --num-prompts 64
```

Repeat with real 4K, 32K, 128K, 384K, and 800K traces. Sweep concurrency until
p95 TTFT or TPOT misses the production objective. Capture HBM, KV capacity,
queue time, cache hit rate, OOMs, errors, DSpark accepted length, and
tool-call validity. Never use synthetic-acceptance modes as evidence.

> [!WARNING]
>
> Raw GPU instances have no managed replica set, load balancer, autoscaler,
> health policy, traffic drain, durable log archive, or customer metrics API.
> Those are required production layers. Keep the previous model revision and
> image digest deployable until the replacement passes a drained canary.

## 7. Clean up

```bash curl theme={"dark"}
curl -sS -X DELETE "$API/v1/gpu/instances/$INSTANCE_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: deepseek-v4-pro-0813-terminate-v1"
curl -sS -X DELETE "$API/v1/gpu/volumes/$VOLUME_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: deepseek-v4-pro-0813-delete-weights-v1"
```

```python Python theme={"dark"}
for path, key in [
    (f"/v1/gpu/instances/{instance_id}", "deepseek-v4-pro-0813-terminate-v1"),
    (f"/v1/gpu/volumes/{volume_id}", "deepseek-v4-pro-0813-delete-weights-v1"),
]:
    response = requests.delete(f"{API}{path}", headers={**AUTH, "Idempotency-Key": key}, timeout=60)
    response.raise_for_status()
```

```typescript TypeScript theme={"dark"}
for (const [path, key] of [
  [`/v1/gpu/instances/${instanceId}`, "deepseek-v4-pro-0813-terminate-v1"],
  [`/v1/gpu/volumes/${volumeId}`, "deepseek-v4-pro-0813-delete-weights-v1"],
] as const) {
  const response = await fetch(`${API}${path}`, {
    method: "DELETE",
    headers: { ...auth, "Idempotency-Key": key },
  });
  if (!response.ok) throw new Error(await response.text());
}
```

## Primary sources

* [DeepSeek V4 Pro 0813 model card](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-0813)
* [Pinned model snapshot](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-0813/tree/72e1d3230f6c080a530b0a1d46f8eb4602340597)
* [DeepSeek V4 encoding guide](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-0813/blob/main/encoding/README.md)
* [vLLM DeepSeek V4 Pro recipe](https://recipes.vllm.ai/deepseek-ai/DeepSeek-V4-Pro)
* [SGLang DeepSeek V4 cookbook](https://docs.sglang.io/cookbook/autoregressive/DeepSeek/DeepSeek-V4)
* [Transformers DeepSeek V4 reference](https://huggingface.co/docs/transformers/model_doc/deepseek_v4)
* [DeepSeek V4 Pro 0813 license](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-0813/blob/main/LICENSE)


# Serve GLM-5.3
Source: https://docs.aireserve.com/gpu-infrastructure/playbooks/glm-5-3

Provision 8×H200, pin the native FP8 checkpoint and vLLM runtime, then qualify an authenticated GLM-5.3 endpoint.

This playbook serves the canonical native-FP8 `zai-org/GLM-5.3`
checkpoint with vLLM on one 8×H200 node. It is the simplest
vendor-documented topology that leaves useful runtime headroom.

> [!WARNING]
>
> **Vendor-verified · AI Reserve qualification pending.** The model and vLLM
> recipes are upstream-supported, but this exact AI Reserve launch has not
> completed the acceptance run. Pin an image digest after qualification; a
> floating image or version tag is not a production release artifact.

## Recipe contract

| Item | Pinned value |
| - | - |
| Artifact | `zai-org/GLM-5.3` |
| Revision reviewed | `ba32f8c19c8738e2c57c71798c601d477a7bf844` |
| Weights | Native block FP8; about 756 GB downloaded and about 893 GB of runtime budget before KV/cache headroom |
| Architecture | About 753B total / 39B active, text-only MoE |
| Context | 1,048,576 architectural maximum; qualify smaller production limits before admitting 1M requests |
| Primary engine | vLLM 0.29.0+ reference path |
| Reference image | `vllm/vllm-openai:v0.29.0`; replace with its qualified digest |
| Hardware | 8×`H200_141GB` |
| Persistent storage | 1,200 GB minimum for this checkpoint, cache metadata, and operational headroom |
| License | GLM-5.3 custom license; MaaS businesses above the license's revenue threshold require Z.AI security review |
| Last reviewed | 2026-10-14 |

The full 1M window is a separate capacity target. Upstream documents 8×B200
with FP8 KV for that operating point; on H200, admit only the maximum context
and concurrency your load test proves.

## 1. Set up the API client

Every command on this page is copy-paste. Paste the shell block once per
terminal and replace only the API key; every later step reads these
variables. The Python and TypeScript tabs read the same variables from the
environment.

```bash curl theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # the only value you type: a key with Compute: Manage access
export API="https://api.aireserve.com"
export VLLM_API_KEY="$(openssl rand -hex 32)"  # generated for you; it protects your model server (see below)
echo "VLLM_API_KEY=$VLLM_API_KEY"               # save it: every request to the endpoint needs it
```

```python Python theme={"dark"}
import json, os, time, uuid
from urllib.error import HTTPError
from urllib.request import Request, urlopen

API = "https://api.aireserve.com"
KEY = os.environ["AIRESERVE_API_KEY"]
VLLM_KEY = os.environ["VLLM_API_KEY"]

def api(path, method="GET", body=None, idempotency_key=None):
    headers = {"Authorization": f"Bearer {KEY}"}
    if body is not None:
        headers["Content-Type"] = "application/json"
    if idempotency_key:
        headers["Idempotency-Key"] = idempotency_key
    request = Request(
        f"{API}{path}",
        data=json.dumps(body).encode() if body is not None else None,
        headers=headers,
        method=method,
    )
    try:
        with urlopen(request) as response:
            return json.load(response)
    except HTTPError as error:
        raise RuntimeError(error.read().decode()) from error

def wait(operation_id):
    while True:
        operation = api(f"/v1/gpu/operations/{operation_id}")
        if operation["status"] == "succeeded":
            return operation
        if operation["status"] in {"failed", "cancelled"}:
            failure = operation.get("failure") or {}
            raise RuntimeError(f"{failure.get('actor', 'unknown')}: {failure.get('message', operation.get('errorMessage'))} {failure.get('next', '')}")
        time.sleep(5)
```

```typescript TypeScript theme={"dark"}
const API = "https://api.aireserve.com";
const KEY = process.env.AIRESERVE_API_KEY!;
const VLLM_KEY = process.env.VLLM_API_KEY!;

async function api(path: string, options: RequestInit = {}) {
  const response = await fetch(`${API}${path}`, {
    ...options,
    headers: {
      Authorization: `Bearer ${KEY}`,
      ...(options.body ? { "Content-Type": "application/json" } : {}),
      ...options.headers,
    },
  });
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

async function wait(operationId: string) {
  while (true) {
    const operation = await api(`/v1/gpu/operations/${operationId}`);
    if (operation.status === "succeeded") return operation;
    if (["failed", "cancelled"].includes(operation.status)) {
      const failure = operation.failure ?? {};
      throw new Error(`${failure.actor ?? "unknown"}: ${failure.message ?? operation.errorMessage} ${failure.next ?? ""}`);
    }
    await new Promise((resolve) => setTimeout(resolve, 5_000));
  }
}
```

> [!NOTE]
>
> **Two keys, two jobs.** `AIRESERVE_API_KEY` authenticates you to AI Reserve
> and creates the volume, quote, and instance. `VLLM_API_KEY` is a password you
> invent for the vLLM server you are about to start: step 5 passes it as
> vLLM's `--api-key`, so the public HTTP port rejects anyone who does not
> send it. No vendor issues it and AI Reserve never sees it.

The shell tabs need `curl` and `jq`.

### Check stock first

A quote is free and creates nothing. Run one before creating storage, because
the volume in step 2 is placed next to this hardware and fails the same way
when none is in stock:

```bash theme={"dark"}
curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"accelerator": "H200_141GB", "count": 8, "region": "united_states", "image": "vllm/vllm-openai:v0.29.0", "diskGb": 100}' \
  | jq '{availability, price, error}'
```

A response with `availability` and `price` means you can continue. An `error`
with `code: no_capacity` means this shape is not in stock in that region right
now: try another `region` here and in steps 2 and 3, or wait, and read
[`no_capacity` reasons](/gpu-infrastructure/operations#no_capacity-reasons).

## 2. Create the weights volume

**Available now.** The accelerator hint places the volume where an H200 can
mount it. Storage bills until you delete it, even after compute is terminated.

```bash curl theme={"dark"}
VOLUME_ACCEPTED=$(curl -sS -X POST "$API/v1/gpu/volumes" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: glm-5-3-weights-v1" \
  -d '{
    "name": "glm-5-3-weights",
    "region": "united_states",
    "sizeGb": 1200,
    "acceleratorHint": "H200_141GB",
    "storageBillingAcknowledged": true
  }')
export VOLUME_ID=$(jq -r .resourceId <<<"$VOLUME_ACCEPTED")
export OPERATION_ID=$(jq -r .operationId <<<"$VOLUME_ACCEPTED")
jq -e .resourceId <<<"$VOLUME_ACCEPTED" >/dev/null \
  && echo "accepted: volume $VOLUME_ID (operation $OPERATION_ID)" \
  || { echo "The volume was not accepted:"; jq . <<<"$VOLUME_ACCEPTED"; }
```

```python Python theme={"dark"}
accepted = api(
    "/v1/gpu/volumes",
    method="POST",
    idempotency_key="glm-5-3-weights-v1",
    body={
        "name": "glm-5-3-weights",
        "region": "united_states",
        "sizeGb": 1200,
        "acceleratorHint": "H200_141GB",
        "storageBillingAcknowledged": True,
    },
)
wait(accepted["operationId"])
volume_id = accepted["resourceId"]
```

```typescript TypeScript theme={"dark"}
const accepted = await api("/v1/gpu/volumes", {
  method: "POST",
  headers: { "Idempotency-Key": "glm-5-3-weights-v1" },
  body: JSON.stringify({
    name: "glm-5-3-weights",
    region: "united_states",
    sizeGb: 1200,
    acceleratorHint: "H200_141GB",
    storageBillingAcknowledged: true,
  }),
});
await wait(accepted.operationId);
const volumeId = accepted.resourceId;
```

In the shell, wait for the operation before quoting compute (the Python and
TypeScript tabs already call `wait`):

```bash theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

## 3. Quote the serving node

**Available now.** The quote creates nothing, expires after 120 seconds, and
binds the hardware, image, disk, and volume.

```bash curl theme={"dark"}
QUOTE=$(curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"accelerator\": \"H200_141GB\",
    \"count\": 8,
    \"region\": \"united_states\",
    \"image\": \"vllm/vllm-openai:v0.29.0\",
    \"diskGb\": 100,
    \"volumeId\": \"$VOLUME_ID\",
    \"volumeMountPath\": \"/models\"
  }")
export QUOTE_ID=$(jq -r .quoteId <<<"$QUOTE")
jq '{quoteId, expiresAt, price, availability, storage, error}' <<<"$QUOTE"
```

```python Python theme={"dark"}
quote = api("/v1/gpu/instances/quote", method="POST", body={
    "accelerator": "H200_141GB",
    "count": 8,
    "region": "united_states",
    "image": "vllm/vllm-openai:v0.29.0",
    "diskGb": 100,
    "volumeId": volume_id,
    "volumeMountPath": "/models",
})
quote_id = quote["quoteId"]
print(quote["price"], quote["availability"], quote["expiresAt"])
```

```typescript TypeScript theme={"dark"}
const quote = await api("/v1/gpu/instances/quote", {
  method: "POST",
  body: JSON.stringify({
    accelerator: "H200_141GB",
    count: 8,
    region: "united_states",
    image: "vllm/vllm-openai:v0.29.0",
    diskGb: 100,
    volumeId,
    volumeMountPath: "/models",
  }),
});
const quoteId = quote.quoteId;
console.log(quote.price, quote.availability, quote.expiresAt);
```

## 4. Pin and download the model

**Manual today.** AI Reserve does not yet have a model-preload resource. vLLM
downloads the pinned revision into `HF_HOME` during first launch. To preload it
separately, run this in a qualified loader image with the same volume mounted.
The verification command requires the current `hf` CLI from
`huggingface_hub` 1.18 or later, not the deprecated `huggingface-cli`:

```bash theme={"dark"}
hf download zai-org/GLM-5.3 \
  --revision ba32f8c19c8738e2c57c71798c601d477a7bf844 \
  --local-dir /models/GLM-5.3

hf cache verify zai-org/GLM-5.3 \
  --revision ba32f8c19c8738e2c57c71798c601d477a7bf844 \
  --local-dir /models/GLM-5.3 \
  --fail-on-missing-files
```

Do not substitute `zai-org/GLM-5.3-BF16`: its runtime budget is about 1.786 TB
and it requires a different topology. Treat third-party NVFP4 builds as
separate artifacts that need their own quality run.

## 5. Launch vLLM

**Available now, runtime qualification pending.** The image entrypoint receives
the model and engine arguments below. `HF_HOME` keeps the resumable download on
the persistent volume. The raw vLLM port is public, so `--api-key` is mandatory.

```bash curl theme={"dark"}
LAUNCH=$(jq -n \
  --arg quoteId "$QUOTE_ID" \
  --arg apiKey "$VLLM_API_KEY" \
  '{
    quoteId: $quoteId,
    name: "glm-5-3-vllm",
    env: {
      HF_HOME: "/models/hf",
      VLLM_USE_RUST_FRONTEND: "1"
    },
    ports: [{port: 8000, protocol: "http"}],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "--model", "zai-org/GLM-5.3",
      "--revision", "ba32f8c19c8738e2c57c71798c601d477a7bf844",
      "--served-model-name", "glm-5.3",
      "--host", "0.0.0.0", "--port", "8000",
      "--api-key", $apiKey,
      "--kv-cache-dtype", "fp8_e4m3",
      "--tensor-parallel-size", "8",
      "--speculative-config", "{\"method\":\"mtp\",\"num_speculative_tokens\":5}",
      "--max-num-seqs", "32",
      "--tool-call-parser", "glm47",
      "--reasoning-parser", "glm47",
      "--enable-auto-tool-choice"
    ]
  }' | curl -sS -X POST "$API/v1/gpu/instances" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "Idempotency-Key: glm-5-3-serve-v1" \
    --data-binary @-)
export INSTANCE_ID=$(jq -r .resourceId <<<"$LAUNCH")
export OPERATION_ID=$(jq -r .operationId <<<"$LAUNCH")
jq -e .resourceId <<<"$LAUNCH" >/dev/null \
  && echo "accepted: instance $INSTANCE_ID (operation $OPERATION_ID)" \
  || { echo "The launch was not accepted:"; jq . <<<"$LAUNCH"; }
```

```python Python theme={"dark"}
accepted = api(
    "/v1/gpu/instances",
    method="POST",
    idempotency_key="glm-5-3-serve-v1",
    body={
        "quoteId": quote_id,
        "name": "glm-5-3-vllm",
        "env": {"HF_HOME": "/models/hf", "VLLM_USE_RUST_FRONTEND": "1"},
        "ports": [{"port": 8000, "protocol": "http"}],
        "publicPortsAcknowledged": True,
        "dockerStartCmd": [
            "--model", "zai-org/GLM-5.3",
            "--revision", "ba32f8c19c8738e2c57c71798c601d477a7bf844",
            "--served-model-name", "glm-5.3",
            "--host", "0.0.0.0", "--port", "8000",
            "--api-key", VLLM_KEY,
            "--kv-cache-dtype", "fp8_e4m3",
            "--tensor-parallel-size", "8",
            "--speculative-config", '{"method":"mtp","num_speculative_tokens":5}',
            "--max-num-seqs", "32",
            "--tool-call-parser", "glm47",
            "--reasoning-parser", "glm47",
            "--enable-auto-tool-choice",
        ],
    },
)
wait(accepted["operationId"])
instance_id = accepted["resourceId"]
```

```typescript TypeScript theme={"dark"}
const launched = await api("/v1/gpu/instances", {
  method: "POST",
  headers: { "Idempotency-Key": "glm-5-3-serve-v1" },
  body: JSON.stringify({
    quoteId,
    name: "glm-5-3-vllm",
    env: { HF_HOME: "/models/hf", VLLM_USE_RUST_FRONTEND: "1" },
    ports: [{ port: 8000, protocol: "http" }],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "--model", "zai-org/GLM-5.3",
      "--revision", "ba32f8c19c8738e2c57c71798c601d477a7bf844",
      "--served-model-name", "glm-5.3",
      "--host", "0.0.0.0", "--port", "8000",
      "--api-key", VLLM_KEY,
      "--kv-cache-dtype", "fp8_e4m3",
      "--tensor-parallel-size", "8",
      "--speculative-config", '{"method":"mtp","num_speculative_tokens":5}',
      "--max-num-seqs", "32",
      "--tool-call-parser", "glm47",
      "--reasoning-parser", "glm47",
      "--enable-auto-tool-choice",
    ],
  }),
});
await wait(launched.operationId);
const instanceId = launched.resourceId;
```

In the shell, wait for the launch operation (the Python and TypeScript tabs
already call `wait`):

```bash theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

A running instance is not a ready model. vLLM still has to load about 756 GB
of weights (downloading them first unless step 4 staged them) and shard them
across eight GPUs, which takes tens of minutes. Step 6 waits for `/v1/models`
before the first request. To watch progress:

```bash theme={"dark"}
curl -N "$API/v1/gpu/instances/$INSTANCE_ID/logs?tail=200" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

The upstream recipe body still mentions 0.28.0, but its current compatibility
header requires 0.29.0+. This playbook deliberately requires 0.29.0 and remains
qualification-pending until one immutable image digest passes.

## 6. Discover and verify the endpoint

Retrieve the HTTP URL only after the operation succeeds. The shell block sets
`ENDPOINT` from the port 8000 connection, then waits for the first successful
`/v1/models`, which is the readiness signal.

```bash curl theme={"dark"}
CONNECTIONS=$(curl -sS "$API/v1/gpu/instances/$INSTANCE_ID/connections" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY")
export ENDPOINT=$(jq -er '.http[] | select(.port == 8000) | .url' <<<"$CONNECTIONS")
[ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT" || jq . <<<"$CONNECTIONS"

until curl -fsS "$ENDPOINT/v1/models" -H "Authorization: Bearer $VLLM_API_KEY" >/dev/null 2>&1; do
  echo "model still loading..."; sleep 30
done
curl -sS "$ENDPOINT/v1/models" -H "Authorization: Bearer $VLLM_API_KEY"
curl -N "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $VLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [{"role": "user", "content": "Reply with exactly: ready"}],
    "stream": true,
    "max_tokens": 256,
    "chat_template_kwargs": {"reasoning_effort": "low", "clear_thinking": true}
  }'
```

```python Python theme={"dark"}
connections = api(f"/v1/gpu/instances/{instance_id}/connections")
endpoint = next(item["url"] for item in connections["http"] if item["port"] == 8000)

request = Request(
    f"{endpoint}/v1/chat/completions",
    data=json.dumps({
        "model": "glm-5.3",
        "messages": [{"role": "user", "content": "Reply with exactly: ready"}],
        "max_tokens": 256,
        "chat_template_kwargs": {"reasoning_effort": "low", "clear_thinking": True},
    }).encode(),
    headers={"Authorization": f"Bearer {VLLM_KEY}", "Content-Type": "application/json"},
)
with urlopen(request, timeout=300) as response:
    print(json.load(response))
```

```typescript TypeScript theme={"dark"}
const connections = await api(`/v1/gpu/instances/${instanceId}/connections`);
const connection = connections.http.find((item: { port: number }) => item.port === 8000);
if (!connection) throw new Error("port 8000 is not available in instance connections");
const endpoint = connection.url;

const response = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: { Authorization: `Bearer ${VLLM_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "glm-5.3",
    messages: [{ role: "user", content: "Reply with exactly: ready" }],
    max_tokens: 256,
    chat_template_kwargs: { reasoning_effort: "low", clear_thinking: true },
  }),
});
if (!response.ok) throw new Error(await response.text());
console.log(await response.json());
```

`clear_thinking=true` is required for ordinary multi-turn chat; otherwise the
template preserves prior reasoning. Run the same test at `low`, `high`, and
`max`, then add a tool schema and verify that `tool_calls` is valid JSON and
that arguments satisfy the schema.

## 7. Qualify throughput and context

Run the benchmark client from another machine so it does not contend with the
server. Start with prefix caching disabled for a clean baseline, then enable it
and measure the production request mix.

```bash theme={"dark"}
OPENAI_API_KEY="$VLLM_API_KEY" vllm bench serve \
  --backend openai-chat \
  --base-url "$ENDPOINT" \
  --endpoint /v1/chat/completions \
  --model glm-5.3 \
  --dataset-name random \
  --random-input-len 8000 \
  --random-output-len 1024 \
  --request-rate 1 \
  --num-prompts 64
```

Sweep 4K, 32K, 128K, then the largest context you intend to admit. Repeat at
increasing request rates and concurrency until p95 TTFT or TPOT misses your
objective. Synthetic prompts understate MTP acceptance; repeat with real
agent traces and report mean accepted draft length.

Before promotion, verify:

* no OOM, worker restart, or malformed tool call at the admitted limits;
* p50/p95/p99 TTFT, TPOT, end-to-end latency, queue time, and error rate;
* input/output throughput, KV and prefix-cache hit rate, HBM and host memory;
* MTP enabled and disabled on identical prompts;
* rolling restart and rollback to the prior image digest.

> [!WARNING]
>
> AI Reserve does not currently provide managed replicas, load balancing,
> draining, durable workload logs, customer GPU metrics, or autoscaling for raw
> instances. Those are platform gaps, not optional production checks. Put an
> authenticated load balancer and monitoring layer in front before accepting
> customer traffic.

## 8. Clean up

Terminate compute first. Delete the volume only after confirming the checkpoint
cache is no longer needed.

```bash curl theme={"dark"}
curl -sS -X DELETE "$API/v1/gpu/instances/$INSTANCE_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: glm-5-3-terminate-v1"

curl -sS -X DELETE "$API/v1/gpu/volumes/$VOLUME_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: glm-5-3-delete-weights-v1"
```

```python Python theme={"dark"}
api(
    f"/v1/gpu/instances/{instance_id}",
    method="DELETE",
    idempotency_key="glm-5-3-terminate-v1",
)
api(
    f"/v1/gpu/volumes/{volume_id}",
    method="DELETE",
    idempotency_key="glm-5-3-delete-weights-v1",
)
```

```typescript TypeScript theme={"dark"}
await api(`/v1/gpu/instances/${instanceId}`, {
  method: "DELETE",
  headers: { "Idempotency-Key": "glm-5-3-terminate-v1" },
});
await api(`/v1/gpu/volumes/${volumeId}`, {
  method: "DELETE",
  headers: { "Idempotency-Key": "glm-5-3-delete-weights-v1" },
});
```

## Primary sources

* [GLM-5.3 model card](https://huggingface.co/zai-org/GLM-5.3)
* [Pinned model snapshot](https://huggingface.co/zai-org/GLM-5.3/tree/ba32f8c19c8738e2c57c71798c601d477a7bf844)
* [vLLM GLM-5.3 recipe](https://recipes.vllm.ai/zai-org/GLM-5.3)
* [SGLang GLM-5.3 cookbook](https://docs.sglang.io/cookbook/autoregressive/GLM/GLM-5.3)
* [Transformers GLM MoE DSA reference](https://huggingface.co/docs/transformers/model_doc/glm_moe_dsa)
* [GLM-5.3 license](https://huggingface.co/zai-org/GLM-5.3/blob/main/LICENSE)


# Serve Kimi K3
Source: https://docs.aireserve.com/gpu-infrastructure/playbooks/kimi-k3

Provision 8×B300, pin Kimi K3's native MXFP4 weights, and qualify an authenticated multimodal SGLang endpoint.

This playbook serves `moonshotai/Kimi-K3` with SGLang on one 8×B300 node.
That is the smallest topology whose unified low-latency and balanced paths are
marked verified by the SGLang maintainers.

> [!WARNING]
>
> **Vendor-verified · AI Reserve qualification pending.** SGLang's verified
> B300 result used revision `v0.5.18 @ 71de97b2`, but its public NVIDIA image
> reference is still floating. Resolve `lmsysorg/sglang:latest` to the digest
> you qualify and store that digest in the deployment record before production.

## Recipe contract

| Item | Pinned value |
| - | - |
| Artifact | `moonshotai/Kimi-K3` |
| Revision reviewed | `f831ab66814297da540d832a5235f8e904f29d06` |
| Weights | QAT MXFP4 weights / MXFP8 activations; about 1.561 TB downloaded and about 1.68 TB before runtime headroom |
| Architecture | 2.8T total / 104B active, 93-layer multimodal MoE |
| Context | 1,048,576 architectural maximum; this starting profile admits 65,536 |
| Primary engine | SGLang; B300 reference measured on `v0.5.18 @ 71de97b2` |
| Reference image | `lmsysorg/sglang:latest`; replace with the qualified digest |
| Hardware | 8×`B300_288GB` |
| Persistent storage | 2,000 GB minimum |
| Self-hosted modalities | Text and images; current open-serving path does not establish video support |
| License | Kimi K3 custom license; MaaS above its revenue threshold requires a separate Moonshot agreement |
| Last reviewed | 2026-10-14 |

Kimi K3 always reasons. It also requires the complete prior assistant message—
including `reasoning_content` and `tool_calls`—on every multi-turn or tool
follow-up. Dropping those fields changes the conversation contract.

## 0. Set up your shell

Every command on this page is copy-paste. Paste this block once per terminal
and replace only the API key; every later step reads these variables.

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."   # the only value you type: a key with Compute: Manage access
export API="https://api.aireserve.com"
export SGLANG_API_KEY="$(openssl rand -hex 32)"  # generated for you; it protects your model server (see below)
echo "SGLANG_API_KEY=$SGLANG_API_KEY"               # save it: every request to the endpoint needs it
```

> [!NOTE]
>
> **Two keys, two jobs.** `AIRESERVE_API_KEY` authenticates you to AI Reserve
> and creates the volume, quote, and instance. `SGLANG_API_KEY` is a password you
> invent for the SGLang server you are about to start: step 4 passes it as
> SGLang's `--api-key`, so the public HTTP port rejects anyone who does not
> send it. No vendor issues it and AI Reserve never sees it.

The Python and TypeScript tabs read the same three variables from the
environment. The shell tabs need `curl` and `jq`; the Python tabs need
`requests` (`python -m pip install requests`).

### Check stock first

A quote is free and creates nothing. Run one before creating storage, because
the volume in step 1 is placed next to this hardware and fails the same way
when none is in stock:

```bash theme={"dark"}
curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"accelerator": "B300_288GB", "count": 8, "region": "united_states", "image": "lmsysorg/sglang:latest", "diskGb": 100}' \
  | jq '{availability, price, error}'
```

A response with `availability` and `price` means you can continue. An `error`
with `code: no_capacity` means this shape is not in stock in that region right
now: try another `region` here and in steps 1 and 2, or wait, and read
[`no_capacity` reasons](/gpu-infrastructure/operations#no_capacity-reasons).

## 1. Create the weights volume

**Available now.** The accelerator hint places the volume in a data center
where 8×B300 has stock today, so the instance in step 4 can mount it. If step 0
reported no stock, this call fails the same way. Storage continues billing
after the instance is terminated.

```bash curl theme={"dark"}
ACCEPTED=$(curl -sS -X POST "$API/v1/gpu/volumes" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: kimi-k3-weights-v1" \
  -d '{
    "name": "kimi-k3-weights",
    "region": "united_states",
    "sizeGb": 2000,
    "acceleratorHint": "B300_288GB",
    "storageBillingAcknowledged": true
  }')
export VOLUME_ID=$(jq -r .resourceId <<<"$ACCEPTED")
export OPERATION_ID=$(jq -r .operationId <<<"$ACCEPTED")
jq -e .resourceId <<<"$ACCEPTED" >/dev/null \
  && echo "accepted: volume $VOLUME_ID (operation $OPERATION_ID)" \
  || { echo "The volume was not accepted:"; jq . <<<"$ACCEPTED"; }
```

```python Python theme={"dark"}
import os, requests, time

API = "https://api.aireserve.com"
HEADERS = {"Authorization": f"Bearer {os.environ['AIRESERVE_API_KEY']}"}

response = requests.post(
    f"{API}/v1/gpu/volumes",
    headers={**HEADERS, "Idempotency-Key": "kimi-k3-weights-v1"},
    json={
        "name": "kimi-k3-weights",
        "region": "united_states",
        "sizeGb": 2000,
        "acceleratorHint": "B300_288GB",
        "storageBillingAcknowledged": True,
    },
    timeout=60,
)
response.raise_for_status()
accepted = response.json()
volume_id = accepted["resourceId"]
operation_id = accepted["operationId"]
```

```typescript TypeScript theme={"dark"}
const API = "https://api.aireserve.com";
const auth = { Authorization: `Bearer ${process.env.AIRESERVE_API_KEY}` };

const response = await fetch(`${API}/v1/gpu/volumes`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "kimi-k3-weights-v1",
  },
  body: JSON.stringify({
    name: "kimi-k3-weights",
    region: "united_states",
    sizeGb: 2000,
    acceleratorHint: "B300_288GB",
    storageBillingAcknowledged: true,
  }),
});
if (!response.ok) throw new Error(await response.text());
const accepted = await response.json();
const volumeId = accepted.resourceId;
const operationId = accepted.operationId;
```

Wait for the operation to finish before you quote compute. Retrying the same
idempotency key never creates a second volume.

```bash curl theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

```python Python theme={"dark"}
def wait_for(operation_id):
    while True:
        operation = requests.get(f"{API}/v1/gpu/operations/{operation_id}", headers=HEADERS, timeout=60).json()
        print("operation", operation_id, operation.get("status"))
        if operation.get("status") == "succeeded":
            return operation
        if operation.get("status") in {"failed", "cancelled"}:
            failure = operation.get("failure") or {}
            raise RuntimeError(f"{failure.get('actor', 'unknown')}: {failure.get('message', operation.get('errorMessage'))} {failure.get('next', '')}")
        time.sleep(10)

wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
async function waitFor(operationId: string) {
  while (true) {
    const response = await fetch(`${API}/v1/gpu/operations/${operationId}`, { headers: auth });
    const operation = await response.json();
    console.log("operation", operationId, operation.status);
    if (operation.status === "succeeded") return operation;
    if (["failed", "cancelled"].includes(operation.status)) {
      const failure = operation.failure ?? {};
      throw new Error(`${failure.actor ?? "unknown"}: ${failure.message ?? operation.errorMessage} ${failure.next ?? ""}`);
    }
    await new Promise((resolve) => setTimeout(resolve, 10_000));
  }
}

await waitFor(operationId);
```

## 2. Quote 8×B300

**Available now.** A quote does not reserve scarce B300 capacity. Launch it
before its 120-second expiry.

```bash curl theme={"dark"}
QUOTE=$(curl -sS -X POST "$API/v1/gpu/instances/quote" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"accelerator\": \"B300_288GB\",
    \"count\": 8,
    \"region\": \"united_states\",
    \"image\": \"lmsysorg/sglang:latest\",
    \"diskGb\": 100,
    \"volumeId\": \"$VOLUME_ID\",
    \"volumeMountPath\": \"/models\"
  }")
export QUOTE_ID=$(jq -r .quoteId <<<"$QUOTE")
jq '{quoteId, expiresAt, price, availability, error}' <<<"$QUOTE"
```

```python Python theme={"dark"}
response = requests.post(
    f"{API}/v1/gpu/instances/quote",
    headers=HEADERS,
    json={
        "accelerator": "B300_288GB",
        "count": 8,
        "region": "united_states",
        "image": "lmsysorg/sglang:latest",
        "diskGb": 100,
        "volumeId": volume_id,
        "volumeMountPath": "/models",
    },
    timeout=60,
)
response.raise_for_status()
quote = response.json()
quote_id = quote["quoteId"]
print(quote["price"], quote["availability"], quote["expiresAt"])
```

```typescript TypeScript theme={"dark"}
const quoteResponse = await fetch(`${API}/v1/gpu/instances/quote`, {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json" },
  body: JSON.stringify({
    accelerator: "B300_288GB",
    count: 8,
    region: "united_states",
    image: "lmsysorg/sglang:latest",
    diskGb: 100,
    volumeId,
    volumeMountPath: "/models",
  }),
});
if (!quoteResponse.ok) throw new Error(await quoteResponse.text());
const quote = await quoteResponse.json();
const quoteId = quote.quoteId;
console.log(quote.price, quote.availability, quote.expiresAt);
```

## 3. Pin and download the model

**Manual today.** The serving process can download into `HF_HOME`, but a
separate preload makes startup and rollback predictable. The verification
command requires the current `hf` CLI from `huggingface_hub` 1.18 or later,
not the deprecated `huggingface-cli`:

```bash theme={"dark"}
hf download moonshotai/Kimi-K3 \
  --revision f831ab66814297da540d832a5235f8e904f29d06 \
  --local-dir /models/Kimi-K3

hf cache verify moonshotai/Kimi-K3 \
  --revision f831ab66814297da540d832a5235f8e904f29d06 \
  --local-dir /models/Kimi-K3 \
  --fail-on-missing-files
```

The canonical artifact is already quantized. Do not silently substitute the
NVIDIA NVFP4 or Ascend W4A8 conversions; each needs its own image, topology,
quality suite, and acceptance record.

## 4. Launch SGLang

**Available now, runtime qualification pending.** This is the conservative
65K B300 profile published by SGLang. It keeps the vision path enabled, uses
TP8, and avoids speculative decoding until target-only quality and latency are
known. The API key protects the public HTTP port.

```bash curl theme={"dark"}
LAUNCH=$(jq -n \
  --arg quoteId "$QUOTE_ID" \
  --arg apiKey "$SGLANG_API_KEY" \
  '{
    quoteId: $quoteId,
    name: "kimi-k3-sglang",
    env: {HF_HOME: "/models/hf"},
    ports: [{port: 30000, protocol: "http"}],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "sglang", "serve",
      "--trust-remote-code",
      "--model-path", "moonshotai/Kimi-K3",
      "--revision", "f831ab66814297da540d832a5235f8e904f29d06",
      "--served-model-name", "kimi-k3",
      "--tp-size", "8",
      "--context-length", "65536",
      "--enable-symm-mem",
      "--mem-fraction-static", "0.82",
      "--mm-feature-transport", "cpu",
      "--reasoning-parser", "kimi_k3",
      "--tool-call-parser", "kimi_k3",
      "--api-key", $apiKey,
      "--host", "0.0.0.0", "--port", "30000"
    ]
  }' | curl -sS -X POST "$API/v1/gpu/instances" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "Idempotency-Key: kimi-k3-serve-v1" \
    --data-binary @-)
export INSTANCE_ID=$(jq -r .resourceId <<<"$LAUNCH")
export OPERATION_ID=$(jq -r .operationId <<<"$LAUNCH")
jq -e .resourceId <<<"$LAUNCH" >/dev/null \
  && echo "accepted: instance $INSTANCE_ID (operation $OPERATION_ID)" \
  || { echo "The launch was not accepted:"; jq . <<<"$LAUNCH"; }
```

```python Python theme={"dark"}
body = {
    "quoteId": quote_id,
    "name": "kimi-k3-sglang",
    "env": {"HF_HOME": "/models/hf"},
    "ports": [{"port": 30000, "protocol": "http"}],
    "publicPortsAcknowledged": True,
    "dockerStartCmd": [
        "sglang", "serve",
        "--trust-remote-code",
        "--model-path", "moonshotai/Kimi-K3",
        "--revision", "f831ab66814297da540d832a5235f8e904f29d06",
        "--served-model-name", "kimi-k3",
        "--tp-size", "8",
        "--context-length", "65536",
        "--enable-symm-mem",
        "--mem-fraction-static", "0.82",
        "--mm-feature-transport", "cpu",
        "--reasoning-parser", "kimi_k3",
        "--tool-call-parser", "kimi_k3",
        "--api-key", os.environ["SGLANG_API_KEY"],
        "--host", "0.0.0.0", "--port", "30000",
    ],
}
response = requests.post(
    f"{API}/v1/gpu/instances",
    headers={**HEADERS, "Idempotency-Key": "kimi-k3-serve-v1"},
    json=body,
    timeout=60,
)
response.raise_for_status()
launched = response.json()
instance_id = launched["resourceId"]
operation_id = launched["operationId"]
wait_for(operation_id)
```

```typescript TypeScript theme={"dark"}
const launchResponse = await fetch(`${API}/v1/gpu/instances`, {
  method: "POST",
  headers: {
    ...auth,
    "Content-Type": "application/json",
    "Idempotency-Key": "kimi-k3-serve-v1",
  },
  body: JSON.stringify({
    quoteId,
    name: "kimi-k3-sglang",
    env: { HF_HOME: "/models/hf" },
    ports: [{ port: 30000, protocol: "http" }],
    publicPortsAcknowledged: true,
    dockerStartCmd: [
      "sglang", "serve",
      "--trust-remote-code",
      "--model-path", "moonshotai/Kimi-K3",
      "--revision", "f831ab66814297da540d832a5235f8e904f29d06",
      "--served-model-name", "kimi-k3",
      "--tp-size", "8",
      "--context-length", "65536",
      "--enable-symm-mem",
      "--mem-fraction-static", "0.82",
      "--mm-feature-transport", "cpu",
      "--reasoning-parser", "kimi_k3",
      "--tool-call-parser", "kimi_k3",
      "--api-key", process.env.SGLANG_API_KEY!,
      "--host", "0.0.0.0", "--port", "30000",
    ],
  }),
});
if (!launchResponse.ok) throw new Error(await launchResponse.text());
const launched = await launchResponse.json();
const instanceId = launched.resourceId;
const operationId = launched.operationId;
await waitFor(operationId);
```

Wait for the launch operation the same way as in step 1 (`wait_for` and
`waitFor` are already defined there):

```bash theme={"dark"}
while :; do
  OPERATION=$(curl -sS "$API/v1/gpu/operations/$OPERATION_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(jq -r .status <<<"$OPERATION")
  echo "operation $OPERATION_ID: $STATUS"
  case "$STATUS" in
    succeeded) break ;;
    failed|cancelled)
      jq -r '.failure // empty | "whose: \(.actor)\nwhy:   \(.message)\nnext:  \(.next)"' <<<"$OPERATION"
      break ;;
  esac
  sleep 10
done
```

A running instance is not a ready model. SGLang still has to load about
1.56 TB of weights (downloading them first unless step 3 staged them) and
shard them across eight GPUs, which takes tens of minutes. Step 5 waits for
`/v1/models` before the first request. To watch progress:

```bash theme={"dark"}
curl -N "$API/v1/gpu/instances/$INSTANCE_ID/logs?tail=200" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

From the logs, record the reported model load, static-memory allocation,
maximum token pool, and admitted-request cap. Do not raise
`--mem-fraction-static` or context until that evidence is captured.

## 5. Verify text, vision, and thinking history

Retrieve the port-30000 URL from the instance's `connections` response and set
it as `ENDPOINT`.

```bash curl theme={"dark"}
CONNECTIONS=$(curl -sS "$API/v1/gpu/instances/$INSTANCE_ID/connections" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY")
export ENDPOINT=$(jq -er '.http[] | select(.port == 30000) | .url' <<<"$CONNECTIONS")
[ -n "$ENDPOINT" ] && echo "ENDPOINT=$ENDPOINT" || jq . <<<"$CONNECTIONS"
```

```python Python theme={"dark"}
response = requests.get(
    f"{API}/v1/gpu/instances/{instance_id}/connections",
    headers=HEADERS,
    timeout=60,
)
response.raise_for_status()
connection = next(item for item in response.json()["http"] if item["port"] == 30000)
endpoint = connection["url"]
```

```typescript TypeScript theme={"dark"}
const connectionResponse = await fetch(`${API}/v1/gpu/instances/${instanceId}/connections`, {
  headers: auth,
});
if (!connectionResponse.ok) throw new Error(await connectionResponse.text());
const connections = await connectionResponse.json();
const connection = connections.http.find((item: { port: number }) => item.port === 30000);
if (!connection) throw new Error("port 30000 is not available in instance connections");
const endpoint = connection.url;
```

Wait until the model is loaded. The first successful `/v1/models` is the
readiness signal; until then the port returns connection errors or 5xx:

```bash theme={"dark"}
until curl -fsS "$ENDPOINT/v1/models" -H "Authorization: Bearer $SGLANG_API_KEY" >/dev/null 2>&1; do
  echo "model still loading..."; sleep 30
done
```

```bash curl theme={"dark"}
curl -sS "$ENDPOINT/v1/models" \
  -H "Authorization: Bearer $SGLANG_API_KEY"

curl -sS "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $SGLANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "What is 15% of 240?"}],
    "reasoning_effort": "high",
    "max_tokens": 4096
  }' | jq '.choices[0].message | {reasoning_content, content, tool_calls}'
```

```python Python theme={"dark"}
response = requests.post(
    f"{endpoint}/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['SGLANG_API_KEY']}"},
    json={
        "model": "kimi-k3",
        "messages": [{"role": "user", "content": "What is 15% of 240?"}],
        "reasoning_effort": "high",
        "max_tokens": 4096,
    },
    timeout=300,
)
response.raise_for_status()
assistant_message = response.json()["choices"][0]["message"]
print(assistant_message)
```

```typescript TypeScript theme={"dark"}
const response = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SGLANG_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "kimi-k3",
    messages: [{ role: "user", content: "What is 15% of 240?" }],
    reasoning_effort: "high",
    max_tokens: 4096,
  }),
});
if (!response.ok) throw new Error(await response.text());
const assistantMessage = (await response.json()).choices[0].message;
console.log(assistantMessage);
```

### Vision smoke test

`IMAGE_URL` is any image your server can fetch; a public sample is set here so
the test runs as written. Exercise the vision encoder separately from text:

```bash theme={"dark"}
export IMAGE_URL="https://upload.wikimedia.org/wikipedia/commons/3/3f/JPEG_example_flower.jpg"  # any public image works
```

```bash curl theme={"dark"}
curl -sS "$ENDPOINT/v1/chat/completions" \
  -H "Authorization: Bearer $SGLANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"kimi-k3\",
    \"messages\": [{
      \"role\": \"user\",
      \"content\": [
        {\"type\": \"text\", \"text\": \"Describe the image in one sentence.\"},
        {\"type\": \"image_url\", \"image_url\": {\"url\": \"$IMAGE_URL\"}}
      ]
    }],
    \"reasoning_effort\": \"low\",
    \"max_tokens\": 1024
  }"
```

```python Python theme={"dark"}
response = requests.post(
    f"{endpoint}/v1/chat/completions",
    headers={"Authorization": f"Bearer {os.environ['SGLANG_API_KEY']}"},
    json={
        "model": "kimi-k3",
        "messages": [{
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the image in one sentence."},
                {"type": "image_url", "image_url": {"url": os.environ["IMAGE_URL"]}},
            ],
        }],
        "reasoning_effort": "low",
        "max_tokens": 1024,
    },
    timeout=300,
)
response.raise_for_status()
print(response.json()["choices"][0]["message"]["content"])
```

```typescript TypeScript theme={"dark"}
const visionResponse = await fetch(`${endpoint}/v1/chat/completions`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.SGLANG_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "kimi-k3",
    messages: [{
      role: "user",
      content: [
        { type: "text", text: "Describe the image in one sentence." },
        { type: "image_url", image_url: { url: process.env.IMAGE_URL } },
      ],
    }],
    reasoning_effort: "low",
    max_tokens: 1024,
  }),
});
if (!visionResponse.ok) throw new Error(await visionResponse.text());
console.log((await visionResponse.json()).choices[0].message.content);
```

For the next turn, append `assistant_message` exactly as returned. Verify all
three reasoning levels, streaming, tool schemas, malformed-tool recovery, and a
real image request. Do not publish self-hosted video support: the current open
checkpoint metadata and serving processor establish text and image input only.

## 6. Qualify the operating point

SGLang's B300 figures used 8,192 input and 1,024 output tokens, 64 warm-up
requests, and cache flushes. Reproduce that baseline, then replace synthetic
traffic with your traces:

```bash theme={"dark"}
OPENAI_API_KEY="$SGLANG_API_KEY" python -m sglang.bench_serving \
  --backend sglang-oai \
  --base-url "$ENDPOINT" \
  --model kimi-k3 \
  --dataset-name random \
  --random-input-len 8192 \
  --random-output-len 1024 \
  --random-range-ratio 1.0 \
  --warmup-requests 64 \
  --flush-cache \
  --num-prompts 128
```

Measure text and image traffic separately. Sweep request length, image count,
concurrency, and arrival rate; report p50/p95/p99 TTFT, TPOT, queue time,
throughput, failures, HBM, the KDA state-pool admitted-request cap, KV
capacity, and cache hit rate.

Only after the target-only baseline passes should you test DSpark. Never set
`SGLANG_SIMULATE_ACC_LEN` in a production or accuracy run: upstream used it for
synthetic throughput projection, not measured acceptance. Compare DSpark and
target-only serving with identical prompts and retain tool/vision quality
tests.

> [!WARNING]
>
> A single instance is not a production service. AI Reserve raw compute does
> not yet manage replicas, a health-aware load balancer, draining, autoscaling,
> durable logs, or GPU metrics. Add those controls externally and retain a
> previously qualified image digest for rollback.

## 7. Clean up

```bash curl theme={"dark"}
curl -sS -X DELETE "$API/v1/gpu/instances/$INSTANCE_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: kimi-k3-terminate-v1"
curl -sS -X DELETE "$API/v1/gpu/volumes/$VOLUME_ID" \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Idempotency-Key: kimi-k3-delete-weights-v1"
```

```python Python theme={"dark"}
requests.delete(
    f"{API}/v1/gpu/instances/{instance_id}",
    headers={**HEADERS, "Idempotency-Key": "kimi-k3-terminate-v1"},
    timeout=60,
).raise_for_status()
requests.delete(
    f"{API}/v1/gpu/volumes/{volume_id}",
    headers={**HEADERS, "Idempotency-Key": "kimi-k3-delete-weights-v1"},
    timeout=60,
).raise_for_status()
```

```typescript TypeScript theme={"dark"}
for (const [path, key] of [
  [`/v1/gpu/instances/${instanceId}`, "kimi-k3-terminate-v1"],
  [`/v1/gpu/volumes/${volumeId}`, "kimi-k3-delete-weights-v1"],
] as const) {
  const response = await fetch(`${API}${path}`, {
    method: "DELETE",
    headers: { ...auth, "Idempotency-Key": key },
  });
  if (!response.ok) throw new Error(await response.text());
}
```

## Primary sources

* [Kimi K3 model card](https://huggingface.co/moonshotai/Kimi-K3)
* [Pinned model snapshot](https://huggingface.co/moonshotai/Kimi-K3/tree/f831ab66814297da540d832a5235f8e904f29d06)
* [SGLang Kimi K3 cookbook](https://docs.sglang.io/cookbook/autoregressive/Moonshotai/Kimi-K3)
* [vLLM Kimi K3 recipe](https://recipes.vllm.ai/moonshotai/Kimi-K3)
* [Kimi K3 API quickstart](https://platform.moonshot.ai/docs/guide/kimi-k3-quickstart)
* [Kimi K3 license](https://huggingface.co/moonshotai/Kimi-K3/blob/main/LICENSE)


# Quickstart
Source: https://docs.aireserve.com/gpu-infrastructure/quickstart

Quote an H100, launch it with SSH access, inspect the connection, and terminate it safely.

This walkthrough uses the `aireserve` CLI because it already covers the full
quote, launch, connection, and cleanup flow. You will create one GPU instance
with an ephemeral root disk and no persistent storage.

## Before you begin

You need:

* an organization API key with **Compute: Manage** access;
* an enabled, funded organization wallet;
* an SSH public key, such as `~/.ssh/id_ed25519.pub`;
* `jq`, which the steps below use to read IDs out of the CLI's output.

Your API key is the only value you type. Every other ID is captured into a
shell variable by the step that produces it.

**1. Install the CLI**

```bash theme={"dark"}
curl -fsSL https://get.aireserve.com/install.sh | sh -s -- --no-configure
```

**2. Export a Compute-enabled API key**

Create the key on the [API Keys page](https://portal.aireserve.com/keys). Keep it out of shell history and source control.

```bash theme={"dark"}
export AIRESERVE_API_KEY="aireserve_api_..."
```

**3. Request a quote**

```bash theme={"dark"}
aireserve gpu instances quote --accelerator H100_80GB
```

The quote creates nothing. It reports the selected normalized region, the running price, the price after stop, and a
short-lived quote ID.

```text theme={"dark"}
Quote ID:        <quote-id>   (expires in 120s)
Accelerator:     1 x H100_80GB    region: united_states
Running price:   $<total>/hr   = GPU $<gpu> + root disk 50 GiB $<disk>
After stop:      $0.00/hr   (nothing persists; nothing bills)
Storage:         root 50 GiB ephemeral only
```

Capture the ID for the next step. The CLI prints JSON whenever its output is not a terminal, so nothing is
copied by hand. Quotes expire after 120 seconds, so launch right away.

```bash theme={"dark"}
export QUOTE_ID=$(aireserve gpu instances quote --accelerator H100_80GB | jq -r .quoteId)
echo "QUOTE_ID=$QUOTE_ID"
```

**4. Launch and wait for SSH**

```bash theme={"dark"}
LAUNCHED=$(aireserve gpu instances launch \
  --quote-id "$QUOTE_ID" \
  --ssh-public-key-file ~/.ssh/id_ed25519.pub \
  --wait)
export INSTANCE_ID=$(jq -r .resourceId <<<"$LAUNCHED")
echo "INSTANCE_ID=$INSTANCE_ID"
```

`--wait` polls the durable operation until it reaches a terminal state, usually a minute or two, then returns the
instance and its connection details. If `INSTANCE_ID` prints `null`, the launch was refused: run
`jq . <<<"$LAUNCHED"` to read why. If the quote expired or the price moved, request a fresh quote and launch again.

**5. Connect**

```bash theme={"dark"}
aireserve gpu instances connections "$INSTANCE_ID"
```

Run the SSH command returned by the CLI. AI Reserve receives only the public key; your private key remains on your
machine.

**6. Terminate when finished**

```bash theme={"dark"}
aireserve gpu instances terminate "$INSTANCE_ID" --yes --wait
```

Termination releases the GPU and destroys the ephemeral root disk. It does not delete an attached persistent volume.

The quickstart uses one `H100_80GB`, any eligible normalized region, the
maintained PyTorch/CUDA image, a 50 GiB ephemeral root disk, and SSH only. The
quote is a price and placement decision—not a capacity reservation—so launch
rechecks current price and availability.

## Keep files between runs

Add a persistent volume to the quote when checkpoints, datasets, or outputs
must survive stop and termination:

```bash theme={"dark"}
aireserve gpu instances quote \
  --accelerator H100_80GB \
  --persistent-gb 500 \
  --mount-path /workspace
```

The quote shows both the total running price and the storage-only rate that
continues after the instance stops or terminates. Continue with [Storage and
persistence](/gpu-infrastructure/storage) before launching important data.

## Prefer direct REST?

The same flow is available through:

1. `POST /v1/gpu/instances/quote`
2. `POST /v1/gpu/instances` with an `Idempotency-Key`
3. `GET /v1/gpu/operations/{operationId}` until terminal
4. `GET /v1/gpu/instances/{instanceId}/connections`

Use the generated [API Reference](/api-reference) for exact wire schemas.


# Storage and persistence
Source: https://docs.aireserve.com/gpu-infrastructure/storage

Choose what survives instance lifecycle changes and understand exactly what continues billing.

Every instance has an ephemeral root disk. Use a persistent volume for anything
you cannot recreate: checkpoints, model weights, datasets, and outputs.

## Choose the storage lifecycle

| Storage | Survives stop | Survives terminate | Billing |
| - | - | - | - |
| Root disk | No | No | Included in the instance's running price |
| Persistent volume | Yes | Yes | From volume creation until explicit deletion, even while detached |

Files outside the persistent mount path live on the root disk and disappear when
the instance stops or terminates.

## Create storage with the instance

This is the recommended path because placement considers GPU stock and storage
support together:

```bash theme={"dark"}
aireserve gpu instances quote \
  --accelerator H100_80GB \
  --persistent-gb 500 \
  --mount-path /workspace
```

The quote includes:

* `instanceUsdPerHour`: GPU plus root disk;
* `persistentStorageUsdPerHour`: the volume rate;
* `totalRunningUsdPerHour`: everything billed while running;
* `storageOnlyUsdPerHour`: what continues after stop or termination.

Launch from the quote:

```bash theme={"dark"}
aireserve gpu instances launch --quote-id <quote-id> --wait
```

The volume is created before the instance in the same accepted transaction. A
retry with the same idempotency key cannot create a second volume.

## Reuse an existing volume

```bash theme={"dark"}
aireserve gpu instances quote \
  --accelerator H100_80GB \
  --volume-id <volume-id>
```

An existing volume pins placement to its provider account and location. If you
also pass `--region`, that region must include the volume's location. AI Reserve
returns `no_capacity` with `reason: volume_location` when no eligible GPU can
mount it within the request.

A volume supports one attached instance at a time. To move it elsewhere,
terminate the current instance and wait for termination to complete before
launching the replacement. Stopping alone does not currently make it attachable
to another instance.

## Create a standalone volume

Create storage before the GPU when you need to stage data:

```bash theme={"dark"}
aireserve gpu volumes create \
  --name weights \
  --size-gb 500 \
  --region europe \
  --accelerator H100_80GB \
  --storage-billing-acknowledged \
  --wait
```

The normalized request chooses a broad region rather than a provider data
center. `--accelerator` is a placement hint: AI Reserve places the volume in a
storage-capable location with current stock for that accelerator, so a later
launch of that accelerator can mount it. If no location in the region both sells
persistent storage and has that accelerator in stock, the request is refused with
`409 no_capacity` (`reason: no_persistent_storage`) listing the regions where it
would work, and no volume is created — a volume nothing you asked for could
mount would only bill. Omit the hint to place storage on the first
storage-capable location in the region regardless of GPU stock. The hint is not
a capacity reservation or guarantee. Storage billing begins when the volume is
created.

> [!NOTE]
>
> Volume list and get responses still include legacy data-center fields for compatibility. New integrations should use
> `region` and should not persist or make decisions from those provider-shaped fields.

## Inspect and delete volumes

```bash theme={"dark"}
aireserve gpu volumes list
aireserve gpu volumes get <volume-id>
```

The response includes normalized region, size, status, attachment, and hourly
storage rate.

Terminate the instance before deleting its attached volume:

```bash theme={"dark"}
aireserve gpu instances terminate <instance-id> --yes --wait
aireserve gpu volumes delete <volume-id> --yes --wait
```

> [!WARNING]
>
> Deleting a volume is irreversible. Terminating an instance never deletes its volume, so storage charges continue until
> the separate volume deletion succeeds.

## Grow a volume

Volumes can grow but cannot shrink. The current grow flow remains on the legacy
quote path: request a volume quote for the volume's existing data center, then
pass that quote ID to `gpu volumes grow`.

```bash theme={"dark"}
aireserve gpu quote \
  --datacenter <legacy-data-center-id> \
  --volume-size-gb 750

aireserve gpu volumes grow <volume-id> \
  --size-gb 750 \
  --quote-id <quote-id> \
  --wait
```

This provider-shaped grow quote is a transitional compatibility surface. Do not
use it as a pattern for new instance placement.

The REST counterparts live under `/v1/gpu/volumes`. Use the generated
[API Reference](/api-reference) for exact create, inspect, grow, and delete
schemas.


# Keys, registries, and usage
Source: https://docs.aireserve.com/gpu-infrastructure/supporting-resources

Prepare reusable SSH access and private-image credentials, then inspect GPU and storage charges.

Keep access material separate from instance requests. AI Reserve stores public
SSH keys and encrypted registry credentials as organization resources that you
can reference from future launches.

## SSH keys

For a one-off launch, pass a local public key file directly:

```bash theme={"dark"}
aireserve gpu instances launch \
  --accelerator H100_80GB \
  --max-hourly-price 3.50 \
  --ssh-public-key-file ~/.ssh/id_ed25519.pub \
  --wait
```

For a reusable organization key:

```bash theme={"dark"}
aireserve gpu ssh-keys add \
  --name laptop \
  --public-key "$(< ~/.ssh/id_ed25519.pub)"

aireserve gpu ssh-keys list
```

Reference the returned key ID at quote or launch time with `--ssh-key-id`.
Revoking a key excludes it from subsequent starts; it does not end an existing
SSH session on a running instance.

```bash theme={"dark"}
aireserve gpu ssh-keys revoke <key-id> --yes
```

> [!WARNING]
>
> Upload public keys only. Never pass a private key, password, or secret through `--public-key`.

## Private container registries

Add a credential once, then reference its ID from instance requests:

```bash theme={"dark"}
aireserve gpu registries add \
  --name ghcr-production \
  --registry ghcr.io \
  --username <username> \
  --wait
```

The CLI reads the password from a protected prompt or standard input; it does
not accept the password as an argument. Secrets are encrypted at rest and never
returned by list or get operations.

```bash theme={"dark"}
aireserve gpu registries list

aireserve gpu instances quote \
  --accelerator A100_80GB \
  --image ghcr.io/acme/trainer:latest \
  --registry-id <registry-credential-id>
```

Rotate or remove a stored credential with:

```bash theme={"dark"}
aireserve gpu registries replace <registry-credential-id> --wait
aireserve gpu registries delete <registry-credential-id> --yes --wait
```

An active resource can block rotation or deletion while it still references the
credential.

## Usage and charges

```bash theme={"dark"}
aireserve gpu usage
```

Usage records are immutable compute and storage billing windows. See
[Billing timeline](/gpu-infrastructure/operations#billing-timeline) for accrual
semantics and use the generated [API Reference](/api-reference) for exact SSH
key, registry credential, and usage schemas.

Templates remain available primarily for the provider-shaped Pods compatibility
flow. The normalized Instances request does not currently accept a template ID;
pass an image and workload settings explicitly instead.


# Every frontier model. One API key.
Source: https://docs.aireserve.com/index

Developer documentation for the AI Reserve AI gateway.

The AI Reserve AI gateway serves the full frontier catalog — chat, reasoning, vision, image generation, and video, plus dedicated GPU deployments — from every major provider behind one endpoint, one key, and one wallet. Point your existing SDK or coding harness at one base URL and everything just works. Teams on major cloud AI platforms get the same seamless path through native wire formats or our official SDKs.

> **[Claude Code & Codex](/connect/claude-code)**
>
> Point the agent harness you already run at AI Reserve — no code changes.

> **[Connect your SDK](/connect)**
>
> Stock OpenAI and Anthropic SDKs work with a base-URL swap.

> **[Models](/models)**
>
> The full catalog — chat, reasoning, vision, image and video generation.

> **[Your AI, right in Slack →](/connect/slack)**
>
> Mention `@aireserve` in any channel and every gateway model answers — billed
> to your org's wallet, no keys to paste, no extra seats.

> **Full catalog**
>
> Models across OpenAI, Anthropic, Google, xAI & more

> **1 key**
>
> Chat, tools, vision, image & video generation

> **3**
>
> Wire formats: OpenAI, Anthropic, Bedrock Converse

> **5**
>
> Official SDKs — Python, TypeScript, Go, Java, Rust

## Introduction

The AI Reserve AI gateway serves [frontier models](/models) from OpenAI,
Anthropic, Google, xAI, DeepSeek, Meta, Mistral, and more behind a single host —
`https://api.aireserve.com` — with one API key, unified billing,
per-user and per-team spend controls, and full usage analytics. Everything a modern AI
stack needs runs through it: streaming chat, tool use, vision,
[image generation](/capabilities/image-generation), [video input](/capabilities/video-input),
[video generation](/capabilities/video-generation),
[data endpoints](/capabilities/data-endpoints), and
[prompt caching](/capabilities/prompt-caching).

You do not have to change how you code. The gateway natively speaks three wire formats,
so almost any existing client points at it with a base-URL change:

> **OpenAI-compatible**
>
> `/v1/chat/completions`, `/v1/responses`, `/v1/models`, images and files — the OpenAI SDK, Vercel AI SDK, Codex, and any OpenAI-compatible framework work with a base-URL swap. See [Use your own SDK](/connect) or the [Migrating from OpenAI](/migrate/from-openai) guide.

> **Anthropic-compatible**
>
> `/v1/messages` and `count_tokens` — the Anthropic SDK, Claude Code, and the Claude Agent SDK connect via `ANTHROPIC_BASE_URL`. Same key, same models, plus every non-Claude model too. See [Migrating from Anthropic](/migrate/from-anthropic).

> **Bedrock Converse — wire format & SDKs**
>
> Unmodified `boto3` / AWS SDK clients point `endpoint_url` at the gateway ([guide](/connect/aws-sdk)), or use our **five official SDKs** — Python, TypeScript, Go, Java, Rust — that expose the exact Converse surface. Migration is a [constructor swap](/migrate/from-bedrock), not a rewrite.

> **Production behavior built in**
>
> Jittered exponential backoff on 429/5xx, `Retry-After` honored, budget errors never retried, streams piped without buffering, request IDs surfaced on every server error, and 321 offline conformance tests across the SDK matrix.


# Migrating from Anthropic
Source: https://docs.aireserve.com/migrate/from-anthropic

Keep the official anthropic package and change two lines — the base URL (host root, no /v1) and the API key.

Same story as [OpenAI](/migrate/from-openai): keep the official
`anthropic` package and change **two lines in client
construction**. System prompts, tool use, streaming events, and
`cache_control` blocks all pass through the gateway verbatim.

> [!NOTE]
>
> **Base URL — host root, no `/v1`.** The Anthropic SDK appends
> `/v1/messages` itself, so the base URL is
> `https://api.aireserve.com` — unlike OpenAI-flavored clients,
> which need the `/v1` suffix.

| Anthropic concept | AI Reserve equivalent |
| - | - |
| API key from `console.anthropic.com` | API key from your AI Reserve workspace (`aireserve_api_…`) — see [Authentication](/getting-started/get-an-api-key) |
| `ANTHROPIC_API_KEY` environment variable | `AIRESERVE_API_KEY`, or pass the key to the constructor |
| `https://api.anthropic.com` | `https://api.aireserve.com` (host root — no `/v1`) |
| Claude models only | Every [gateway model](/models) answers `/v1/messages` — GPT, Gemini, Grok, … via the same `messages.create` call |
| `count_tokens` | Identical — `POST /v1/messages/count_tokens`, free, no inference |

```diff Python theme={"dark"}
 import os
 from anthropic import Anthropic

 client = Anthropic(
-    api_key=os.environ["ANTHROPIC_API_KEY"],
+    base_url="https://api.aireserve.com",  # host root — NO /v1
+    api_key=os.environ["AIRESERVE_API_KEY"],
 )

 # Everything below is unchanged:
 res = client.messages.create(
     model="claude-sonnet-4-6",
     max_tokens=256,
     messages=[{"role": "user", "content": "hello"}],
 )

 # Streaming still yields message_start … message_stop events:
 with client.messages.stream(model=…, max_tokens=…, messages=…) as stream:
     for text in stream.text_stream:
         print(text, end="")
```

```diff TypeScript theme={"dark"}
 import Anthropic from "@anthropic-ai/sdk";

 const client = new Anthropic({
-  apiKey: process.env.ANTHROPIC_API_KEY,
+  baseURL: "https://api.aireserve.com", // host root — NO /v1
+  apiKey: process.env.AIRESERVE_API_KEY,
 });

 // Everything below is unchanged:
 const res = await client.messages.create({
   model: "claude-sonnet-4-6",
   max_tokens: 256,
   messages: [{ role: "user", content: "hello" }],
 });
```

The [AI Reserve SDKs speak the Anthropic format natively](/api-reference/sdk-wire-formats) too
(v0.5.0 in all five languages) — same `messages.create` /
`count_tokens` convention, one dependency for every wire format:

```python theme={"dark"}
from audacity import Audacity

client = Audacity()   # reads AIRESERVE_API_KEY

response = client.messages.create(   # same calling convention
    model="claude-sonnet-4-6",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello!"}],
)
```

**Claude Code and the Claude Agent SDK** migrate without touching this
section at all — they are configured entirely through
`ANTHROPIC_BASE_URL` / `ANTHROPIC_AUTH_TOKEN` environment
variables. See the [Claude Code recipe](/connect/claude-code).

> [!NOTE]
>
> **What carries over verbatim.** System prompts, tool use
> (`tool_use` / `tool_result` blocks), streaming events
> (`message_start` … `message_stop`), and
> [prompt caching](/capabilities/prompt-caching) — `cache_control` markers are
> forwarded to Anthropic unchanged, with the same minimums and 5-minute lifetime. What
> changes: the key and its environment variable, the base URL, and the model namespace —
> `/v1/messages` answers for every gateway model, not just Claude.


# Migrating from Bedrock
Source: https://docs.aireserve.com/migrate/from-bedrock

Imports and client construction change; message shapes, tool configs, streaming loops, and error handling carry over verbatim.

Migration is intentionally boring. In every language, the change is confined to
**imports and client construction** — plus swapping Bedrock model ARNs for
AI Reserve model IDs (for example `gpt-5.4-mini`, `gpt-5.5`,
`claude-opus-4-8`). Message shapes, tool configs, streaming loops, and error
handling carry over verbatim.

| Bedrock concept | AI Reserve equivalent |
| - | - |
| AWS region + credential chain / IAM | One bearer key: `AIRESERVE_API_KEY` |
| Model ARN (`anthropic.claude-3-5-sonnet-…`) | AI Reserve model ID (`claude-opus-4-8`, `gpt-5.5`, …) |
| `Converse` / `ConverseStream` | Identical — same names, same shapes |
| `toolConfig`, `toolUse`, `toolResult` | Identical |
| `ThrottlingException`, `ValidationException`, … | Identical exception names, same retryability semantics |
| Bedrock standard retry mode | Same policy: jittered backoff, `Retry-After` honored |

```diff Python theme={"dark"}
-import boto3
-client = boto3.client("bedrock-runtime", region_name="us-east-1")
+from audacity import Audacity
+client = Audacity(api_key="aireserve_api_…")   # only line that changes

 response = client.converse(
-    modelId="anthropic.claude-3-sonnet-20240229-v1:0",
+    modelId="gpt-5.4-mini",                   # use an AI Reserve model ID
     messages=[{"role": "user", "content": [{"text": "Hi"}]}],
 )

 # Streaming call sites are identical:
 stream_resp = client.converse_stream(modelId=…, messages=…)
 for event in stream_resp["stream"]:
     …
```

```diff TypeScript theme={"dark"}
-import {
-  BedrockRuntimeClient,
-  ConverseCommand,
-  ConverseStreamCommand,
-} from "@aws-sdk/client-bedrock-runtime";
+import {
+  AudacityRuntimeClient as BedrockRuntimeClient,
+  ConverseCommand,
+  ConverseStreamCommand,
+} from "@audacity/sdk";

-const client = new BedrockRuntimeClient({ region: "us-east-1" });
+const client = new BedrockRuntimeClient({ apiKey: process.env.AIRESERVE_API_KEY });

 const response = await client.send(
   new ConverseCommand({
     modelId: "gpt-5.4-mini",
     messages: [{ role: "user", content: [{ text: "Hi" }] }],
   })
 );
```

```diff Go theme={"dark"}
 import (
-    "github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
-    "github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
+    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime"
+    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime/types"
 )

-client := bedrockruntime.NewFromConfig(cfg)
+client := audacityruntime.New(audacityruntime.Options{})  // reads AIRESERVE_API_KEY

 resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
-    ModelId: aws.String("anthropic.claude-3-5-sonnet-20241022-v2:0"),
+    ModelId: audacity.String("gpt-5.4-mini"),
     Messages: []types.Message{{ … }},
 })
```

```diff Java theme={"dark"}
-BedrockRuntimeClient client = BedrockRuntimeClient.builder()
-    .region(Region.US_EAST_1)
-    .credentialsProvider(DefaultCredentialsProvider.create())
-    .build();
+var client = AudacityRuntimeClient.builder()
+    .apiKey(System.getenv("AIRESERVE_API_KEY"))
+    .build();

 ConverseResponse response = client.converse(req -> req
-    .modelId("anthropic.claude-3-5-sonnet-20241022-v2:0")
+    .modelId("gpt-5.4-mini")
     .messages(Message.builder()
         .role(ConversationRole.USER)
         .content(ContentBlock.fromText("Hi"))
         .build())
     .inferenceConfig(cfg -> cfg.maxTokens(500).temperature(0.2f)));
```

```diff Rust theme={"dark"}
-use aws_sdk_bedrockruntime::Client;
-use aws_sdk_bedrockruntime::types::{ContentBlock, ConversationRole, Message};
+use audacity_sdk::{Client, ContentBlock, ConversationRole, Message};

-let config = aws_config::load_from_env().await;
-let client = Client::new(&config);
+let client = audacity_sdk::Client::from_env()?;   // reads AIRESERVE_API_KEY

 let response = client.converse()
-    .model_id("anthropic.claude-3-5-sonnet-20241022-v2:0")
+    .model_id("gpt-5.4-mini")
     .messages(
         Message::builder()
             .role(ConversationRole::User)
             .content(ContentBlock::Text("Hello".into()))
             .build()?
     )
     .send()
     .await?;
```

> [!NOTE]
>
> **Java note.** `converseStream` in the AI Reserve SDK is synchronous
> (a blocking push handler or a pull iterator) rather than the AWS async
> `CompletableFuture` publisher — for most codebases this removes boilerplate rather
> than adding it.

## Bedrock-routed models

Some teams prefer a model's serving behavior *via AWS Bedrock* over the provider's
direct API. AI Reserve offers both paths behind the same endpoint: append
`-bedrock` to a model ID and the gateway routes that request through AWS
Bedrock instead of the provider directly. Everything else — SDK, key, shapes,
streaming, errors — is identical, so you can A/B the two paths by changing only the
model string.

```python theme={"dark"}
# Direct provider API
client.converse(modelId="claude-opus-4-8", messages=…)

# Same model, routed through AWS Bedrock
client.converse(modelId="claude-opus-4-8-bedrock", messages=…)
```

| Direct model ID | Bedrock-routed variant |
| - | - |
| `claude-fable-5-1` | `claude-fable-5-1-bedrock` |
| `claude-fable-5` | `claude-fable-5-bedrock` |
| `claude-opus-5-5` | `claude-opus-5-5-bedrock` |
| `claude-opus-5` | `claude-opus-5-bedrock` |
| `claude-opus-4-8` | `claude-opus-4-8-bedrock` |
| `claude-opus-4-7` | `claude-opus-4-7-bedrock` |
| `claude-opus-4-6` | `claude-opus-4-6-bedrock` |
| `claude-sonnet-5-5` | `claude-sonnet-5-5-bedrock` |
| `claude-sonnet-5` | `claude-sonnet-5-bedrock` |
| `claude-sonnet-4-6` | `claude-sonnet-4-6-bedrock` |
| `claude-sonnet-4-5` | `claude-sonnet-4-5-bedrock` |
| `claude-haiku-4-5-20251001` | `claude-haiku-4-5-bedrock` |
| `llama-4-maverick` | `llama-4-maverick-bedrock` |
| `llama-4-scout` | `llama-4-scout-bedrock` |
| `mistral-large` | `mistral-large-bedrock` |
| `deepseek-reasoner` | `deepseek-reasoner-bedrock` |
| `deepseek-v3.2` | `deepseek-v3.2-bedrock` |
| `glm-4.7-novita` | `glm-4.7-bedrock` |

Models that Bedrock does not serve (OpenAI GPT, Gemini, Grok, Perplexity Sonar, Moonshot)
have no `-bedrock` variant — the direct IDs remain the only path for those.

Every variant routes through AWS Bedrock. Since October 7, 2026 the Claude variants
come in two geographies, priced exactly as Bedrock prices them:

| Suffix | Bedrock inference profile | Processing | Price |
| - | - | - | - |
| `-bedrock` | `global.anthropic.claude-…` (global cross-region) | Any AWS commercial region | Anthropic list |
| `-bedrock-us` | `us.anthropic.claude-…` (US geographic cross-region) | AWS US regions only | Anthropic list × 1.1 (Bedrock's geographic uplift) |

Append `-bedrock-us` instead of `-bedrock` when your data must stay in the United
States (for example `claude-opus-4-8-bedrock-us`). The twelve Claude variants above all
have a `-bedrock-us` twin; the Llama, Mistral and DeepSeek variants are single-leg. If
your code sends a raw AWS id, the `us.` form resolves to the `-bedrock-us` leg and the
`global.` / bare forms resolve to the `-bedrock` leg (see [AWS SDK](/connect/aws-sdk)).

## Latency

Compared to calling a provider (or Bedrock) directly from your own code, the AI Reserve
gateway adds a small, **fixed** toll — authentication, rate limiting,
quota checks, and request translation:

| Component | Added latency |
| - | - |
| Auth + rate limit (gateway edge) | \~10–30 ms |
| Quota / spend-cap checks (proxy) | \~10–30 ms |
| Request translation (router) | \~20–60 ms |
| Cross-cloud hop (region dependent) | \~5–40 ms |

Rule of thumb: **\~60–200 ms added to time-to-first-token, and effectively
zero between tokens** — streaming responses are piped through without
re-buffering, so inter-token latency is determined entirely by the model provider.
Against typical generation times of seconds to tens of seconds, the overhead is low
single-digit percent. The toll does not grow with context size or generation length.

Note that provider-side differences (for example, Bedrock vs. direct-API
time-to-first-token for the same Claude model, which varies by region and load) are
independent of the gateway and typically larger than the gateway's own overhead. The
`-bedrock` variants make measuring both paths for your workload a
one-string A/B test.

Already on boto3 or the AWS JS SDK and want to keep them? See
[AWS SDK (boto3)](/connect/aws-sdk) — the gateway serves the Bedrock Converse API at the
same paths, so unmodified clients work by overriding the endpoint.


# Migrating from Fish Audio
Source: https://docs.aireserve.com/migrate/from-fish-audio

Keep your Fish Audio client. Point it at api.aireserve.com/fish-audio with your AI Reserve API key — text to speech, speech to text and voice design pass through unchanged and land on your AI Reserve ledger.

AI Reserve serves the **Fish Audio API** at `https://api.aireserve.com/fish-audio`.
A Fish Audio client whose base URL is repointed here — the `fish-audio-sdk`
Python package, the `fish-audio` JavaScript package, curl — keeps working after
**two settings change**: the base URL and the key. The gateway authenticates
your AI Reserve key, swaps it for AI Reserve's Fish Audio key, forwards the
request exactly as you sent it (JSON or MessagePack, multipart uploads, the
`model` header), relays Fish's answer exactly as Fish gave it, and books each
successful request to your wallet at Fish's list price.

Any AI Reserve API key works here; there is no separate credential and no
organization setting to turn on.

| Fish Audio setting | AI Reserve value |
| - | - |
| Base URL (default `https://api.fish.audio`) | `https://api.aireserve.com/fish-audio` — the client appends its own paths, so `/v1/tts` becomes `https://api.aireserve.com/fish-audio/v1/tts` |
| `FISH_API_KEY` from fish.audio | Your AI Reserve API key (`aireserve_api_…`). Same `Authorization: Bearer` header |

> [!NOTE]
>
> **This is a passthrough, not a translation.** Request bodies, the `model` header, voice ids (`reference_id`),
> inline `references` for zero-shot cloning, output formats, response shapes and Fish's own errors are all Fish's.
> The OpenAI-shaped alternative — `POST /v1/audio/speech` with `grok-tts` or the `eleven-*` models — is documented
> under [Text to speech](/capabilities/text-to-speech).

## What is served

| Fish Audio endpoint | Through AI Reserve | Billed as |
| - | - | - |
| `POST /v1/tts` | ✅ | UTF-8 bytes of `text` at \*\*$15 per million** (`s2.1-pro`, `s2-pro`, `drama-3`, `s1`); `s2.1-pro-free` at $0 |
| `POST /v1/tts/stream/with-timestamp` | ✅ | Same as `/v1/tts` |
| `POST /v1/asr` | ✅ | Audio seconds, rounded up, at **\$0.36 per hour** (`transcribe-1-pro` and `transcribe-1`) |
| `POST /v1/voice-design` | ✅ | **\$0.01** per successful request |
| `GET /model`, `GET /model/{id}` | ✅ | Free — browse the voice library and read a voice's details |
| `POST` / `PATCH` / `DELETE /model` | ❌ `403` | Stored voice models are not available yet (below) |
| `wss://…/v1/tts/live` | ❌ `403` | WebSocket streaming is not served yet; `POST /v1/tts` streams its bytes |
| `/wallet/*` | ❌ `403` | Your usage is billed to your AI Reserve wallet, not a Fish balance |
| `/v1/agent/*` | ❌ `403` | The Fish voice-agent platform is not available through AI Reserve |
| Anything else | ❌ `404` | |

The model is selected the way Fish selects it: the `model` **HTTP header**.
Without it, or with an id Fish does not recognise, synthesis is served and
billed as `s2.1-pro`; transcription is served and billed as `transcribe-1`
unless the header reads exactly `transcribe-1-pro`. The header is forwarded
as you sent it.

Each successful call appears as its own line in **Observe › Event Log** and
**Financials** (model `fish-audio:s2.1-pro`, `fish-audio:transcribe-1-pro`,
`fish-audio:voice-design-1`, …, with Fish's `X-Generation-Id`, the metered
bytes or seconds and the rate in its details). Fish does not bill requests
that fail, and neither does AI Reserve: a `4xx` or `5xx` from Fish is relayed
and books nothing.

## What to change

```diff Shell theme={"dark"}
-export FISH_API_KEY="…"
+export FISH_API_KEY="aireserve_api_…"                     # your AI Reserve API key
+export FISH_BASE_URL="https://api.aireserve.com/fish-audio"
```

```python Python (fish-audio-sdk ≥ 1.0) theme={"dark"}
import os
from fishaudio import FishAudio
from fishaudio.core.request_options import RequestOptions
from fishaudio.utils import save

client = FishAudio(
    api_key=os.environ["FISH_API_KEY"],          # aireserve_api_…
    base_url="https://api.aireserve.com/fish-audio",
)

audio = client.tts.convert(text="Hello from Fish Audio, through AI Reserve.", model="s2.1-pro")
save(audio, "hello.mp3")

with open("meeting.wav", "rb") as f:
    transcript = client.asr.transcribe(
        audio=f.read(),
        request_options=RequestOptions(additional_headers={"model": "transcribe-1-pro"}),
    )
print(transcript.text, transcript.duration)
```

```ts TypeScript (fish-audio) theme={"dark"}
import { FishAudioClient } from "fish-audio";

const fishAudio = new FishAudioClient({
  apiKey: process.env.FISH_API_KEY,                 // aireserve_api_…
  baseUrl: "https://api.aireserve.com/fish-audio",
});

const audio = await fishAudio.textToSpeech.convert({ text: "Hello from Fish Audio, through AI Reserve." }, "s2.1-pro");
const transcript = await fishAudio.speechToText.convert({ audio: myAudio }, { headers: { model: "transcribe-1-pro" } });
const voices = await fishAudio.voices.search({ title: "narrator" });
```

```bash curl theme={"dark"}
# Text to speech (JSON; the SDKs send MessagePack — both pass through)
curl -X POST https://api.aireserve.com/fish-audio/v1/tts \
  -H "Authorization: Bearer $FISH_API_KEY" -H "Content-Type: application/json" -H "model: s2.1-pro" \
  -d '{"text":"Hello from Fish Audio, through AI Reserve.","reference_id":"933563129e564b19a115bedd57b7406a","format":"mp3"}' \
  --output hello.mp3

# Speech to text
curl -X POST https://api.aireserve.com/fish-audio/v1/asr \
  -H "Authorization: Bearer $FISH_API_KEY" -H "model: transcribe-1-pro" \
  -F "audio=@meeting.wav" -F "ignore_timestamps=false"

# Voice library
curl "https://api.aireserve.com/fish-audio/model?title=narrator&language=en" -H "Authorization: Bearer $FISH_API_KEY"
```

## Voice cloning

Fish offers two ways to clone a voice. **Instant cloning** — reference audio
and its transcript sent inline in `references` on `/v1/tts` — works unchanged
through AI Reserve and needs nothing stored. **Stored voice models**
(`POST /model`, which returns a reusable `_id`) are not available yet: every
AI Reserve organization reaches Fish through one shared account, and a model
stored there would be visible to every other organization's `GET /model?self=true`.
Until stored clones are tenant-scoped, `POST`, `PATCH` and `DELETE /model`
answer `403` with
`Stored voice models cannot be created, changed or deleted through AI Reserve yet. Clone per request by sending reference audio in \`references\` on /v1/tts, or pick a library voice from GET /model.\`

## What AI Reserve enforces

Every refusal is a JSON `{ "status": <code>, "message": "…" }` body, the
smallest shape Fish's clients read, and names its cause in `message`.

* **Your organization's policies.** The key is checked exactly as on every AI
  Reserve endpoint: paused keys (`401`), invalid keys (`401`, `Invalid API
  key.`), per-key IP allowlists and organization network policies (`403`),
  rate limits (`429` with `Retry-After`), and — on every `POST` — your
  organization's spend caps and wallet (`402`). A Fish request is a wallet
  request: an exhausted budget refuses it before Fish is called.
* **Metering is a precondition, not an afterthought.** A `/v1/tts` body the
  gateway cannot read as JSON or MessagePack with a string `text` is refused
  with `400` before any upstream call; a deployment that cannot reach the
  ledger refuses billable calls with `503` rather than serving them unmetered.
* **Headers.** Your `Authorization` and `x-api-key` are replaced by AI
  Reserve's Fish key; `Accept-Encoding` is pinned to `identity` so Fish's
  bytes are the bytes relayed. The `model` header, content types and your
  client's user agent go through. Fish's `X-Generation-Id` comes back on
  every synthesis and transcription.
* **A request log.** Each call is recorded with method, path, Fish's
  generation id, upstream status, byte counts, time-to-headers, duration,
  outcome, your key id, and the metered amount. Refusals are recorded with
  their outcome before any upstream request. Neither includes bodies,
  audio, or credentials.
* **Transport.** Fish unreachable → `503`; no response headers within the
  time-to-headers bound (sized for multi-minute transcriptions) → `504`; a
  stream that has started is never cut by that bound.

## Limits

* **Rate limits are Fish's concurrency tiers, shared.** Fish limits
  concurrent requests per account, not per key; AI Reserve's account tier is
  shared across every organization using this endpoint, and a `429` from Fish
  is relayed as Fish sends it (without `Retry-After`). Back off
  exponentially, as Fish's own docs advise.
* **One Fish account, Fish's data handling.** Text, audio uploads and
  reference audio reach Fish Audio under AI Reserve's account and Fish's
  terms. See the [provider data-handling page](https://privacy.aireserve.com/data-handling).
* **No stored voices, no WebSockets, no agents, no wallet** (above).
* **The native API only.** Fish's OpenAI- and ElevenLabs-compatible
  endpoints (`/compat/*`, `/elevenlabs/*`) are not mounted; use the OpenAI
  shape on AI Reserve's own [`/v1/audio/speech`](/capabilities/text-to-speech)
  instead.


# Migrating from OpenAI
Source: https://docs.aireserve.com/migrate/from-openai

Two lines in client construction — the base URL and the API key. Everything else passes through verbatim.

Migration is intentionally boring. If you call OpenAI through the official
`openai` package, the change is **two lines in client
construction** — the base URL and the API key. Message shapes, tool definitions,
streaming loops, `temperature` and every other request field pass through
the gateway verbatim, so nothing else in your codebase changes.

| OpenAI concept | AI Reserve equivalent |
| - | - |
| API key from `platform.openai.com` | API key from your AI Reserve workspace (`aireserve_api_…`) — see [Authentication](/getting-started/get-an-api-key) |
| `OPENAI_API_KEY` environment variable | `AIRESERVE_API_KEY`, or pass the key to the constructor |
| `https://api.openai.com/v1` | `https://api.aireserve.com/v1` (keep the `/v1` suffix) |
| OpenAI models only | Every [gateway model](/models) — Claude, Gemini, Grok, Llama, … answer the same `chat.completions` call |
| OpenAI error objects | Same shapes on standard HTTP statuses (400/401/404/429/5xx) — see [Errors & retries](/api-reference/errors) |

```diff Python theme={"dark"}
 import os
 from openai import OpenAI

 client = OpenAI(
-    api_key=os.environ["OPENAI_API_KEY"],
+    base_url="https://api.aireserve.com/v1",  # note the /v1 suffix
+    api_key=os.environ["AIRESERVE_API_KEY"],
 )

 # Everything below is unchanged — and now works with any gateway model:
 res = client.chat.completions.create(
-    model="gpt-4o-mini",
+    model="gpt-5.4-mini",   # or claude-sonnet-4-6, gemini-2.5-flash, …
     messages=[{"role": "user", "content": "hello"}],
 )

 # Streaming call sites are identical:
 for chunk in client.chat.completions.create(model=…, messages=…, stream=True):
     print(chunk.choices[0].delta.content or "", end="")
```

```diff TypeScript theme={"dark"}
 import OpenAI from "openai";

 const client = new OpenAI({
-  apiKey: process.env.OPENAI_API_KEY,
+  baseURL: "https://api.aireserve.com/v1", // note the /v1 suffix
+  apiKey: process.env.AIRESERVE_API_KEY,
 });

 // Everything below is unchanged — and now works with any gateway model:
 const res = await client.chat.completions.create({
-  model: "gpt-4o-mini",
+  model: "gpt-5.4-mini", // or claude-sonnet-4-6, gemini-2.5-flash, …
   messages: [{ role: "user", content: "hello" }],
 });
```

Prefer one dependency across all of your model traffic? The
[AI Reserve SDKs expose the OpenAI format natively](/api-reference/sdk-wire-formats) (v0.5.0 in
all five languages), with the gateway's [retry policy and exception
taxonomy](/api-reference/errors) built in. The calling convention is identical — only the import and
constructor change:

```python theme={"dark"}
from audacity import Audacity

client = Audacity()   # reads AIRESERVE_API_KEY

response = client.chat.completions.create(   # same calling convention
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
```

> [!NOTE]
>
> **What carries over verbatim.** Messages, `tools` /
> `tool_choice`, `response_format`, sampling parameters, and
> streaming loops — requests pass through unmodified, and streams still end at
> `data: [DONE]`. What changes: the key and its environment variable, the
> base URL, and the model namespace — every gateway model is now callable from the same
> code, and `GET /v1/models` enumerates the live catalog.


# Migrating from RunPod
Source: https://docs.aireserve.com/migrate/from-runpod

Keep your RunPod client. Point it at api.aireserve.com with a RunPod credential from the AI Reserve portal — every call passes through unchanged to the RunPod organization contracted for you.

AI Reserve serves the **RunPod API** at `https://api.aireserve.com`. A RunPod
client whose base URL is repointed here — the REST v2 TypeScript SDK, the
`runpod` Python package, the Serverless job SDKs, the local RunPod MCP server,
`runpodctl` for part of its surface, a generated OpenAPI client, curl — keeps
working after **two settings change**: the base URL and the key. The gateway
authenticates your AI Reserve credential, swaps it for the upstream key of the
RunPod organization contracted for you, forwards the request exactly as you
sent it, and relays RunPod's answer exactly as RunPod gave it. There is no
operation allowlist: the whole of RunPod REST v2, the GraphQL API and
Serverless job invocation pass through, minus a short list of
tenancy-protecting denials described under
[What AI Reserve enforces](#what-ai-reserve-enforces).

This endpoint is for organizations with a RunPod contract that AI Reserve has
**assigned** to them: a RunPod Organization provisioned under that contract and
recorded against your AI Reserve organization. Without an assignment every
call is refused before it reaches RunPod.

| RunPod setting | AI Reserve value |
| - | - |
| `RUNPOD_API_BASE_URL` (REST v2 + GraphQL; default `https://api.runpod.io`) | `https://api.aireserve.com` — **no `/v2` suffix**; the client adds it, so requests become `https://api.aireserve.com/v2/pods` |
| `RUNPOD_ENDPOINT_BASE_URL` (Serverless jobs; default `https://api.runpod.ai/v2`) | `https://api.aireserve.com/serverless/v2` |
| GraphQL endpoint (`https://api.runpod.io/graphql`) | `https://api.aireserve.com/graphql` |
| `RUNPOD_API_KEY` from the RunPod console | A **RunPod credential** (`aireserve_api_…`) created under **Compute › RunPod** in the AI Reserve portal. Same `Authorization: Bearer` header. An ordinary inference key is refused |

> [!NOTE]
>
> **This is a passthrough, not a translation.** Resource ids, request bodies, response shapes, pagination,
> `RateLimit` headers, `application/problem+json` errors, SSE log streams — all RunPod's own. Resources you create
> live in the RunPod organization contracted for you, so ids from a personal RunPod account do not carry over; RunPod
> does not move personal resources into an organization on its own
> ([Access](https://docs.runpod.io/organizations/orgs-access)).

## How tenancy works

The isolation is RunPod's, not a filter in the gateway.

* **The organization is the tenancy wall.** RunPod Organizations are its
  enterprise account model: "an organization is a first-class entity that owns
  all resources independent of any individual member, including compute,
  storage, secrets, and templates", and "A user belongs to at most one
  organization"
  ([Organizations](https://docs.runpod.io/organizations/orgs-overview)). The
  upstream key AI Reserve holds for you belongs to a member of **your**
  organization and to nothing else, so nothing outside it is reachable. RunPod
  notes that "Organizations are currently in beta. Runpod provisions
  organization accounts and enables them for your account"
  ([Organizations](https://docs.runpod.io/organizations/orgs-overview)) — which
  is why AI Reserve arranges the organization under the contract rather than
  creating it through an API.
* **The Dev role bounds management.** The member that minted the upstream key
  holds RunPod's **Dev** role: "Full compute access with no billing or member
  management. Devs can deploy Pods, create Serverless endpoints, manage network
  volumes, Instant Clusters, and templates. They cannot view billing, manage
  cost centers, or manage members or groups"
  ([Roles](https://docs.runpod.io/organizations/org-roles)).
* **The Restricted key bounds permission.** RunPod API keys are created with
  **All**, **Restricted** or **Read Only** access; a Restricted key sets
  **None**, **Restricted**, **Read/Write** or **Read Only** per RunPod API
  ([API keys](https://docs.runpod.io/get-started/credentials#api-keys)). Your
  read/write credential maps to a Restricted key with Read/Write on the compute
  APIs; your read-only credential maps to a Read Only key. RunPod enforces
  these at the source: "Keys are scoped to the permissions granted when
  created; requests may return `403` when a valid key lacks access to the
  requested resource or action" (security scheme in
  [`openapi.json`](https://api.runpod.io/v2/openapi.json)).
* **Visibility follows the member.** "By default, a member can only see
  resources they created themselves. When a resource is assigned to a group,
  all members of that group can see it, regardless of who created it"
  ([Groups](https://docs.runpod.io/organizations/orgs-groups)). Everything you
  create through this endpoint is created by that member and is visible to
  you. A resource created directly in the RunPod console by someone else
  appears through this endpoint only once an organization admin assigns it to
  a group that member belongs to. Templates are listed "owned by the
  authenticated user (including team/organization-scoped ones)"
  ([`GET /v2/templates`](https://docs.runpod.io/api-reference-v2/templates/list-templates)).

The gateway adds defense in depth on top — the denials below — but it never
needs to know which resource is whose.

## Get a RunPod credential

A RunPod credential is an AI Reserve API key bound to a RunPod permission
level. You never see a RunPod key.

1. In the portal open **Compute › RunPod**. The page shows the RunPod
   organization assigned to you (id and name, as RunPod reported them when AI
   Reserve verified the upstream key) and your existing credentials. If no
   organization is assigned yet, creating a credential is refused with
   "No RunPod organization is assigned to your organization yet. Contact AI
   Reserve to assign your contracted RunPod organization."
2. Choose a name and a permission:
   * **read-only** — RunPod's **Read Only** level. Lists and reads only:
     `GET`/`HEAD` on REST v2 and Serverless, queries only on GraphQL. Any
     mutation is refused by the gateway with
     `This RunPod credential is read-only.` before it reaches RunPod.
   * **read/write** — RunPod's **Restricted** level with Read/Write on pods,
     Serverless, templates, volumes, clusters and registries. Resource
     mutations pass; account and organization management does not (below).
3. Copy the key. It is shown **once**; afterwards only its prefix and suffix
   are displayed. Organization admins create and revoke credentials; revoking
   one stops every client using it until you create another.

Credentials carry the **RunPod** badge on the API Keys page and cannot be
edited into another category. A key created anywhere else — an ordinary
inference key, a customer key, a CI key — is refused on this endpoint with
`403` and the detail `This API key is not a RunPod credential. Create one under
Compute › RunPod in the AI Reserve portal.` Keyless (OIDC) callers get the
same answer: the RunPod surface is key-only.

## Which RunPod clients work

| Client | Works | How |
| - | - | - |
| **`@runpod/typescript-api-sdk`** (`createRunpodClient`) | ✅ | Reads `RUNPOD_API_BASE_URL` + `RUNPOD_API_KEY` (or `createRunpodClient({ baseUrl, apiKey })`). Base URL without `/v2`; the SDK's paths carry it. |
| **`runpod` Python package, 2.0.0rc1 and later** — pods, templates, endpoints, volumes | ✅ | REST v2 control plane. Reads `RUNPOD_API_BASE_URL`, `RUNPOD_ENDPOINT_BASE_URL` and `RUNPOD_API_KEY` from the environment. |
| **`runpod` Python package, 1.12.0 (current stable)** — pods, templates, endpoints | ⚠️ | GraphQL-only control plane at `${RUNPOD_API_BASE_URL}/graphql`. Reads the two URL variables but **not** `RUNPOD_API_KEY`: set `runpod.api_key = "aireserve_api_…"` in code, or store it once with `runpod config` ([SkyPilot integration](https://docs.runpod.io/integrations/skypilot)). GraphQL is deprecated and "will be retired in early 2027" ([GraphQL API](https://docs.runpod.io/sdks/graphql/configurations)). |
| **`runpod.Endpoint`** Serverless jobs (`run_sync`, `run`, `status`, `stream`, `health`, `purge_queue`), any version | ✅ | `RUNPOD_ENDPOINT_BASE_URL=https://api.aireserve.com/serverless/v2`, key as in the row for your version. |
| **`runpodctl`** | ⚠️ | Partial. Set `RUNPOD_GRAPHQL_URL`, `RUNPOD_REST_V2_URL`, `RUNPOD_INVOKE_URL` and `RUNPOD_API_KEY`. **Works:** `gpu list`, `user`, `ssh list-keys`, `ssh connect`, GPU `pod create`, `pod logs`, `serverless logs`, `serverless run`, `serverless status`, `serverless health`. **Does not work:** `pod list`, `pod get`, `pod stop`, `pod start`, `pod restart`, `pod reset`, `pod delete`, `pod update`, CPU `pod create`, `serverless create`, `serverless list`, `serverless get`, `serverless update`, `serverless delete`, `template`, `network-volume`, `registry`, `billing` — these call REST v1 (`rest.runpod.io/v1`), which is not served and which RunPod retires on **November 15, 2026** ([REST API v1](https://docs.runpod.io/api-reference/overview)). `ssh add-key` is also refused: it is the GraphQL `updateUserSettings` mutation (see below); manage SSH keys through `PUT /v2/account/ssh-keys` instead. |
| **`@runpod/mcp-server`**, local (Claude Code, Codex CLI, Cursor, Claude Desktop, …) | ✅ | Four host variables plus the key: `RUNPOD_API_BASE_URL` (REST v2 tools), `RUNPOD_SERVERLESS_API_URL` (job tools), `RUNPOD_PUBLIC_GRAPHQL_URL` and `RUNPOD_AUTHED_GRAPHQL_URL` (GraphQL tools), `RUNPOD_API_KEY`. Setting only `RUNPOD_API_BASE_URL` leaves the GraphQL and job tools pointed at RunPod directly. |
| **Hosted RunPod MCP server** (`https://mcp.getrunpod.io/`) | ❌ | RunPod's hosted service calls RunPod's API itself and has no base-URL setting; it cannot be pointed at AI Reserve ([MCP servers](https://docs.runpod.io/get-started/mcp-servers)). Use the local server. |
| **`runpod-sdk`** (JavaScript Serverless SDK) | ✅ | Constructor option: `runpodSdk(apiKey, { baseUrl: "https://api.aireserve.com/serverless/v2" })`. No environment variable. |
| **Go SDK v2** (`github.com/runpod/go-sdk/v2`) | ✅ | `runpod.New(runpod.WithBaseURL("https://api.aireserve.com"))`; key from `RUNPOD_API_KEY` or `runpod.WithAPIKey`. `New()` does not read `RUNPOD_API_BASE_URL`. |
| **Go Serverless SDK** (`github.com/runpod/go-sdk/pkg/sdk/endpoint`) | ✅ | `Option{ EndpointId, EndpointUrl }` with `EndpointUrl` = `https://api.aireserve.com/serverless/v2`. |
| **Raw REST v2 / GraphQL** (`curl`, your own HTTP client, generated clients from `api.aireserve.com/v2/openapi.json`) | ✅ | Replace the host. RunPod's documented GraphQL form, "your API key included as a query parameter" ([GraphQL API](https://docs.runpod.io/sdks/graphql/configurations)), is accepted: a `?api_key=aireserve_api_…` is lifted into the Authorization header before routing and never forwarded. |
| **OpenAI-compatible vLLM endpoints** (`…/v2/<endpoint-id>/openai/v1`) | ✅ | Base URL `https://api.aireserve.com/serverless/v2/<endpoint-id>/openai/v1` ([OpenAI compatibility](https://docs.runpod.io/serverless/vllm/openai-compatibility)). |
| **REST v1** (`rest.runpod.io/v1`) | ❌ | Not mounted. RunPod retires it on November 15, 2026 and offers `/runpod:migrate rest` to move an integration to v2 ([REST API v1](https://docs.runpod.io/api-reference/overview)). |
| **Per-endpoint load-balancer hostnames** (`https://<endpoint-id>.api.runpod.ai/...`) | ❌ | Hostname-addressed, not path-addressed; call those endpoints directly. |

## What to change

```diff Shell theme={"dark"}
-export RUNPOD_API_KEY="rpa_…"
+export RUNPOD_API_BASE_URL="https://api.aireserve.com"                    # no /v2 suffix
+export RUNPOD_ENDPOINT_BASE_URL="https://api.aireserve.com/serverless/v2"  # Serverless jobs only
+export RUNPOD_API_KEY="aireserve_api_…"                                   # your RunPod credential
```

```ts TypeScript SDK theme={"dark"}
import { createRunpodClient } from "@runpod/typescript-api-sdk";

// Nothing to change in code: the client reads RUNPOD_API_BASE_URL and RUNPOD_API_KEY.
const runpod = createRunpodClient();

const { data: pod } = await runpod.POST("/v2/pods", {
  body: {
    name: "comfyui-1",
    image: "ghcr.io/acme/comfyui:latest",
    gpu: { id: "NVIDIA A40", count: 1 },
    disk: 50,
    ports: ["8188/http", "22/tcp"],
  },
});
await runpod.POST("/v2/pods/{id}/action", { params: { path: { id: pod!.id } }, body: { action: "stop" } });
await runpod.DELETE("/v2/pods/{id}", { params: { path: { id: pod!.id } } });
```

```python Python (runpod ≥ 2.0.0rc1) theme={"dark"}
import os, runpod

# Nothing to change in code: 2.0 reads RUNPOD_API_KEY, RUNPOD_API_BASE_URL
# and RUNPOD_ENDPOINT_BASE_URL from the environment.
pods = runpod.get_pods()

endpoint = runpod.Endpoint(os.environ["ENDPOINT_ID"])          # Serverless jobs
print(endpoint.run_sync({"prompt": "Hello, world!"}, timeout=60))
```

```python Python (runpod 1.12.0) theme={"dark"}
import os, runpod

# 1.12 reads RUNPOD_API_BASE_URL and RUNPOD_ENDPOINT_BASE_URL, but NOT
# RUNPOD_API_KEY. Set the credential in code (or once with `runpod config`):
runpod.api_key = os.environ["RUNPOD_API_KEY"]

pods = runpod.get_pods()                                       # GraphQL query
pod = runpod.create_pod("comfyui-1", "ghcr.io/acme/comfyui:latest", "NVIDIA A40")  # read/write credential
runpod.stop_pod(pod["id"])

endpoint = runpod.Endpoint(os.environ["ENDPOINT_ID"])          # Serverless jobs
print(endpoint.run_sync({"prompt": "Hello, world!"}, timeout=60))
```

```bash runpodctl theme={"dark"}
export RUNPOD_GRAPHQL_URL=https://api.aireserve.com/graphql           # config: apiUrl
export RUNPOD_REST_V2_URL=https://api.aireserve.com/v2                 # config: restV2ApiUrl
export RUNPOD_INVOKE_URL=https://api.aireserve.com/serverless/v2       # config: invokeUrl
export RUNPOD_API_KEY=aireserve_api_…

runpodctl gpu list                                                     # GraphQL
runpodctl pod create --template-id runpod-torch-v21 --gpu-id "NVIDIA RTX 4090"   # GPU pods: GraphQL
runpodctl pod logs <pod-id>                                            # REST v2
runpodctl serverless run <endpoint-id> --input '{"prompt":"hi"}'       # Serverless invoke
# pod list/stop/start/delete, serverless create/list, template, network-volume,
# registry and billing use REST v1 and are NOT served — use the REST v2 SDK or curl.
```

```bash MCP server (Claude Code) theme={"dark"}
claude mcp add runpod --scope user \
  -e RUNPOD_API_BASE_URL=https://api.aireserve.com \
  -e RUNPOD_SERVERLESS_API_URL=https://api.aireserve.com/serverless/v2 \
  -e RUNPOD_PUBLIC_GRAPHQL_URL=https://api.aireserve.com/graphql \
  -e RUNPOD_AUTHED_GRAPHQL_URL=https://api.aireserve.com/graphql \
  -e RUNPOD_API_KEY=aireserve_api_… \
  -- npx -y @runpod/mcp-server@latest
```

```js JavaScript (runpod-sdk) theme={"dark"}
import runpodSdk from "runpod-sdk";

const runpod = runpodSdk(process.env.RUNPOD_API_KEY, {
  baseUrl: "https://api.aireserve.com/serverless/v2",   // default is https://api.runpod.ai/v2
});
const endpoint = runpod.endpoint(process.env.ENDPOINT_ID);
const result = await endpoint.runSync({ input: { prompt: "Hello, world!" } });
```

```go Go (SDK v2) theme={"dark"}
import runpod "github.com/runpod/go-sdk/v2"

// Key from RUNPOD_API_KEY (or runpod.WithAPIKey). New() does not read RUNPOD_API_BASE_URL,
// so the base URL is an option:
client, err := runpod.New(runpod.WithBaseURL("https://api.aireserve.com"))
```

```go Go (Serverless SDK) theme={"dark"}
import (
	"os"

	"github.com/runpod/go-sdk/pkg/sdk/config"
	rpEndpoint "github.com/runpod/go-sdk/pkg/sdk/endpoint"
)

apiKey := os.Getenv("RUNPOD_API_KEY")
endpointID := os.Getenv("ENDPOINT_ID")
endpointURL := "https://api.aireserve.com/serverless/v2"

endpoint, err := rpEndpoint.New(
	&config.Config{ApiKey: &apiKey},
	&rpEndpoint.Option{EndpointId: &endpointID, EndpointUrl: &endpointURL},
)
```

```bash curl theme={"dark"}
# REST v2
curl https://api.aireserve.com/v2/catalog/gpus -H "Authorization: Bearer $RUNPOD_API_KEY"
curl -X POST https://api.aireserve.com/v2/pods \
  -H "Authorization: Bearer $RUNPOD_API_KEY" -H "Content-Type: application/json" \
  -d '{"name":"comfyui-1","image":"ghcr.io/acme/comfyui:latest","gpu":{"id":"NVIDIA A40","count":1},"disk":50}'

# GraphQL (header, or RunPod's documented ?api_key= form — the key is lifted into the header, never forwarded)
curl -X POST https://api.aireserve.com/graphql -H "Authorization: Bearer $RUNPOD_API_KEY" \
  -H "Content-Type: application/json" -d '{"query":"query { myself { id } }"}'

# Serverless job
curl -X POST https://api.aireserve.com/serverless/v2/$ENDPOINT_ID/runsync \
  -H "Authorization: Bearer $RUNPOD_API_KEY" -H "Content-Type: application/json" \
  -d '{"input":{"prompt":"Hello, world!"}}'

# Pod logs (SSE)
curl -N "https://api.aireserve.com/v2/pods/$POD_ID/logs?tail=100" -H "Authorization: Bearer $RUNPOD_API_KEY"
```

## What AI Reserve enforces

Every refusal is RunPod-shaped `application/problem+json` — the
`{ title, status, detail }` envelope RunPod's own errors use — and names its
cause in `detail`, so the SDKs surface it unchanged:

```json theme={"dark"}
{ "title": "Forbidden", "status": 403, "detail": "This RunPod credential is read-only." }
```

* **Your organization's policies.** The credential is checked exactly as on
  every AI Reserve endpoint: paused keys (`401`,
  `This key is paused — an admin can resume it from the API Keys page.`),
  invalid keys (`401`, `Invalid API key.`), per-key IP allowlists and
  organization network policies (`403`), and rate limits (`429` with
  `Retry-After`). RunPod calls never touch the token wallet: a wallet outage or
  a zero token balance cannot turn a valid RunPod request into a `402` or
  `503`.
* **Tenancy.** The credential is resolved to your assignment on every request
  (memoised for 30 seconds). Refusals, all `403` and all before any upstream
  call:
  * `This API key is not a RunPod credential. Create one under Compute › RunPod in the AI Reserve portal.`
  * `No RunPod organization is assigned to this AI Reserve organization. Contact AI Reserve to assign your contracted RunPod organization.`
  * `The assigned RunPod organization has no upstream credential at this key's permission level yet. Contact AI Reserve.`
    — for example a read-only credential when AI Reserve holds only a
    read/write upstream key for your organization.
  * `503` `The RunPod credential for this organization could not be loaded. Retry; contact AI Reserve if it persists.`
    — a transient lookup failure, or a stored key the gateway cannot decrypt.
    Never a fallback to any other key.
* **Read-only credentials.** `GET`, `HEAD` and `OPTIONS` on REST v2 and
  Serverless, queries on GraphQL. Anything else is `403`
  `This RunPod credential is read-only.`
* **The account secrets store is denied for every credential.** Every method
  on `/v2/account/secrets` and `/v2/account/secrets/*` answers `403`
  `The RunPod account secrets store is not available through AI Reserve. Registries and pod secrets are.`
  RunPod tags both the secrets store and container registries with the same
  `secrets` scope (`x-runpod-scope` in
  [`openapi.json`](https://api.runpod.io/v2/openapi.json)), so a key that can
  reach your private registries can also read the organization's secret
  store; the gateway closes that path. Registry credentials
  (`/v2/registries*`) and secrets passed in a pod's environment are
  unaffected.
* **Account, organization and API-key management is denied on GraphQL for
  every credential.** A GraphQL document whose top-level mutation fields
  include any of `createApiKey`, `updateApiKey`, `deleteApiKey`,
  `createSharedApiKey`, `createFlashAuthRequest`,
  `organizationInviteCreate`, `organizationInviteAccept`,
  `organizationInviteDelete`, `organizationMembershipUpdate`,
  `organizationMembershipDelete`, `organizationUpdate`, `groupCreate`,
  `groupUpdate`, `groupDelete`, `teamCreate`, `teamUpdate`, `teamDelete`,
  `teamInviteCreate`, `teamInviteDelete`, `teamJoin`, `teamMembershipUpdate`,
  `teamMembershipDelete`, `updateUserSettings`, `updateUserInformation`,
  `deleteUser`, `setDefaultPaymentMethod` or `deletePaymentMethod` answers
  `403`
  `Account, organization and API-key management mutations are not available through AI Reserve.`
  Aliases and variables do not get around the check, and a mutation document
  the gateway cannot parse is refused the same way. The check is also
  deliberately conservative: a mutation whose top-level selection uses a
  fragment spread, an inline fragment, or a directive, or whose operation
  head carries anything other than variable definitions, is refused as well,
  because the gateway cannot vouch for where such a document executes (a
  denied field inside any fragment definition is refused by name). Write
  mutations the way RunPod's own clients do — named fields with arguments
  and nested selections — and they pass; fragments and directives below the
  top level are fine. Resource
  mutations — pods, endpoints, templates, volumes, registries, clusters — pass.
  The RunPod GraphQL API itself is deprecated and "will be retired in early
  2027" ([GraphQL API](https://docs.runpod.io/sdks/graphql/configurations)).
* **Headers.** Your `Authorization` and `x-api-key` are replaced by the
  upstream key; `X-Team-Id` is dropped (the upstream key is already bound to
  your organization); `Accept-Encoding` is pinned to `identity` so RunPod's
  bytes are the bytes relayed. `Idempotency-Key`, `Last-Event-ID`,
  `x-runpod-*` and SDK user agents go through.
* **A request log.** Each forwarded call is recorded with method, path (any
  credential-looking query value masked), RunPod's `x-request-id`, upstream
  status, `RateLimit`, byte counts, time-to-headers, duration, outcome, your
  key id, and the assignment, credential and organization ids it resolved to.
  Refusals are recorded with their outcome before any upstream request.
  Neither includes bodies or credentials.
* **Nothing else.** No request rewriting, no field validation, no response
  filtering. An error from RunPod is RunPod's error, relayed with RunPod's
  status. If RunPod answers `401` to a forwarded call, the upstream key was
  disabled or revoked in the RunPod console; the answer is relayed as-is and
  the credential is flagged for AI Reserve to rotate.
* **Transport.** RunPod unreachable → `503`; no response headers within the
  time-to-headers bound (sized for pod placement and `/runsync?wait=`) →
  `504`; a stream that has started is never cut by that bound.

## Limits

* **A fresh organization, driven through the API.** Pods, volumes, templates,
  registries, endpoints and SSH keys created through this endpoint belong to
  the RunPod organization contracted for you. You do not get RunPod console
  access to it through AI Reserve, and resources from a previous RunPod
  account are not migrated.
* **Usage is metered hourly into your AI Reserve ledger.** RunPod organizations
  "are billed on a post-paid invoice model"
  ([Billing](https://docs.runpod.io/organizations/orgs-billing)); the
  commitment and any overage sit on your AI Reserve order. Every hour, AI
  Reserve reads RunPod's own billing history for your organization and books
  each pod, network volume, cluster and serverless endpoint hour to your
  wallet at RunPod's metered amount. Each hour appears as its own line in
  **Observe › Event Log** and **Financials** (model `runpod:pod`,
  `runpod:network_volume`, `runpod:cluster` or `runpod:serverless`, with the
  RunPod resource id in its details). Hours settle about two hours behind
  real time. `GET /v2/billing/*` passes through and shows the same figures —
  RunPod's rule is that "Dev members see their own usage only"
  ([Billing](https://docs.runpod.io/organizations/orgs-billing)), and the
  member behind your credential is exactly what you created through AI Reserve.
* **Capacity is RunPod's decision.** The gateway does not reserve cards or
  rewrite GPU choices; RunPod places the request under the organization's
  contract. Requests outside the committed hardware or quantity still pass
  through and may be billed as overage by RunPod.
* **No account secrets store, no management mutations** (above). Manage SSH
  keys through `PUT /v2/account/ssh-keys` rather than the GraphQL
  `updateUserSettings` mutation.
* **RunPod's own sunsets apply.** REST v1 is not mounted and retires on
  November 15, 2026 ([REST API v1](https://docs.runpod.io/api-reference/overview));
  GraphQL retires in early 2027
  ([GraphQL API](https://docs.runpod.io/sdks/graphql/configurations)). Move
  GraphQL and v1 integrations to REST v2 — RunPod's
  [migration guide](https://docs.runpod.io/api-reference-v2/migrate-from-v1)
  and `/runpod:migrate` cover both.
* **Serverless and Instant Clusters** are RunPod products reached through this
  endpoint; they are not AI Reserve catalog products and carry no AI Reserve
  quote or price ceiling. For multi-node training with a quote and a price
  ceiling, use [AI Reserve clusters](/gpu-infrastructure/clusters).

Ready for more than a lift-and-shift? The
[standard GPU API](/gpu-infrastructure/quickstart) adds quotes with price
ceilings, provider-free capability launch, persistent storage in the same
request, and the `aireserve` CLI.


# Audio & voice models
Source: https://docs.aireserve.com/models/audio

8 audio & voice models on the AI Reserve gateway — ids, serving providers, pricing and links to a copy-paste request for each.

Text-to-speech, speech-to-text and realtime voice sessions.

Endpoints: `POST /v1/audio/speech` · `POST /v1/audio/transcriptions` · `POST /v1/realtime/sessions`. Prefer to search and filter? [Browse models](/models).

## ElevenLabs

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [Eleven Flash v2.5](/models/catalog/eleven-flash-v2-5) *Unverified-retention opt-in* | `eleven-flash-v2-5` | Text-to-speech | billed per input character — see guide |
| [Eleven Multilingual v2](/models/catalog/eleven-multilingual-v2) *Unverified-retention opt-in* | `eleven-multilingual-v2` | Text-to-speech | billed per input character — see guide |
| [Eleven v3](/models/catalog/eleven-v3) *Unverified-retention opt-in* | `eleven-v3` | Text-to-speech | billed per input character — see guide |
| [Eleven v4](/models/catalog/eleven-v4) *Unverified-retention opt-in* | `eleven-v4` | Text-to-speech | billed per input character — see guide |
| [ElevenLabs Scribe v2](/models/catalog/scribe-v2) *served by fal* | `scribe-v2` | Speech-to-text | \$0.008 / minute |

## OpenAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [GPT-4o mini Transcribe](/models/catalog/gpt-4o-mini-transcribe) | `gpt-4o-mini-transcribe` | Speech-to-text | — |

## xAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [Grok TTS](/models/catalog/grok-tts) | `grok-tts` | Text-to-speech | billed per input character — see guide |
| [Grok Voice (realtime)](/models/catalog/grok-voice) | `grok-voice` | Realtime voice | billed per session second — see guide |


# bria-background-remove
Source: https://docs.aireserve.com/models/catalog/bria-background-remove

Accepts up to 1 input image.

**Image editing** · Bria · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `bria-background-remove`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bria-background-remove",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "bria-background-remove",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `bria-background-remove` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | Bria |
| Served by | fal |
| Pricing | \$0.018 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5
Source: https://docs.aireserve.com/models/catalog/claude-fable-5

Anthropic's most capable model for demanding reasoning and long-horizon agentic work.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5` | Canonical gateway id |
| `claude-fable-5[1m]` | 1M-context form |
| `fable` | Claude Code tier alias |
| `fable-5` | Engine alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5:nitro` picks the fastest provider serving these weights and `claude-fable-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$10 in / \$50 out per 1M tokens |
| Cached input | \$1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-bedrock`](/models/catalog/claude-fable-5-bedrock) | Amazon Bedrock | \$10 in / \$50 out per 1M tokens |
| [`claude-fable-5-bedrock-us`](/models/catalog/claude-fable-5-bedrock-us) | Amazon Bedrock (US regions) | \$11 in / \$55 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5.1
Source: https://docs.aireserve.com/models/catalog/claude-fable-5-1

Anthropic's most capable model for demanding reasoning and long-horizon agentic work; 75% cheaper cache reads than Fable 5.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5-1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5-1",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5-1",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5-1` | Canonical gateway id |
| `claude-fable-5-1[1m]` | 1M-context form |
| `fable-5-1` | Engine alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5-1:nitro` picks the fastest provider serving these weights and `claude-fable-5-1:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$10 in / \$50 out per 1M tokens |
| Cached input | \$0.25 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-1-bedrock`](/models/catalog/claude-fable-5-1-bedrock) | Amazon Bedrock | \$10 in / \$50 out per 1M tokens |
| [`claude-fable-5-1-bedrock-us`](/models/catalog/claude-fable-5-1-bedrock-us) | Amazon Bedrock (US regions) | \$11 in / \$55 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5.1 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-fable-5-1-bedrock

Claude Fable 5.1 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5-1-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5-1-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5-1-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5-1-bedrock` | Canonical gateway id |
| `anthropic.claude-fable-5-1` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5-1-bedrock:nitro` picks the fastest provider serving these weights and `claude-fable-5-1-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$10 in / \$50 out per 1M tokens |
| Cached input | \$0.25 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Fable 5.1](/models/catalog/claude-fable-5-1) (`claude-fable-5-1`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-1-bedrock-us`](/models/catalog/claude-fable-5-1-bedrock-us) | Amazon Bedrock (US regions) | \$11 in / \$55 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5.1 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-fable-5-1-bedrock-us

Claude Fable 5.1 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5-1-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-1-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5-1-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5-1-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5-1-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5-1-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-fable-5-1-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$11 in / \$55 out per 1M tokens |
| Cached input | \$0.275 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Fable 5.1](/models/catalog/claude-fable-5-1) (`claude-fable-5-1`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-1-bedrock`](/models/catalog/claude-fable-5-1-bedrock) | Amazon Bedrock | \$10 in / \$50 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-fable-5-bedrock

Claude Fable 5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5-bedrock` | Canonical gateway id |
| `anthropic.claude-fable-5` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-fable-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$10 in / \$50 out per 1M tokens |
| Cached input | \$1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Fable 5](/models/catalog/claude-fable-5) (`claude-fable-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-bedrock-us`](/models/catalog/claude-fable-5-bedrock-us) | Amazon Bedrock (US regions) | \$11 in / \$55 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Fable 5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-fable-5-bedrock-us

Claude Fable 5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-fable-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-fable-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-fable-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-fable-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-fable-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-fable-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-fable-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$11 in / \$55 out per 1M tokens |
| Cached input | \$1.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Fable 5](/models/catalog/claude-fable-5) (`claude-fable-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-fable-5-bedrock`](/models/catalog/claude-fable-5-bedrock) | Amazon Bedrock | \$10 in / \$50 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Haiku 4.5
Source: https://docs.aireserve.com/models/catalog/claude-haiku-4-5-20251001

Fast Claude model with standard reasoning capability.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-haiku-4-5-20251001`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-20251001",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-20251001",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-haiku-4-5-20251001",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-haiku-4-5-20251001",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-haiku-4-5-20251001` | Canonical gateway id |
| `haiku` | Family default |
| `claude-haiku-4-5` | Undated id |
| `haiku-4-5` | Undated id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-haiku-4-5-20251001:nitro` picks the fastest provider serving these weights and `claude-haiku-4-5-20251001:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 200,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$1 in / \$5 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-haiku-4-5-bedrock`](/models/catalog/claude-haiku-4-5-bedrock) | Amazon Bedrock | \$1 in / \$5 out per 1M tokens |
| [`claude-haiku-4-5-bedrock-us`](/models/catalog/claude-haiku-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$1.1 in / \$5.5 out per 1M tokens |
| [`claude-haiku-4-5-vertex`](/models/catalog/claude-haiku-4-5-vertex) | Google Vertex AI | \$1 in / \$5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Haiku 4.5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-haiku-4-5-bedrock

Claude Haiku 4.5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-haiku-4-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-haiku-4-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-haiku-4-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-haiku-4-5-bedrock` | Canonical gateway id |
| `anthropic.claude-haiku-4-5-20251001-v1:0` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-haiku-4-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-haiku-4-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 200,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$1 in / \$5 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Haiku 4.5](/models/catalog/claude-haiku-4-5-20251001) (`claude-haiku-4-5-20251001`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-haiku-4-5-bedrock-us`](/models/catalog/claude-haiku-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$1.1 in / \$5.5 out per 1M tokens |
| [`claude-haiku-4-5-vertex`](/models/catalog/claude-haiku-4-5-vertex) | Google Vertex AI | \$1 in / \$5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Haiku 4.5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-haiku-4-5-bedrock-us

Claude Haiku 4.5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-haiku-4-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-haiku-4-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-haiku-4-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-haiku-4-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-haiku-4-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-haiku-4-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 200,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$1.1 in / \$5.5 out per 1M tokens |
| Cached input | \$0.11 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Haiku 4.5](/models/catalog/claude-haiku-4-5-20251001) (`claude-haiku-4-5-20251001`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-haiku-4-5-bedrock`](/models/catalog/claude-haiku-4-5-bedrock) | Amazon Bedrock | \$1 in / \$5 out per 1M tokens |
| [`claude-haiku-4-5-vertex`](/models/catalog/claude-haiku-4-5-vertex) | Google Vertex AI | \$1 in / \$5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Haiku 4.5 (Google Vertex AI)
Source: https://docs.aireserve.com/models/catalog/claude-haiku-4-5-vertex

Claude Haiku 4.5 (Google Vertex AI) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Google Vertex AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-haiku-4-5-vertex`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-vertex",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-haiku-4-5-vertex",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-haiku-4-5-vertex",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-haiku-4-5-vertex",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-haiku-4-5-vertex` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-haiku-4-5-vertex:nitro` picks the fastest provider serving these weights and `claude-haiku-4-5-vertex:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Google Vertex AI |
| Context window | 200,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$1 in / \$5 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Haiku 4.5](/models/catalog/claude-haiku-4-5-20251001) (`claude-haiku-4-5-20251001`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-haiku-4-5-bedrock`](/models/catalog/claude-haiku-4-5-bedrock) | Amazon Bedrock | \$1 in / \$5 out per 1M tokens |
| [`claude-haiku-4-5-bedrock-us`](/models/catalog/claude-haiku-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$1.1 in / \$5.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.5
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-5

Claude Opus reasoning model.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-5` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-5:nitro` picks the fastest provider serving these weights and `claude-opus-4-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 200,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.6
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-6

Claude Opus 4.6 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-6`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-6",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-6",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-6` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-6:nitro` picks the fastest provider serving these weights and `claude-opus-4-6:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-6-bedrock`](/models/catalog/claude-opus-4-6-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |
| [`claude-opus-4-6-bedrock-us`](/models/catalog/claude-opus-4-6-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.6 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-6-bedrock

Claude Opus 4.6 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-6-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-6-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-6-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-6-bedrock` | Canonical gateway id |
| `anthropic.claude-opus-4-6-v1` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-6-bedrock:nitro` picks the fastest provider serving these weights and `claude-opus-4-6-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.6](/models/catalog/claude-opus-4-6) (`claude-opus-4-6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-6-bedrock-us`](/models/catalog/claude-opus-4-6-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.6 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-6-bedrock-us

Claude Opus 4.6 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-6-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-6-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-6-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-6-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-6-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-opus-4-6-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5.5 in / \$27.5 out per 1M tokens |
| Cached input | \$0.55 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.6](/models/catalog/claude-opus-4-6) (`claude-opus-4-6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-6-bedrock`](/models/catalog/claude-opus-4-6-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.7
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-7

Flagship Claude reasoning model.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-7`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-7",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-7",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-7` | Canonical gateway id |
| `claude-opus` | Recommended-release alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-7:nitro` picks the fastest provider serving these weights and `claude-opus-4-7:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-7-bedrock`](/models/catalog/claude-opus-4-7-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |
| [`claude-opus-4-7-bedrock-us`](/models/catalog/claude-opus-4-7-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.7 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-7-bedrock

Claude Opus 4.7 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-7-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-7-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-7-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-7-bedrock` | Canonical gateway id |
| `anthropic.claude-opus-4-7` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-7-bedrock:nitro` picks the fastest provider serving these weights and `claude-opus-4-7-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.7](/models/catalog/claude-opus-4-7) (`claude-opus-4-7`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-7-bedrock-us`](/models/catalog/claude-opus-4-7-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.7 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-7-bedrock-us

Claude Opus 4.7 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-7-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-7-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-7-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-7-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-7-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-opus-4-7-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5.5 in / \$27.5 out per 1M tokens |
| Cached input | \$0.55 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.7](/models/catalog/claude-opus-4-7) (`claude-opus-4-7`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-7-bedrock`](/models/catalog/claude-opus-4-7-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.8
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-8

Flagship Claude reasoning model.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-8`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-8",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-8",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-8` | Canonical gateway id |
| `claude-opus-4-8[1m]` | 1M-context form |
| `opus-4-8` | Engine alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-8:nitro` picks the fastest provider serving these weights and `claude-opus-4-8:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-8-bedrock`](/models/catalog/claude-opus-4-8-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |
| [`claude-opus-4-8-bedrock-us`](/models/catalog/claude-opus-4-8-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.8 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-8-bedrock

Claude Opus 4.8 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-8-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-8-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-8-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-8-bedrock` | Canonical gateway id |
| `anthropic.claude-opus-4-8` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-8-bedrock:nitro` picks the fastest provider serving these weights and `claude-opus-4-8-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.8](/models/catalog/claude-opus-4-8) (`claude-opus-4-8`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-8-bedrock-us`](/models/catalog/claude-opus-4-8-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 4.8 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-opus-4-8-bedrock-us

Claude Opus 4.8 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-4-8-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-8-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-4-8-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-4-8-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-4-8-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-4-8-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-opus-4-8-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5.5 in / \$27.5 out per 1M tokens |
| Cached input | \$0.55 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 4.8](/models/catalog/claude-opus-4-8) (`claude-opus-4-8`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-4-8-bedrock`](/models/catalog/claude-opus-4-8-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5
Source: https://docs.aireserve.com/models/catalog/claude-opus-5

Flagship Claude reasoning model for complex agentic and enterprise work.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5` | Canonical gateway id |
| `claude-opus-5[1m]` | 1M-context form |
| `opus` | Claude Code tier alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5:nitro` picks the fastest provider serving these weights and `claude-opus-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-bedrock`](/models/catalog/claude-opus-5-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |
| [`claude-opus-5-bedrock-us`](/models/catalog/claude-opus-5-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5.5
Source: https://docs.aireserve.com/models/catalog/claude-opus-5-5

Anthropic's flagship Opus model for demanding reasoning, coding, and long-horizon agentic work (succeeds Opus 5).

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5-5` | Canonical gateway id |
| `claude-opus-5-5[1m]` | 1M-context form |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5-5:nitro` picks the fastest provider serving these weights and `claude-opus-5-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$4 in / \$20 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-5-bedrock`](/models/catalog/claude-opus-5-5-bedrock) | Amazon Bedrock | \$4 in / \$20 out per 1M tokens |
| [`claude-opus-5-5-bedrock-us`](/models/catalog/claude-opus-5-5-bedrock-us) | Amazon Bedrock (US regions) | \$4.4 in / \$22 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5.5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-opus-5-5-bedrock

Claude Opus 5.5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5-5-bedrock` | Canonical gateway id |
| `anthropic.claude-opus-5-5` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-opus-5-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$4 in / \$20 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 5.5](/models/catalog/claude-opus-5-5) (`claude-opus-5-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-5-bedrock-us`](/models/catalog/claude-opus-5-5-bedrock-us) | Amazon Bedrock (US regions) | \$4.4 in / \$22 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5.5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-opus-5-5-bedrock-us

Claude Opus 5.5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-opus-5-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$4.4 in / \$22 out per 1M tokens |
| Cached input | \$0.22 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 5.5](/models/catalog/claude-opus-5-5) (`claude-opus-5-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-5-bedrock`](/models/catalog/claude-opus-5-5-bedrock) | Amazon Bedrock | \$4 in / \$20 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-opus-5-bedrock

Claude Opus 5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5-bedrock` | Canonical gateway id |
| `anthropic.claude-opus-5` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-opus-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$25 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 5](/models/catalog/claude-opus-5) (`claude-opus-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-bedrock-us`](/models/catalog/claude-opus-5-bedrock-us) | Amazon Bedrock (US regions) | \$5.5 in / \$27.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Opus 5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-opus-5-bedrock-us

Claude Opus 5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-opus-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-opus-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-opus-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-opus-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-opus-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-opus-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5.5 in / \$27.5 out per 1M tokens |
| Cached input | \$0.55 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Opus 5](/models/catalog/claude-opus-5) (`claude-opus-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-opus-5-bedrock`](/models/catalog/claude-opus-5-bedrock) | Amazon Bedrock | \$5 in / \$25 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.5
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-5

Claude Sonnet model with strong reasoning capability.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-5` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-5:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-5-bedrock`](/models/catalog/claude-sonnet-4-5-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-5-bedrock-us`](/models/catalog/claude-sonnet-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |
| [`claude-sonnet-4-5-vertex`](/models/catalog/claude-sonnet-4-5-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-5-bedrock

Claude Sonnet 4.5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-5-bedrock` | Canonical gateway id |
| `anthropic.claude-sonnet-4-5-20250929-v1:0` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.5](/models/catalog/claude-sonnet-4-5) (`claude-sonnet-4-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-5-bedrock-us`](/models/catalog/claude-sonnet-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |
| [`claude-sonnet-4-5-vertex`](/models/catalog/claude-sonnet-4-5-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-5-bedrock-us

Claude Sonnet 4.5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$3.3 in / \$16.5 out per 1M tokens |
| Cached input | \$0.33 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.5](/models/catalog/claude-sonnet-4-5) (`claude-sonnet-4-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-5-bedrock`](/models/catalog/claude-sonnet-4-5-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-5-vertex`](/models/catalog/claude-sonnet-4-5-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.5 (Google Vertex AI)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-5-vertex

Claude Sonnet 4.5 (Google Vertex AI) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Google Vertex AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-5-vertex`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-vertex",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-vertex",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-5-vertex",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-5-vertex",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-5-vertex` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-5-vertex:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-5-vertex:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Google Vertex AI |
| Context window | 1,000,000 tokens |
| Max output | 64,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.5](/models/catalog/claude-sonnet-4-5) (`claude-sonnet-4-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-5-bedrock`](/models/catalog/claude-sonnet-4-5-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-5-bedrock-us`](/models/catalog/claude-sonnet-4-5-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.6
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-6

Claude Sonnet model with strong reasoning capability.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-6`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-6` | Canonical gateway id |
| `claude-sonnet-4-6[1m]` | 1M-context form |
| `sonnet-4-6` | Engine alias |
| `claude-sonnet` | Recommended-release alias |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-6:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-6:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-6-bedrock`](/models/catalog/claude-sonnet-4-6-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-6-bedrock-us`](/models/catalog/claude-sonnet-4-6-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |
| [`claude-sonnet-4-6-vertex`](/models/catalog/claude-sonnet-4-6-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.6 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-6-bedrock

Claude Sonnet 4.6 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-6-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-6-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-6-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-6-bedrock` | Canonical gateway id |
| `anthropic.claude-sonnet-4-6` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-6-bedrock:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-6-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.6](/models/catalog/claude-sonnet-4-6) (`claude-sonnet-4-6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-6-bedrock-us`](/models/catalog/claude-sonnet-4-6-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |
| [`claude-sonnet-4-6-vertex`](/models/catalog/claude-sonnet-4-6-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.6 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-6-bedrock-us

Claude Sonnet 4.6 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-6-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-6-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-6-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-6-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-6-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-6-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$3.3 in / \$16.5 out per 1M tokens |
| Cached input | \$0.33 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.6](/models/catalog/claude-sonnet-4-6) (`claude-sonnet-4-6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-6-bedrock`](/models/catalog/claude-sonnet-4-6-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-6-vertex`](/models/catalog/claude-sonnet-4-6-vertex) | Google Vertex AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 4.6 (Google Vertex AI)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-4-6-vertex

Claude Sonnet 4.6 (Google Vertex AI) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Google Vertex AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-4-6-vertex`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-vertex",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6-vertex",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-4-6-vertex",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-4-6-vertex",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-4-6-vertex` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-4-6-vertex:nitro` picks the fastest provider serving these weights and `claude-sonnet-4-6-vertex:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Google Vertex AI |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 4.6](/models/catalog/claude-sonnet-4-6) (`claude-sonnet-4-6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-4-6-bedrock`](/models/catalog/claude-sonnet-4-6-bedrock) | Amazon Bedrock | \$3 in / \$15 out per 1M tokens |
| [`claude-sonnet-4-6-bedrock-us`](/models/catalog/claude-sonnet-4-6-bedrock-us) | Amazon Bedrock (US regions) | \$3.3 in / \$16.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5

Claude Sonnet model with near-Opus coding and agentic capability.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5` | Canonical gateway id |
| `claude-sonnet-5[1m]` | 1M-context form |
| `sonnet` | Claude Code tier alias |
| `anthropic` | Family default |
| `claude` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5:nitro` picks the fastest provider serving these weights and `claude-sonnet-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-bedrock`](/models/catalog/claude-sonnet-5-bedrock) | Amazon Bedrock | \$2 in / \$10 out per 1M tokens |
| [`claude-sonnet-5-bedrock-us`](/models/catalog/claude-sonnet-5-bedrock-us) | Amazon Bedrock (US regions) | \$2.2 in / \$11 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5.5
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5-5

Claude Sonnet model with adaptive thinking and near-Opus coding and agentic capability.

**Chat** · Anthropic

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5-5` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5-5:nitro` picks the fastest provider serving these weights and `claude-sonnet-5-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Anthropic |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-5-bedrock`](/models/catalog/claude-sonnet-5-5-bedrock) | Amazon Bedrock | \$2 in / \$10 out per 1M tokens |
| [`claude-sonnet-5-5-bedrock-us`](/models/catalog/claude-sonnet-5-5-bedrock-us) | Amazon Bedrock (US regions) | \$2.2 in / \$11 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5.5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5-5-bedrock

Claude Sonnet 5.5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5-5-bedrock` | Canonical gateway id |
| `anthropic.claude-sonnet-5-5` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-sonnet-5-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 5.5](/models/catalog/claude-sonnet-5-5) (`claude-sonnet-5-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-5-bedrock-us`](/models/catalog/claude-sonnet-5-5-bedrock-us) | Amazon Bedrock (US regions) | \$2.2 in / \$11 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5.5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5-5-bedrock-us

Claude Sonnet 5.5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-sonnet-5-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2.2 in / \$11 out per 1M tokens |
| Cached input | \$0.11 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 5.5](/models/catalog/claude-sonnet-5-5) (`claude-sonnet-5-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-5-bedrock`](/models/catalog/claude-sonnet-5-5-bedrock) | Amazon Bedrock | \$2 in / \$10 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5-bedrock

Claude Sonnet 5 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-bedrock",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5-bedrock` | Canonical gateway id |
| `anthropic.claude-sonnet-5` | AWS Bedrock id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5-bedrock:nitro` picks the fastest provider serving these weights and `claude-sonnet-5-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 5](/models/catalog/claude-sonnet-5) (`claude-sonnet-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-bedrock-us`](/models/catalog/claude-sonnet-5-bedrock-us) | Amazon Bedrock (US regions) | \$2.2 in / \$11 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Claude Sonnet 5 (Amazon Bedrock (US regions))
Source: https://docs.aireserve.com/models/catalog/claude-sonnet-5-bedrock-us

Claude Sonnet 5 (Amazon Bedrock (US regions)) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Anthropic · served by Amazon Bedrock (US regions)

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `claude-sonnet-5-bedrock-us`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-bedrock-us",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```bash cURL (Anthropic Messages shape) theme={"dark"}
curl https://api.aireserve.com/v1/messages \
  -H "x-api-key: $AIRESERVE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-bedrock-us",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="claude-sonnet-5-bedrock-us",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "claude-sonnet-5-bedrock-us",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `claude-sonnet-5-bedrock-us` | Canonical gateway id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `claude-sonnet-5-bedrock-us:nitro` picks the fastest provider serving these weights and `claude-sonnet-5-bedrock-us:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Anthropic |
| Served by | Amazon Bedrock (US regions) |
| Context window | 1,000,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2.2 in / \$11 out per 1M tokens |
| Cached input | \$0.22 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Claude Sonnet 5](/models/catalog/claude-sonnet-5) (`claude-sonnet-5`).

| Model id | Served by | Pricing |
| - | - | - |
| [`claude-sonnet-5-bedrock`](/models/catalog/claude-sonnet-5-bedrock) | Amazon Bedrock | \$2 in / \$10 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Codestral
Source: https://docs.aireserve.com/models/catalog/codestral-2508

Mistral coding-specialized model on La Plateforme.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `codestral-2508`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "codestral-2508",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="codestral-2508",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "codestral-2508",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `codestral-2508` | Canonical gateway id |
| `claude-air-codestral-2508` | Claude Code picker id |
| `codestral` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `codestral-2508:nitro` picks the fastest provider serving these weights and `codestral-2508:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 256,000 tokens |
| Max output | 204,800 tokens |
| Pricing | \$0.3 in / \$0.9 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek Chat
Source: https://docs.aireserve.com/models/catalog/deepseek-chat

DeepSeek V4 Flash non-thinking mode.

**Chat** · DeepSeek · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-chat`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-chat",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-chat` | Canonical gateway id |
| `claude-air-deepseek-chat` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-chat:nitro` picks the fastest provider serving these weights and `deepseek-chat:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepSeek |
| Context window | 163,840 tokens |
| Max output | 16,000 tokens |
| Pricing | \$0.181 in / \$0.725 out per 1M tokens |
| Cached input | \$0.0036 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4.1 Flash (Official)
Source: https://docs.aireserve.com/models/catalog/deepseek-flash

DeepSeek V4.1 Flash on DeepSeek's official API — multimodal, 1M context, adjustable reasoning.

**Chat** · DeepSeek · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-flash` | Canonical gateway id |
| `claude-air-deepseek-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-flash:nitro` picks the fastest provider serving these weights and `deepseek-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepSeek |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$0.181 in / \$0.725 out per 1M tokens |
| Cached input | \$0.0036 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek Reasoner
Source: https://docs.aireserve.com/models/catalog/deepseek-reasoner

DeepSeek V4 Flash thinking mode.

**Chat** · DeepSeek · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-reasoner`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-reasoner",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-reasoner",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-reasoner` | Canonical gateway id |
| `claude-air-deepseek-reasoner` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-reasoner:nitro` picks the fastest provider serving these weights and `deepseek-reasoner:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepSeek |
| Context window | 64,000 tokens |
| Max output | 16,000 tokens |
| Pricing | \$0.181 in / \$0.725 out per 1M tokens |
| Cached input | \$0.0036 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-reasoner-bedrock`](/models/catalog/deepseek-reasoner-bedrock) | Amazon Bedrock | \$0.55 in / \$2.19 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek Reasoner (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/deepseek-reasoner-bedrock

DeepSeek Reasoner (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-reasoner-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-reasoner-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-reasoner-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-reasoner-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-reasoner-bedrock` | Canonical gateway id |
| `deepseek.r1-v1:0` | AWS Bedrock id |
| `claude-air-deepseek-reasoner-bedrock` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-reasoner-bedrock:nitro` picks the fastest provider serving these weights and `deepseek-reasoner-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Amazon Bedrock |
| Context window | 64,000 tokens |
| Max output | 16,000 tokens |
| Pricing | \$0.55 in / \$2.19 out per 1M tokens |
| Cached input | \$0.055 per 1M tokens |
| Capabilities | Streaming, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek Reasoner](/models/catalog/deepseek-reasoner) (`deepseek-reasoner`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V3.2
Source: https://docs.aireserve.com/models/catalog/deepseek-v3.2

DeepSeek V3.2 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v3.2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v3.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v3.2",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v3.2",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v3.2` | Canonical gateway id |
| `claude-air-deepseek-v3.2` | Claude Code picker id |
| `deepseek-v3.2-gmicloud` | Retired id (resolves here) |
| `deepseek-v3.2-novita` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v3.2:nitro` picks the fastest provider serving these weights and `deepseek-v3.2:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 163,840 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.26 in / \$0.38 out per 1M tokens |
| Cached input | \$0.13 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v3.2-bedrock`](/models/catalog/deepseek-v3.2-bedrock) | Amazon Bedrock | \$0.62 in / \$1.85 out per 1M tokens |
| [`deepseek-v3.2-streamlake`](/models/catalog/deepseek-v3.2-streamlake) | StreamLake | \$0.286 in / \$0.429 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V3.2 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/deepseek-v3.2-bedrock

DeepSeek V3.2 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v3.2-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v3.2-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v3.2-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v3.2-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v3.2-bedrock` | Canonical gateway id |
| `deepseek.v3.2` | AWS Bedrock id |
| `claude-air-deepseek-v3.2-bedrock` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v3.2-bedrock:nitro` picks the fastest provider serving these weights and `deepseek-v3.2-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Amazon Bedrock |
| Context window | 163,840 tokens |
| Max output | 8,192 tokens |
| Pricing | \$0.62 in / \$1.85 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V3.2](/models/catalog/deepseek-v3.2) (`deepseek-v3.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v3.2-streamlake`](/models/catalog/deepseek-v3.2-streamlake) | StreamLake | \$0.286 in / \$0.429 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V3.2 (StreamLake)
Source: https://docs.aireserve.com/models/catalog/deepseek-v3.2-streamlake

DeepSeek V3.2 (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v3.2-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v3.2-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v3.2-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v3.2-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v3.2-streamlake` | Canonical gateway id |
| `claude-air-deepseek-v3.2-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v3.2-streamlake:nitro` picks the fastest provider serving these weights and `deepseek-v3.2-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | StreamLake |
| Context window | 131,072 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.286 in / \$0.429 out per 1M tokens |
| Cached input | \$0.029 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V3.2](/models/catalog/deepseek-v3.2) (`deepseek-v3.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v3.2-bedrock`](/models/catalog/deepseek-v3.2-bedrock) | Amazon Bedrock | \$0.62 in / \$1.85 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash

DeepSeek V4 Flash served by DeepInfra — cheap open-weight workhorse.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash` | Canonical gateway id |
| `claude-air-deepseek-v4-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.09 in / \$0.18 out per 1M tokens |
| Cached input | \$0.018 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (Baseten)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-baseten

DeepSeek V4 Flash served by Baseten Model APIs.

**Chat** · DeepSeek · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-baseten` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-baseten:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.13 in / \$0.26 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-deepinfra

DeepSeek V4 Flash served by DeepInfra — cheapest US-hosted route at listing time.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-deepinfra` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-deepinfra:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.09 in / \$0.18 out per 1M tokens |
| Cached input | \$0.018 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-gmicloud

DeepSeek V4 Flash (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-gmicloud` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-gmicloud:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | GMI Cloud |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$0.091 in / \$0.182 out per 1M tokens |
| Cached input | \$0.018 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (Novita)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-novita

DeepSeek V4 Flash served by Novita AI.

**Chat** · DeepSeek · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-novita` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-novita:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Reasoner
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-reasoner

DeepSeek V4 Flash thinking mode served by DeepInfra — US-hosted deepseek-reasoner mirror.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-reasoner`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-reasoner",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-reasoner",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-reasoner",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-reasoner` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-reasoner` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-reasoner:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-reasoner:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.09 in / \$0.18 out per 1M tokens |
| Cached input | \$0.018 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-reasoner-baseten`](/models/catalog/deepseek-v4-flash-reasoner-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-deepinfra`](/models/catalog/deepseek-v4-flash-reasoner-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-novita`](/models/catalog/deepseek-v4-flash-reasoner-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-together`](/models/catalog/deepseek-v4-flash-reasoner-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Reasoner (Baseten)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-reasoner-baseten

DeepSeek V4 Flash thinking mode served by Baseten Model APIs.

**Chat** · DeepSeek · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-reasoner-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-reasoner-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-reasoner-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-reasoner-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-reasoner-baseten` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-reasoner-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-reasoner-baseten:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-reasoner-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.13 in / \$0.26 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash Reasoner](/models/catalog/deepseek-v4-flash-reasoner) (`deepseek-v4-flash-reasoner`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-reasoner-deepinfra`](/models/catalog/deepseek-v4-flash-reasoner-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-novita`](/models/catalog/deepseek-v4-flash-reasoner-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-together`](/models/catalog/deepseek-v4-flash-reasoner-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Reasoner (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-reasoner-deepinfra

DeepSeek V4 Flash thinking mode served by DeepInfra — cheapest US-hosted reasoner route.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-reasoner-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-reasoner-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-reasoner-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-reasoner-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-reasoner-deepinfra` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-reasoner-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-reasoner-deepinfra:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-reasoner-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.09 in / \$0.18 out per 1M tokens |
| Cached input | \$0.018 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash Reasoner](/models/catalog/deepseek-v4-flash-reasoner) (`deepseek-v4-flash-reasoner`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-reasoner-baseten`](/models/catalog/deepseek-v4-flash-reasoner-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-novita`](/models/catalog/deepseek-v4-flash-reasoner-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-together`](/models/catalog/deepseek-v4-flash-reasoner-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Reasoner (Novita)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-reasoner-novita

DeepSeek V4 Flash thinking mode served by Novita AI.

**Chat** · DeepSeek · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-reasoner-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-reasoner-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-reasoner-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-reasoner-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-reasoner-novita` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-reasoner-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-reasoner-novita:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-reasoner-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash Reasoner](/models/catalog/deepseek-v4-flash-reasoner) (`deepseek-v4-flash-reasoner`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-reasoner-baseten`](/models/catalog/deepseek-v4-flash-reasoner-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-deepinfra`](/models/catalog/deepseek-v4-flash-reasoner-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-together`](/models/catalog/deepseek-v4-flash-reasoner-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Reasoner (Together)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-reasoner-together

DeepSeek V4 Flash thinking mode served by Together AI.

**Chat** · DeepSeek · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-reasoner-together`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-reasoner-together",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-reasoner-together",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-reasoner-together",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-reasoner-together` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-reasoner-together` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-reasoner-together:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-reasoner-together:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Together AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash Reasoner](/models/catalog/deepseek-v4-flash-reasoner) (`deepseek-v4-flash-reasoner`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-reasoner-baseten`](/models/catalog/deepseek-v4-flash-reasoner-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-deepinfra`](/models/catalog/deepseek-v4-flash-reasoner-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-reasoner-novita`](/models/catalog/deepseek-v4-flash-reasoner-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (StreamLake)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-streamlake

DeepSeek V4 Flash (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-streamlake` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-streamlake:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | StreamLake |
| Context window | 1,048,576 tokens |
| Max output | 393,216 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-tensormesh

DeepSeek V4 Flash (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-tensormesh` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-tensormesh` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-tensormesh:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Tensormesh |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-together`](/models/catalog/deepseek-v4-flash-together) | Together AI | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash (Together)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-together

DeepSeek V4 Flash served by Together AI.

**Chat** · DeepSeek · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-together`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-together",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-together",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-together",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-together` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-together` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-together:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-together:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Together AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.28 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) (`deepseek-v4-flash`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-baseten`](/models/catalog/deepseek-v4-flash-baseten) | Baseten | \$0.13 in / \$0.26 out per 1M tokens |
| [`deepseek-v4-flash-deepinfra`](/models/catalog/deepseek-v4-flash-deepinfra) | DeepInfra | \$0.09 in / \$0.18 out per 1M tokens |
| [`deepseek-v4-flash-gmicloud`](/models/catalog/deepseek-v4-flash-gmicloud) | GMI Cloud | \$0.091 in / \$0.182 out per 1M tokens |
| [`deepseek-v4-flash-novita`](/models/catalog/deepseek-v4-flash-novita) | Novita AI | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-streamlake`](/models/catalog/deepseek-v4-flash-streamlake) | StreamLake | \$0.14 in / \$0.28 out per 1M tokens |
| [`deepseek-v4-flash-tensormesh`](/models/catalog/deepseek-v4-flash-tensormesh) | Tensormesh | \$0.14 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Vision Exp (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-vision-exp-deepinfra

DeepSeek V4 Flash Vision Exp (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-vision-exp-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-vision-exp-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-vision-exp-deepinfra` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-vision-exp-deepinfra` | Claude Code picker id |
| `deepseek-v4-flash-vision-exp-fireworks` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-vision-exp-deepinfra:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-vision-exp-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 262,144 tokens |
| Pricing | \$0.216 in / \$0.647 out per 1M tokens |
| Cached input | \$0.007 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-vision-exp-novita`](/models/catalog/deepseek-v4-flash-vision-exp-novita) | Novita AI | \$0.44 in / \$1.32 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Flash Vision Exp (Novita)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-flash-vision-exp-novita

DeepSeek V4 Flash Vision Exp (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-flash-vision-exp-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-flash-vision-exp-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-flash-vision-exp-novita` | Canonical gateway id |
| `claude-air-deepseek-v4-flash-vision-exp-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-flash-vision-exp-novita:nitro` picks the fastest provider serving these weights and `deepseek-v4-flash-vision-exp-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 393,216 tokens |
| Pricing | \$0.44 in / \$1.32 out per 1M tokens |
| Cached input | \$0.028 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-flash-vision-exp-deepinfra`](/models/catalog/deepseek-v4-flash-vision-exp-deepinfra) | DeepInfra | \$0.216 in / \$0.647 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro

DeepSeek V4 Pro (official -0813 release, 1M context) served by Together AI.

**Chat** · DeepSeek · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro` | Canonical gateway id |
| `claude-air-deepseek-v4-pro` | Claude Code picker id |
| `deepseek` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Together AI |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$1.32 in / \$3.96 out per 1M tokens |
| Cached input | \$0.13 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (Alibaba)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-alibaba

DeepSeek V4 Pro (Alibaba) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-alibaba`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-alibaba",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-alibaba",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-alibaba",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-alibaba` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-alibaba` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-alibaba:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-alibaba:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 384,000 tokens |
| Pricing | \$1.42 in / \$2.83 out per 1M tokens |
| Cached input | \$0.118 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (Baseten)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-baseten

DeepSeek V4 Pro (1M context) served by Baseten Model APIs.

**Chat** · DeepSeek · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-baseten` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-baseten:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$1.32 in / \$3.96 out per 1M tokens |
| Cached input | \$0.132 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-deepinfra

DeepSeek V4 Pro (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-deepinfra` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-deepinfra` | Claude Code picker id |
| `deepseek-v4-pro-fireworks` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-deepinfra:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$1.3 in / \$2.6 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (DeepSeek)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-deepseek

DeepSeek V4 Pro (DeepSeek) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-deepseek`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-deepseek",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-deepseek",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-deepseek",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-deepseek` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-deepseek` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-deepseek:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-deepseek:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepSeek |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$0.797 in / \$2.39 out per 1M tokens |
| Cached input | \$0.027 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-gmicloud

DeepSeek V4 Pro (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-gmicloud` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-gmicloud:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | GMI Cloud |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$0.957 in / \$1.91 out per 1M tokens |
| Cached input | \$0.08 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (Novita)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-novita

DeepSeek V4 Pro (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-novita` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-novita:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 384,000 tokens |
| Pricing | \$1.32 in / \$3.96 out per 1M tokens |
| Cached input | \$0.044 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-streamlake`](/models/catalog/deepseek-v4-pro-streamlake) | StreamLake | \$1.74 in / \$3.48 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4 Pro (StreamLake)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4-pro-streamlake

DeepSeek V4 Pro (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4-pro-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4-pro-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4-pro-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4-pro-streamlake` | Canonical gateway id |
| `claude-air-deepseek-v4-pro-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4-pro-streamlake:nitro` picks the fastest provider serving these weights and `deepseek-v4-pro-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | StreamLake |
| Context window | 1,048,576 tokens |
| Max output | 393,216 tokens |
| Pricing | \$1.74 in / \$3.48 out per 1M tokens |
| Cached input | \$0.145 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) (`deepseek-v4-pro`).

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4-pro-alibaba`](/models/catalog/deepseek-v4-pro-alibaba) | Alibaba Cloud | \$1.42 in / \$2.83 out per 1M tokens |
| [`deepseek-v4-pro-baseten`](/models/catalog/deepseek-v4-pro-baseten) | Baseten | \$1.32 in / \$3.96 out per 1M tokens |
| [`deepseek-v4-pro-deepinfra`](/models/catalog/deepseek-v4-pro-deepinfra) | DeepInfra | \$1.3 in / \$2.6 out per 1M tokens |
| [`deepseek-v4-pro-deepseek`](/models/catalog/deepseek-v4-pro-deepseek) | DeepSeek | \$0.797 in / \$2.39 out per 1M tokens |
| [`deepseek-v4-pro-gmicloud`](/models/catalog/deepseek-v4-pro-gmicloud) | GMI Cloud | \$0.957 in / \$1.91 out per 1M tokens |
| [`deepseek-v4-pro-novita`](/models/catalog/deepseek-v4-pro-novita) | Novita AI | \$1.32 in / \$3.96 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4.1 Flash
Source: https://docs.aireserve.com/models/catalog/deepseek-v4.1-flash

DeepSeek V4.1 Flash served by DeepInfra — multimodal, 1M context, adjustable reasoning.

**Chat** · DeepSeek · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4.1-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4.1-flash` | Canonical gateway id |
| `claude-air-deepseek-v4.1-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4.1-flash:nitro` picks the fastest provider serving these weights and `deepseek-v4.1-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.14 in / \$0.42 out per 1M tokens |
| Cached input | \$0.0042 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`deepseek-v4.1-flash-novita`](/models/catalog/deepseek-v4.1-flash-novita) | Novita AI | \$0.3 in / \$1.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4.1 Flash 1017
Source: https://docs.aireserve.com/models/catalog/deepseek-v4.1-flash-1017

DeepSeek V4.1 Flash 1017 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · DeepSeek · served by Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4.1-flash-1017`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash-1017",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4.1-flash-1017",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4.1-flash-1017",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4.1-flash-1017` | Canonical gateway id |
| `claude-air-deepseek-v4.1-flash-1017` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4.1-flash-1017:nitro` picks the fastest provider serving these weights and `deepseek-v4.1-flash-1017:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Fireworks AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0.006 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4.1 Flash 1017 Fast
Source: https://docs.aireserve.com/models/catalog/deepseek-v4.1-flash-1017-fast

DeepSeek V4.1 Flash 1017 on Baseten's Fast serving tier — premium low-latency twin of the Fireworks primary.

**Chat** · DeepSeek · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4.1-flash-1017-fast`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash-1017-fast",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4.1-flash-1017-fast",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4.1-flash-1017-fast",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4.1-flash-1017-fast` | Canonical gateway id |
| `claude-air-deepseek-v4.1-flash-1017-fast` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4.1-flash-1017-fast:nitro` picks the fastest provider serving these weights and `deepseek-v4.1-flash-1017-fast:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 262,144 tokens |
| Pricing | \$0.6 in / \$2.4 out per 1M tokens |
| Cached input | \$0.014 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# DeepSeek V4.1 Flash (Novita)
Source: https://docs.aireserve.com/models/catalog/deepseek-v4.1-flash-novita

DeepSeek V4.1 Flash served by Novita AI — multimodal, 1M context, adjustable reasoning.

**Chat** · DeepSeek · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `deepseek-v4.1-flash-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="deepseek-v4.1-flash-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "deepseek-v4.1-flash-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `deepseek-v4.1-flash-novita` | Canonical gateway id |
| `claude-air-deepseek-v4.1-flash-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `deepseek-v4.1-flash-novita:nitro` picks the fastest provider serving these weights and `deepseek-v4.1-flash-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | DeepSeek |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 393,216 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0.006 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [DeepSeek V4.1 Flash](/models/catalog/deepseek-v4.1-flash) (`deepseek-v4.1-flash`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Eleven Flash v2.5
Source: https://docs.aireserve.com/models/catalog/eleven-flash-v2-5

Up to 40,000 characters per request · mp3, opus, pcm, wav output.

**Text-to-speech** · ElevenLabs

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/audio/speech` — set `model` to `eleven-flash-v2-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "eleven-flash-v2-5", "input": "Welcome to AI Reserve.", "voice": "George"}' \
  --output speech.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="eleven-flash-v2-5",
    voice="George",
    input="Welcome to AI Reserve.",
) as response:
    response.stream_to_file("speech.mp3")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.audio.speech.create({
  model: "eleven-flash-v2-5",
  voice: "George",
  input: "Welcome to AI Reserve.",
});
await Bun.write("speech.mp3", await res.arrayBuffer());
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `eleven-flash-v2-5` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Text-to-speech |
| Model maker | ElevenLabs |
| Served by | ElevenLabs |
| Pricing | billed per input character — see guide |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Eleven Multilingual v2
Source: https://docs.aireserve.com/models/catalog/eleven-multilingual-v2

Up to 10,000 characters per request · mp3, opus, pcm, wav output.

**Text-to-speech** · ElevenLabs

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/audio/speech` — set `model` to `eleven-multilingual-v2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "eleven-multilingual-v2", "input": "Welcome to AI Reserve.", "voice": "George"}' \
  --output speech.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="eleven-multilingual-v2",
    voice="George",
    input="Welcome to AI Reserve.",
) as response:
    response.stream_to_file("speech.mp3")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.audio.speech.create({
  model: "eleven-multilingual-v2",
  voice: "George",
  input: "Welcome to AI Reserve.",
});
await Bun.write("speech.mp3", await res.arrayBuffer());
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `eleven-multilingual-v2` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Text-to-speech |
| Model maker | ElevenLabs |
| Served by | ElevenLabs |
| Pricing | billed per input character — see guide |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Eleven v3
Source: https://docs.aireserve.com/models/catalog/eleven-v3

Up to 5,000 characters per request · mp3, opus, pcm, wav output.

**Text-to-speech** · ElevenLabs

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/audio/speech` — set `model` to `eleven-v3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "eleven-v3", "input": "Welcome to AI Reserve.", "voice": "George"}' \
  --output speech.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="eleven-v3",
    voice="George",
    input="Welcome to AI Reserve.",
) as response:
    response.stream_to_file("speech.mp3")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.audio.speech.create({
  model: "eleven-v3",
  voice: "George",
  input: "Welcome to AI Reserve.",
});
await Bun.write("speech.mp3", await res.arrayBuffer());
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `eleven-v3` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Text-to-speech |
| Model maker | ElevenLabs |
| Served by | ElevenLabs |
| Pricing | billed per input character — see guide |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Eleven v4
Source: https://docs.aireserve.com/models/catalog/eleven-v4

Up to 10,000 characters per request · mp3, opus, pcm, wav output.

**Text-to-speech** · ElevenLabs

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/audio/speech` — set `model` to `eleven-v4`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "eleven-v4", "input": "Welcome to AI Reserve.", "voice": "George"}' \
  --output speech.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="eleven-v4",
    voice="George",
    input="Welcome to AI Reserve.",
) as response:
    response.stream_to_file("speech.mp3")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.audio.speech.create({
  model: "eleven-v4",
  voice: "George",
  input: "Welcome to AI Reserve.",
});
await Bun.write("speech.mp3", await res.arrayBuffer());
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `eleven-v4` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Text-to-speech |
| Model maker | ElevenLabs |
| Served by | ElevenLabs |
| Pricing | billed per input character — see guide |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Ember-1
Source: https://docs.aireserve.com/models/catalog/ember-1

Ember-1 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `ember-1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ember-1",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="ember-1",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "ember-1",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `ember-1` | Canonical gateway id |
| `claude-air-ember-1` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `ember-1:nitro` picks the fastest provider serving these weights and `ember-1:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Fireworks AI |
| Served by | Fireworks AI |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# flux-2-flex
Source: https://docs.aireserve.com/models/catalog/flux-2-flex

flux-2-flex on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Black Forest Labs · served by fal

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `flux-2-flex`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-2-flex",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="flux-2-flex",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "flux-2-flex",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `flux-2-flex` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Black Forest Labs |
| Served by | fal |
| Pricing | \$0.05 / megapixel |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# flux-2-flex-edit
Source: https://docs.aireserve.com/models/catalog/flux-2-flex-edit

Accepts up to 4 input images.

**Image editing** · Black Forest Labs · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `flux-2-flex-edit`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-2-flex-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-2-flex-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `flux-2-flex-edit` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | Black Forest Labs |
| Served by | fal |
| Pricing | \$0.2 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# flux-3-i2v
Source: https://docs.aireserve.com/models/catalog/flux-3-i2v

flux-3-i2v on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image-to-video** · Black Forest Labs · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `flux-3-i2v`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-3-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "flux-3-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `flux-3-i2v` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Image-to-video |
| Model maker | Black Forest Labs |
| Served by | fal |
| Pricing | 720p \$0.17/s, 1080p \$0.29/s |
| Capabilities | Image input |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 2.5 Flash
Source: https://docs.aireserve.com/models/catalog/gemini-2.5-flash

Fast Gemini model with standard reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-2.5-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-2.5-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-2.5-flash` | Canonical gateway id |
| `claude-air-gemini-2.5-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-2.5-flash:nitro` picks the fastest provider serving these weights and `gemini-2.5-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,535 tokens |
| Pricing | \$0.3 in / \$2.5 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 2.5 Flash Image
Source: https://docs.aireserve.com/models/catalog/gemini-2.5-flash-image

Gemini 2.5 Flash Image on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Google

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `gemini-2.5-flash-image`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-flash-image",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="gemini-2.5-flash-image",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "gemini-2.5-flash-image",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-2.5-flash-image` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Google |
| Served by | Google |
| Pricing | \$0.039 / image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 2.5 Pro
Source: https://docs.aireserve.com/models/catalog/gemini-2.5-pro

Gemini Pro model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-2.5-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-2.5-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-2.5-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-2.5-pro` | Canonical gateway id |
| `claude-air-gemini-2.5-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-2.5-pro:nitro` picks the fastest provider serving these weights and `gemini-2.5-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$1.25 in / \$10 out per 1M tokens |
| Cached input | \$0.125 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3 Flash (Preview)
Source: https://docs.aireserve.com/models/catalog/gemini-3-flash-preview

Preview Gemini Flash model with standard reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3-flash-preview`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3-flash-preview",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3-flash-preview",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3-flash-preview",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3-flash-preview` | Canonical gateway id |
| `claude-air-gemini-3-flash-preview` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3-flash-preview:nitro` picks the fastest provider serving these weights and `gemini-3-flash-preview:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.5 in / \$3 out per 1M tokens |
| Cached input | \$0.05 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.1 Flash Image
Source: https://docs.aireserve.com/models/catalog/gemini-3.1-flash-image

Gemini 3.1 Flash Image on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Google

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `gemini-3.1-flash-image`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.1-flash-image",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="gemini-3.1-flash-image",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "gemini-3.1-flash-image",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.1-flash-image` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Google |
| Served by | Google |
| Pricing | \$0.151 / image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.1 Flash Lite
Source: https://docs.aireserve.com/models/catalog/gemini-3.1-flash-lite

Cost-efficient Gemini 3.1 Flash Lite model with standard reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.1-flash-lite`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.1-flash-lite",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.1-flash-lite",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.1-flash-lite",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.1-flash-lite` | Canonical gateway id |
| `claude-air-gemini-3.1-flash-lite` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.1-flash-lite:nitro` picks the fastest provider serving these weights and `gemini-3.1-flash-lite:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.25 in / \$1.5 out per 1M tokens |
| Cached input | \$0.025 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.1 Pro (Preview)
Source: https://docs.aireserve.com/models/catalog/gemini-3.1-pro-preview

Frontier Gemini Pro model with advanced reasoning capability (preview).

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.1-pro-preview`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.1-pro-preview",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.1-pro-preview",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.1-pro-preview",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.1-pro-preview` | Canonical gateway id |
| `claude-air-gemini-3.1-pro-preview` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.1-pro-preview:nitro` picks the fastest provider serving these weights and `gemini-3.1-pro-preview:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$2 in / \$12 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.5 Flash
Source: https://docs.aireserve.com/models/catalog/gemini-3.5-flash

Gemini 3.5 Flash model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.5-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.5-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.5-flash` | Canonical gateway id |
| `claude-air-gemini-3.5-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.5-flash:nitro` picks the fastest provider serving these weights and `gemini-3.5-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$1.5 in / \$9 out per 1M tokens |
| Cached input | \$0.15 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.5 Flash Lite
Source: https://docs.aireserve.com/models/catalog/gemini-3.5-flash-lite

Cost-efficient Gemini 3.5 Flash Lite model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.5-flash-lite`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.5-flash-lite",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.5-flash-lite",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.5-flash-lite",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.5-flash-lite` | Canonical gateway id |
| `claude-air-gemini-3.5-flash-lite` | Claude Code picker id |
| `gemini-2.5-flash-lite` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.5-flash-lite:nitro` picks the fastest provider serving these weights and `gemini-3.5-flash-lite:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.3 in / \$2.5 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.6 Flash
Source: https://docs.aireserve.com/models/catalog/gemini-3.6-flash

Gemini 3.6 Flash model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.6-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.6-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.6-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.6-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.6-flash` | Canonical gateway id |
| `claude-air-gemini-3.6-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.6-flash:nitro` picks the fastest provider serving these weights and `gemini-3.6-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.75 in / \$3.75 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.7 Flash
Source: https://docs.aireserve.com/models/catalog/gemini-3.7-flash

Latest Gemini Flash model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.7-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.7-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.7-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.7-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.7-flash` | Canonical gateway id |
| `claude-air-gemini-3.7-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.7-flash:nitro` picks the fastest provider serving these weights and `gemini-3.7-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.75 in / \$3.75 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemini 3.8 Flash
Source: https://docs.aireserve.com/models/catalog/gemini-3.8-flash

Latest Gemini Flash model with advanced reasoning capability.

**Chat** · Google

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemini-3.8-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemini-3.8-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemini-3.8-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemini-3.8-flash` | Canonical gateway id |
| `claude-air-gemini-3.8-flash` | Claude Code picker id |
| `gemini` | Family default |
| `google` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemini-3.8-flash:nitro` picks the fastest provider serving these weights and `gemini-3.8-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Google |
| Context window | 1,048,576 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.75 in / \$3.75 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Video input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Gemma 4 31B
Source: https://docs.aireserve.com/models/catalog/gemma-4-31b

Gemma 4 31B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Google · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gemma-4-31b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma-4-31b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gemma-4-31b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gemma-4-31b` | Canonical gateway id |
| `claude-air-gemma-4-31b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gemma-4-31b:nitro` picks the fastest provider serving these weights and `gemma-4-31b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Google |
| Served by | Tensormesh |
| Context window | 32,768 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.14 in / \$0.56 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 4.7 (Amazon Bedrock)
Source: https://docs.aireserve.com/models/catalog/glm-4.7-bedrock

GLM 4.7 (Amazon Bedrock) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-4.7-bedrock`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-4.7-bedrock",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-4.7-bedrock",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-4.7-bedrock",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-4.7-bedrock` | Canonical gateway id |
| `zai.glm-4.7` | AWS Bedrock id |
| `claude-air-glm-4.7-bedrock` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-4.7-bedrock:nitro` picks the fastest provider serving these weights and `glm-4.7-bedrock:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Amazon Bedrock |
| Context window | 203,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.6 in / \$2.2 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-4.7-deepinfra`](/models/catalog/glm-4.7-deepinfra) | DeepInfra | \$0.4 in / \$1.75 out per 1M tokens |
| [`glm-4.7-novita`](/models/catalog/glm-4.7-novita) | Novita AI | \$0.6 in / \$2.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 4.7 (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/glm-4.7-deepinfra

Zhipu GLM 4.7 flagship (200K context) served by DeepInfra.

**Chat** · Z.ai · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-4.7-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-4.7-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-4.7-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-4.7-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-4.7-deepinfra` | Canonical gateway id |
| `claude-air-glm-4.7-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-4.7-deepinfra:nitro` picks the fastest provider serving these weights and `glm-4.7-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | DeepInfra |
| Context window | 202,752 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.4 in / \$1.75 out per 1M tokens |
| Cached input | \$0.08 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-4.7-bedrock`](/models/catalog/glm-4.7-bedrock) | Amazon Bedrock | \$0.6 in / \$2.2 out per 1M tokens |
| [`glm-4.7-novita`](/models/catalog/glm-4.7-novita) | Novita AI | \$0.6 in / \$2.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 4.7 (Novita)
Source: https://docs.aireserve.com/models/catalog/glm-4.7-novita

Zhipu GLM 4.7 flagship (200K context) served by Novita AI.

**Chat** · Z.ai · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-4.7-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-4.7-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-4.7-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-4.7-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-4.7-novita` | Canonical gateway id |
| `claude-air-glm-4.7-novita` | Claude Code picker id |
| `glm-4.7-baseten` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-4.7-novita:nitro` picks the fastest provider serving these weights and `glm-4.7-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Novita AI |
| Context window | 204,800 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.6 in / \$2.2 out per 1M tokens |
| Cached input | \$0.11 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-4.7-bedrock`](/models/catalog/glm-4.7-bedrock) | Amazon Bedrock | \$0.6 in / \$2.2 out per 1M tokens |
| [`glm-4.7-deepinfra`](/models/catalog/glm-4.7-deepinfra) | DeepInfra | \$0.4 in / \$1.75 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2
Source: https://docs.aireserve.com/models/catalog/glm-5.2

Zhipu GLM flagship served by DeepInfra.

**Chat** · Z.ai · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2` | Canonical gateway id |
| `claude-air-glm-5.2` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2:nitro` picks the fastest provider serving these weights and `glm-5.2:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.563 in / \$1.8 out per 1M tokens |
| Cached input | \$0.105 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (Alibaba)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-alibaba

GLM 5.2 (Alibaba) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-alibaba`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-alibaba",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-alibaba",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-alibaba",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-alibaba` | Canonical gateway id |
| `claude-air-glm-5.2-alibaba` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-alibaba:nitro` picks the fastest provider serving these weights and `glm-5.2-alibaba:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Alibaba Cloud |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.966 in / \$3.04 out per 1M tokens |
| Cached input | \$0.193 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (Baseten)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-baseten

Zhipu GLM flagship served by Baseten Model APIs.

**Chat** · Z.ai · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-baseten` | Canonical gateway id |
| `claude-air-glm-5.2-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-baseten:nitro` picks the fastest provider serving these weights and `glm-5.2-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.14 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-deepinfra

GLM 5.2 (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-deepinfra` | Canonical gateway id |
| `claude-air-glm-5.2-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-deepinfra:nitro` picks the fastest provider serving these weights and `glm-5.2-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.563 in / \$1.8 out per 1M tokens |
| Cached input | \$0.105 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-gmicloud

GLM 5.2 (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-gmicloud` | Canonical gateway id |
| `claude-air-glm-5.2-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-gmicloud:nitro` picks the fastest provider serving these weights and `glm-5.2-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | GMI Cloud |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.26 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (Novita)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-novita

GLM 5.2 (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-novita` | Canonical gateway id |
| `claude-air-glm-5.2-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-novita:nitro` picks the fastest provider serving these weights and `glm-5.2-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.26 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (StreamLake)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-streamlake

GLM 5.2 (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-streamlake` | Canonical gateway id |
| `claude-air-glm-5.2-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-streamlake:nitro` picks the fastest provider serving these weights and `glm-5.2-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | StreamLake |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.26 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-tensormesh

GLM 5.2 (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-tensormesh` | Canonical gateway id |
| `claude-air-glm-5.2-tensormesh` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-tensormesh:nitro` picks the fastest provider serving these weights and `glm-5.2-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Tensormesh |
| Context window | 250,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-together`](/models/catalog/glm-5.2-together) | Together AI | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.2 (Together)
Source: https://docs.aireserve.com/models/catalog/glm-5.2-together

GLM 5.2 (Together) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.2-together`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2-together",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.2-together",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.2-together",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.2-together` | Canonical gateway id |
| `claude-air-glm-5.2-together` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.2-together:nitro` picks the fastest provider serving these weights and `glm-5.2-together:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Together AI |
| Context window | 512,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.26 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.2](/models/catalog/glm-5.2) (`glm-5.2`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.2-alibaba`](/models/catalog/glm-5.2-alibaba) | Alibaba Cloud | \$0.966 in / \$3.04 out per 1M tokens |
| [`glm-5.2-baseten`](/models/catalog/glm-5.2-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-deepinfra`](/models/catalog/glm-5.2-deepinfra) | DeepInfra | \$0.563 in / \$1.8 out per 1M tokens |
| [`glm-5.2-gmicloud`](/models/catalog/glm-5.2-gmicloud) | GMI Cloud | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-novita`](/models/catalog/glm-5.2-novita) | Novita AI | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-streamlake`](/models/catalog/glm-5.2-streamlake) | StreamLake | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.2-tensormesh`](/models/catalog/glm-5.2-tensormesh) | Tensormesh | \$1.4 in / \$4.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3
Source: https://docs.aireserve.com/models/catalog/glm-5.3

Zhipu GLM flagship reasoning model (1M context) served by Fireworks AI.

**Chat** · Z.ai · served by Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3` | Canonical gateway id |
| `claude-air-glm-5.3` | Claude Code picker id |
| `glm` | Family default |
| `zhipu` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3:nitro` picks the fastest provider serving these weights and `glm-5.3:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Fireworks AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.26 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-baseten`](/models/catalog/glm-5.3-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.3-deepinfra`](/models/catalog/glm-5.3-deepinfra) | DeepInfra | \$0.563 in / \$2.5 out per 1M tokens |
| [`glm-5.3-gmicloud`](/models/catalog/glm-5.3-gmicloud) | GMI Cloud | \$1.12 in / \$3.52 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 (Baseten)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-baseten

Zhipu GLM flagship reasoning model (1M context) served by Baseten Model APIs.

**Chat** · Z.ai · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-baseten` | Canonical gateway id |
| `claude-air-glm-5.3-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-baseten:nitro` picks the fastest provider serving these weights and `glm-5.3-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.4 in / \$4.4 out per 1M tokens |
| Cached input | \$0.14 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.3](/models/catalog/glm-5.3) (`glm-5.3`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-deepinfra`](/models/catalog/glm-5.3-deepinfra) | DeepInfra | \$0.563 in / \$2.5 out per 1M tokens |
| [`glm-5.3-gmicloud`](/models/catalog/glm-5.3-gmicloud) | GMI Cloud | \$1.12 in / \$3.52 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-deepinfra

Zhipu GLM 5.3 flagship reasoning model (1M context) served by DeepInfra.

**Chat** · Z.ai · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-deepinfra` | Canonical gateway id |
| `claude-air-glm-5.3-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-deepinfra:nitro` picks the fastest provider serving these weights and `glm-5.3-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.563 in / \$2.5 out per 1M tokens |
| Cached input | \$0.125 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.3](/models/catalog/glm-5.3) (`glm-5.3`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-baseten`](/models/catalog/glm-5.3-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.3-gmicloud`](/models/catalog/glm-5.3-gmicloud) | GMI Cloud | \$1.12 in / \$3.52 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 Flash (Baseten)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-flash-baseten

Zhipu GLM 5.3 Flash (MIT-licensed 320B-A18B, 1M context) served by Baseten Model APIs.

**Chat** · Z.ai · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-flash-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-flash-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-flash-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-flash-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-flash-baseten` | Canonical gateway id |
| `claude-air-glm-5.3-flash-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-flash-baseten:nitro` picks the fastest provider serving these weights and `glm-5.3-flash-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Baseten |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.15 in / \$0.5 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-flash-gmicloud`](/models/catalog/glm-5.3-flash-gmicloud) | GMI Cloud | \$0.113 in / \$0.375 out per 1M tokens |
| [`glm-5.3-flash-novita`](/models/catalog/glm-5.3-flash-novita) | Novita AI | \$0.15 in / \$0.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 Flash (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-flash-gmicloud

GLM 5.3 Flash (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-flash-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-flash-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-flash-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-flash-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-flash-gmicloud` | Canonical gateway id |
| `claude-air-glm-5.3-flash-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-flash-gmicloud:nitro` picks the fastest provider serving these weights and `glm-5.3-flash-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | GMI Cloud |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$0.113 in / \$0.375 out per 1M tokens |
| Cached input | \$0.022 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-flash-baseten`](/models/catalog/glm-5.3-flash-baseten) | Baseten | \$0.15 in / \$0.5 out per 1M tokens |
| [`glm-5.3-flash-novita`](/models/catalog/glm-5.3-flash-novita) | Novita AI | \$0.15 in / \$0.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 Flash (Novita)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-flash-novita

Zhipu GLM 5.3 Flash (MIT-licensed 320B-A18B, 1M context) served by Novita AI.

**Chat** · Z.ai · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-flash-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-flash-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-flash-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-flash-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-flash-novita` | Canonical gateway id |
| `claude-air-glm-5.3-flash-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-flash-novita:nitro` picks the fastest provider serving these weights and `glm-5.3-flash-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.15 in / \$0.5 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-flash-baseten`](/models/catalog/glm-5.3-flash-baseten) | Baseten | \$0.15 in / \$0.5 out per 1M tokens |
| [`glm-5.3-flash-gmicloud`](/models/catalog/glm-5.3-flash-gmicloud) | GMI Cloud | \$0.113 in / \$0.375 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GLM 5.3 (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/glm-5.3-gmicloud

GLM 5.3 (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Z.ai · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `glm-5.3-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="glm-5.3-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "glm-5.3-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `glm-5.3-gmicloud` | Canonical gateway id |
| `claude-air-glm-5.3-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `glm-5.3-gmicloud:nitro` picks the fastest provider serving these weights and `glm-5.3-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Z.ai |
| Served by | GMI Cloud |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$1.12 in / \$3.52 out per 1M tokens |
| Cached input | \$0.208 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GLM 5.3](/models/catalog/glm-5.3) (`glm-5.3`).

| Model id | Served by | Pricing |
| - | - | - |
| [`glm-5.3-baseten`](/models/catalog/glm-5.3-baseten) | Baseten | \$1.4 in / \$4.4 out per 1M tokens |
| [`glm-5.3-deepinfra`](/models/catalog/glm-5.3-deepinfra) | DeepInfra | \$0.563 in / \$2.5 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4 Turbo
Source: https://docs.aireserve.com/models/catalog/gpt-4-turbo

GPT-4 Turbo on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-4-turbo`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4-turbo",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-4-turbo",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4-turbo` | Canonical gateway id |
| `claude-air-gpt-4-turbo` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-4-turbo:nitro` picks the fastest provider serving these weights and `gpt-4-turbo:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Pricing | \$10 in / \$30 out per 1M tokens |
| Cached input | \$5 per 1M tokens |
| Capabilities | Streaming, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4.1
Source: https://docs.aireserve.com/models/catalog/gpt-4.1

Non-reasoning OpenAI model with a 1M-token context window.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-4.1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4.1",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-4.1",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4.1` | Canonical gateway id |
| `claude-air-gpt-4.1` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-4.1:nitro` picks the fastest provider serving these weights and `gpt-4.1:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,047,576 tokens |
| Max output | 32,768 tokens |
| Pricing | \$2 in / \$8 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4.1 Mini
Source: https://docs.aireserve.com/models/catalog/gpt-4.1-mini

Smaller non-reasoning OpenAI model with a 1M-token context window.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-4.1-mini`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4.1-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-4.1-mini",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4.1-mini` | Canonical gateway id |
| `claude-air-gpt-4.1-mini` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-4.1-mini:nitro` picks the fastest provider serving these weights and `gpt-4.1-mini:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,047,576 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.4 in / \$1.6 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4o
Source: https://docs.aireserve.com/models/catalog/gpt-4o

General-purpose OpenAI model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-4o`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4o` | Canonical gateway id |
| `claude-air-gpt-4o` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-4o:nitro` picks the fastest provider serving these weights and `gpt-4o:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 128,000 tokens |
| Max output | 16,384 tokens |
| Pricing | \$2.5 in / \$10 out per 1M tokens |
| Cached input | \$1.25 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4o Mini
Source: https://docs.aireserve.com/models/catalog/gpt-4o-mini

GPT-4o Mini on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-4o-mini`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4o-mini` | Canonical gateway id |
| `claude-air-gpt-4o-mini` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-4o-mini:nitro` picks the fastest provider serving these weights and `gpt-4o-mini:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 128,000 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.15 in / \$0.6 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-4o mini Transcribe
Source: https://docs.aireserve.com/models/catalog/gpt-4o-mini-transcribe

GPT-4o mini Transcribe on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Speech-to-text** · OpenAI

## Call it

Endpoint: `POST /v1/audio/transcriptions` — set `model` to `gpt-4o-mini-transcribe`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -F model="gpt-4o-mini-transcribe" \
  -F file=@recording.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with open("recording.mp3", "rb") as audio:
    res = client.audio.transcriptions.create(
        model="gpt-4o-mini-transcribe",
        file=audio,
    )
print(res.text)
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-4o-mini-transcribe` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Speech-to-text |
| Model maker | OpenAI |
| Served by | OpenAI |
| Pricing | — |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.1
Source: https://docs.aireserve.com/models/catalog/gpt-5.1

OpenAI GPT-5.1 reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.1",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.1",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.1` | Canonical gateway id |
| `claude-air-gpt-5.1` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.1:nitro` picks the fastest provider serving these weights and `gpt-5.1:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$1.25 in / \$10 out per 1M tokens |
| Cached input | \$0.125 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.2
Source: https://docs.aireserve.com/models/catalog/gpt-5.2

Previous-flagship OpenAI GPT-5.2 reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.2",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.2",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.2` | Canonical gateway id |
| `claude-air-gpt-5.2` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.2:nitro` picks the fastest provider serving these weights and `gpt-5.2:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$1.75 in / \$14 out per 1M tokens |
| Cached input | \$0.175 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.2 Pro
Source: https://docs.aireserve.com/models/catalog/gpt-5.2-pro

Extended-compute pro tier of GPT-5.2.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.2-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.2-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.2-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.2-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.2-pro` | Canonical gateway id |
| `claude-air-gpt-5.2-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.2-pro:nitro` picks the fastest provider serving these weights and `gpt-5.2-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$21 in / \$168 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.3 Codex
Source: https://docs.aireserve.com/models/catalog/gpt-5.3-codex

Coding-specialized OpenAI reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.3-codex`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.3-codex",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.3-codex",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.3-codex",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.3-codex` | Canonical gateway id |
| `claude-air-gpt-5.3-codex` | Claude Code picker id |
| `codex` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.3-codex:nitro` picks the fastest provider serving these weights and `gpt-5.3-codex:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$1.75 in / \$14 out per 1M tokens |
| Cached input | \$0.175 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.4
Source: https://docs.aireserve.com/models/catalog/gpt-5.4

General-purpose OpenAI model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.4`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.4",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.4` | Canonical gateway id |
| `claude-air-gpt-5.4` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.4:nitro` picks the fastest provider serving these weights and `gpt-5.4:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2.5 in / \$15 out per 1M tokens |
| Cached input | \$0.25 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.4 Mini
Source: https://docs.aireserve.com/models/catalog/gpt-5.4-mini

Smaller OpenAI model with standard reasoning capability.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.4-mini`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.4-mini` | Canonical gateway id |
| `claude-air-gpt-5.4-mini` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.4-mini:nitro` picks the fastest provider serving these weights and `gpt-5.4-mini:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.75 in / \$4.5 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.4 Nano
Source: https://docs.aireserve.com/models/catalog/gpt-5.4-nano

GPT-5.4 Nano on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.4-nano`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-nano",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.4-nano",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.4-nano",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.4-nano` | Canonical gateway id |
| `claude-air-gpt-5.4-nano` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.4-nano:nitro` picks the fastest provider serving these weights and `gpt-5.4-nano:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 400,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.2 in / \$1.25 out per 1M tokens |
| Cached input | \$0.02 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.4 Pro
Source: https://docs.aireserve.com/models/catalog/gpt-5.4-pro

Extended-compute pro tier of GPT-5.4 with a 1M-token context window.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.4-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.4-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.4-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.4-pro` | Canonical gateway id |
| `claude-air-gpt-5.4-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.4-pro:nitro` picks the fastest provider serving these weights and `gpt-5.4-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$30 in / \$180 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.5
Source: https://docs.aireserve.com/models/catalog/gpt-5.5

OpenAI reasoning-capable model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.5` | Canonical gateway id |
| `claude-air-gpt-5.5` | Claude Code picker id |
| `chatgpt` | Family default |
| `gpt` | Family default |
| `openai` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.5:nitro` picks the fastest provider serving these weights and `gpt-5.5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$5 in / \$30 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.5 Pro
Source: https://docs.aireserve.com/models/catalog/gpt-5.5-pro

Extended-compute pro tier of GPT-5.5 for the hardest reasoning tasks.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.5-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.5-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.5-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.5-pro` | Canonical gateway id |
| `claude-air-gpt-5.5-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.5-pro:nitro` picks the fastest provider serving these weights and `gpt-5.5-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$30 in / \$180 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.6 Luna
Source: https://docs.aireserve.com/models/catalog/gpt-5.6-luna

Fast, cost-efficient OpenAI GPT-5.6 reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.6-luna`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-luna",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.6-luna",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.6-luna` | Canonical gateway id |
| `claude-air-gpt-5.6-luna` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.6-luna:nitro` picks the fastest provider serving these weights and `gpt-5.6-luna:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.2 in / \$1.2 out per 1M tokens |
| Cached input | \$0.02 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.6 Sol
Source: https://docs.aireserve.com/models/catalog/gpt-5.6-sol

Flagship OpenAI GPT-5.6 reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.6-sol`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.6-sol` | Canonical gateway id |
| `claude-air-gpt-5.6-sol` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.6-sol:nitro` picks the fastest provider serving these weights and `gpt-5.6-sol:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$4 in / \$20 out per 1M tokens |
| Cached input | \$0.4 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.6 Sol Ultra
Source: https://docs.aireserve.com/models/catalog/gpt-5.6-sol-ultra

Multi-agent serving of flagship GPT-5.6 Sol: parallel subagents on the same weights (higher token use per request).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.6-sol-ultra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol-ultra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.6-sol-ultra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.6-sol-ultra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.6-sol-ultra` | Canonical gateway id |
| `claude-air-gpt-5.6-sol-ultra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.6-sol-ultra:nitro` picks the fastest provider serving these weights and `gpt-5.6-sol-ultra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$4 in / \$20 out per 1M tokens |
| Cached input | \$0.4 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-5.6 Terra
Source: https://docs.aireserve.com/models/catalog/gpt-5.6-terra

Mid-tier OpenAI GPT-5.6 reasoning model.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-5.6-terra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-5.6-terra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-5.6-terra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-5.6-terra` | Canonical gateway id |
| `claude-air-gpt-5.6-terra` | Claude Code picker id |
| `terra` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-5.6-terra:nitro` picks the fastest provider serving these weights and `gpt-5.6-terra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$12 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6 Astra
Source: https://docs.aireserve.com/models/catalog/gpt-6-astra

OpenAI's first GPT-6 model for frontier reasoning and long-horizon work.

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6-astra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6-astra` | Canonical gateway id |
| `claude-air-gpt-6-astra` | Claude Code picker id |
| `astra` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6-astra:nitro` picks the fastest provider serving these weights and `gpt-6-astra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$10 in / \$50 out per 1M tokens |
| Cached input | \$1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6 Astra Ultrafast
Source: https://docs.aireserve.com/models/catalog/gpt-6-astra-ultrafast

Ultrafast service tier of GPT-6 Astra: the same flagship weights on OpenAI's fastest serving tier (6x the Standard price).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6-astra-ultrafast`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra-ultrafast",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6-astra-ultrafast",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6-astra-ultrafast",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6-astra-ultrafast` | Canonical gateway id |
| `claude-air-gpt-6-astra-ultrafast` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6-astra-ultrafast:nitro` picks the fastest provider serving these weights and `gpt-6-astra-ultrafast:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$60 in / \$300 out per 1M tokens |
| Cached input | \$6 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6 Luna
Source: https://docs.aireserve.com/models/catalog/gpt-6-luna

Fast, cost-efficient OpenAI GPT-6 reasoning model (1M context).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6-luna`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6-luna",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6-luna",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6-luna` | Canonical gateway id |
| `claude-air-gpt-6-luna` | Claude Code picker id |
| `luna` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6-luna:nitro` picks the fastest provider serving these weights and `gpt-6-luna:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.1 in / \$0.5 out per 1M tokens |
| Cached input | \$0.01 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6 Sol
Source: https://docs.aireserve.com/models/catalog/gpt-6-sol

Flagship OpenAI GPT-6 reasoning model (1M context).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6-sol`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-sol",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6-sol",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6-sol` | Canonical gateway id |
| `claude-air-gpt-6-sol` | Claude Code picker id |
| `sol` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6-sol:nitro` picks the fastest provider serving these weights and `gpt-6-sol:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6.1 Sol
Source: https://docs.aireserve.com/models/catalog/gpt-6.1-sol

Flagship OpenAI GPT-6.1 reasoning model (1M context).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6.1-sol`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6.1-sol",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6.1-sol` | Canonical gateway id |
| `claude-air-gpt-6.1-sol` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6.1-sol:nitro` picks the fastest provider serving these weights and `gpt-6.1-sol:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$2 in / \$10 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-6.1 Sol Ultrafast
Source: https://docs.aireserve.com/models/catalog/gpt-6.1-sol-ultrafast

Ultrafast service tier of GPT-6.1 Sol: the same weights at up to 8x faster token generation (6x the Standard price).

**Chat** · OpenAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-6.1-sol-ultrafast`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol-ultrafast",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-6.1-sol-ultrafast",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-6.1-sol-ultrafast",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-6.1-sol-ultrafast` | Canonical gateway id |
| `claude-air-gpt-6.1-sol-ultrafast` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-6.1-sol-ultrafast:nitro` picks the fastest provider serving these weights and `gpt-6.1-sol-ultrafast:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | OpenAI |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Pricing | \$12 in / \$60 out per 1M tokens |
| Cached input | \$0.6 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Extended reasoning, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT Image 1
Source: https://docs.aireserve.com/models/catalog/gpt-image-1

GPT Image 1 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · OpenAI

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `gpt-image-1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-1",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="gpt-image-1",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "gpt-image-1",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-image-1` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | OpenAI |
| Served by | OpenAI |
| Pricing | \$5 in / \$40 out per 1M tokens · token-billed |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# gpt-image-2-edit
Source: https://docs.aireserve.com/models/catalog/gpt-image-2-edit

Accepts up to 8 input images.

**Image editing** · OpenAI · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `gpt-image-2-edit`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-image-2-edit` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | OpenAI |
| Served by | fal |
| Pricing | \$0.45 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 120B
Source: https://docs.aireserve.com/models/catalog/gpt-oss-120b

OpenAI GPT-OSS 120B open-weight model served by Fireworks AI.

**Chat** · OpenAI · served by Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-120b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-120b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-120b` | Canonical gateway id |
| `claude-air-gpt-oss-120b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-120b:nitro` picks the fastest provider serving these weights and `gpt-oss-120b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | Fireworks AI |
| Context window | 131,072 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.15 in / \$0.6 out per 1M tokens |
| Cached input | \$0.015 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-120b-baseten`](/models/catalog/gpt-oss-120b-baseten) | Baseten | \$0.1 in / \$0.5 out per 1M tokens |
| [`gpt-oss-120b-deepinfra`](/models/catalog/gpt-oss-120b-deepinfra) | DeepInfra | \$0.037 in / \$0.17 out per 1M tokens |
| [`gpt-oss-120b-tensormesh`](/models/catalog/gpt-oss-120b-tensormesh) | Tensormesh | \$0.15 in / \$0.6 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 120B (Baseten)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-120b-baseten

GPT-OSS 120B (Baseten) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-120b-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-120b-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-120b-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-120b-baseten` | Canonical gateway id |
| `claude-air-gpt-oss-120b-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-120b-baseten:nitro` picks the fastest provider serving these weights and `gpt-oss-120b-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | Baseten |
| Context window | 131,072 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.1 in / \$0.5 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 120B](/models/catalog/gpt-oss-120b) (`gpt-oss-120b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-120b-deepinfra`](/models/catalog/gpt-oss-120b-deepinfra) | DeepInfra | \$0.037 in / \$0.17 out per 1M tokens |
| [`gpt-oss-120b-tensormesh`](/models/catalog/gpt-oss-120b-tensormesh) | Tensormesh | \$0.15 in / \$0.6 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 120B (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-120b-deepinfra

GPT-OSS 120B (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-120b-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-120b-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-120b-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-120b-deepinfra` | Canonical gateway id |
| `claude-air-gpt-oss-120b-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-120b-deepinfra:nitro` picks the fastest provider serving these weights and `gpt-oss-120b-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | DeepInfra |
| Context window | 131,072 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.037 in / \$0.17 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 120B](/models/catalog/gpt-oss-120b) (`gpt-oss-120b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-120b-baseten`](/models/catalog/gpt-oss-120b-baseten) | Baseten | \$0.1 in / \$0.5 out per 1M tokens |
| [`gpt-oss-120b-tensormesh`](/models/catalog/gpt-oss-120b-tensormesh) | Tensormesh | \$0.15 in / \$0.6 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 120B (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-120b-tensormesh

GPT-OSS 120B (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-120b-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-120b-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-120b-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-120b-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-120b-tensormesh` | Canonical gateway id |
| `claude-air-gpt-oss-120b-tensormesh` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-120b-tensormesh:nitro` picks the fastest provider serving these weights and `gpt-oss-120b-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | Tensormesh |
| Context window | 131,072 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.15 in / \$0.6 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 120B](/models/catalog/gpt-oss-120b) (`gpt-oss-120b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-120b-baseten`](/models/catalog/gpt-oss-120b-baseten) | Baseten | \$0.1 in / \$0.5 out per 1M tokens |
| [`gpt-oss-120b-deepinfra`](/models/catalog/gpt-oss-120b-deepinfra) | DeepInfra | \$0.037 in / \$0.17 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 20B
Source: https://docs.aireserve.com/models/catalog/gpt-oss-20b

GPT-OSS 20B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-20b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-20b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-20b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-20b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-20b` | Canonical gateway id |
| `claude-air-gpt-oss-20b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-20b:nitro` picks the fastest provider serving these weights and `gpt-oss-20b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | DeepInfra |
| Context window | 131,072 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.03 in / \$0.14 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-20b-deepinfra`](/models/catalog/gpt-oss-20b-deepinfra) | DeepInfra | \$0.03 in / \$0.14 out per 1M tokens |
| [`gpt-oss-20b-novita`](/models/catalog/gpt-oss-20b-novita) | Novita AI | \$0.04 in / \$0.15 out per 1M tokens |
| [`gpt-oss-20b-tensormesh`](/models/catalog/gpt-oss-20b-tensormesh) | Tensormesh | \$0.07 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 20B (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-20b-deepinfra

GPT-OSS 20B (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-20b-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-20b-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-20b-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-20b-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-20b-deepinfra` | Canonical gateway id |
| `claude-air-gpt-oss-20b-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-20b-deepinfra:nitro` picks the fastest provider serving these weights and `gpt-oss-20b-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | DeepInfra |
| Context window | 131,072 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.03 in / \$0.14 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 20B](/models/catalog/gpt-oss-20b) (`gpt-oss-20b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-20b-novita`](/models/catalog/gpt-oss-20b-novita) | Novita AI | \$0.04 in / \$0.15 out per 1M tokens |
| [`gpt-oss-20b-tensormesh`](/models/catalog/gpt-oss-20b-tensormesh) | Tensormesh | \$0.07 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 20B (Novita)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-20b-novita

GPT-OSS 20B (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-20b-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-20b-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-20b-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-20b-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-20b-novita` | Canonical gateway id |
| `claude-air-gpt-oss-20b-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-20b-novita:nitro` picks the fastest provider serving these weights and `gpt-oss-20b-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | Novita AI |
| Context window | 131,072 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.04 in / \$0.15 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 20B](/models/catalog/gpt-oss-20b) (`gpt-oss-20b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-20b-deepinfra`](/models/catalog/gpt-oss-20b-deepinfra) | DeepInfra | \$0.03 in / \$0.14 out per 1M tokens |
| [`gpt-oss-20b-tensormesh`](/models/catalog/gpt-oss-20b-tensormesh) | Tensormesh | \$0.07 in / \$0.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# GPT-OSS 20B (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/gpt-oss-20b-tensormesh

GPT-OSS 20B (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · OpenAI · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `gpt-oss-20b-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-oss-20b-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="gpt-oss-20b-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "gpt-oss-20b-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `gpt-oss-20b-tensormesh` | Canonical gateway id |
| `claude-air-gpt-oss-20b-tensormesh` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `gpt-oss-20b-tensormesh:nitro` picks the fastest provider serving these weights and `gpt-oss-20b-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | OpenAI |
| Served by | Tensormesh |
| Context window | 131,072 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.07 in / \$0.28 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [GPT-OSS 20B](/models/catalog/gpt-oss-20b) (`gpt-oss-20b`).

| Model id | Served by | Pricing |
| - | - | - |
| [`gpt-oss-20b-deepinfra`](/models/catalog/gpt-oss-20b-deepinfra) | DeepInfra | \$0.03 in / \$0.14 out per 1M tokens |
| [`gpt-oss-20b-novita`](/models/catalog/gpt-oss-20b-novita) | Novita AI | \$0.04 in / \$0.15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 3
Source: https://docs.aireserve.com/models/catalog/grok-3

General-purpose xAI model.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-3",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-3` | Canonical gateway id |
| `claude-air-grok-3` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-3:nitro` picks the fastest provider serving these weights and `grok-3:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 131,072 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 3 Mini
Source: https://docs.aireserve.com/models/catalog/grok-3-mini

Smaller xAI model with standard reasoning capability.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-3-mini`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-3-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-3-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-3-mini",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-3-mini` | Canonical gateway id |
| `claude-air-grok-3-mini` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-3-mini:nitro` picks the fastest provider serving these weights and `grok-3-mini:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 131,072 tokens |
| Pricing | \$0.3 in / \$0.5 out per 1M tokens |
| Cached input | \$0.075 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.1 Fast
Source: https://docs.aireserve.com/models/catalog/grok-4-1-fast-non-reasoning

Grok 4.1 Fast on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-1-fast-non-reasoning`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-1-fast-non-reasoning",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-1-fast-non-reasoning",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-1-fast-non-reasoning",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-1-fast-non-reasoning` | Canonical gateway id |
| `claude-air-grok-4-1-fast-non-reasoning` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-1-fast-non-reasoning:nitro` picks the fastest provider serving these weights and `grok-4-1-fast-non-reasoning:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 2,000,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.1 Fast (Reasoning)
Source: https://docs.aireserve.com/models/catalog/grok-4-1-fast-reasoning

xAI fast reasoning model.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-1-fast-reasoning`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-1-fast-reasoning",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-1-fast-reasoning",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-1-fast-reasoning",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-1-fast-reasoning` | Canonical gateway id |
| `claude-air-grok-4-1-fast-reasoning` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-1-fast-reasoning:nitro` picks the fastest provider serving these weights and `grok-4-1-fast-reasoning:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 2,000,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.20
Source: https://docs.aireserve.com/models/catalog/grok-4-20

xAI reasoning-capable model with a 2M-token context window.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-20`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-20",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-20",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-20",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-20` | Canonical gateway id |
| `claude-air-grok-4-20` | Claude Code picker id |
| `grok-4.20` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-20:nitro` picks the fastest provider serving these weights and `grok-4-20:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 2,000,000 tokens |
| Max output | 1,800,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.20 Multi-Agent
Source: https://docs.aireserve.com/models/catalog/grok-4-20-multi-agent

Multi-agent serving variant of Grok 4.20.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-20-multi-agent`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-20-multi-agent",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-20-multi-agent",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-20-multi-agent",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-20-multi-agent` | Canonical gateway id |
| `claude-air-grok-4-20-multi-agent` | Claude Code picker id |
| `grok-4.20-multi-agent` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-20-multi-agent:nitro` picks the fastest provider serving these weights and `grok-4-20-multi-agent:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 2,000,000 tokens |
| Max output | 1,800,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.20 (Non-Reasoning)
Source: https://docs.aireserve.com/models/catalog/grok-4-20-non-reasoning

Non-reasoning serving of Grok 4.20 for latency-sensitive tool calling.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-20-non-reasoning`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-20-non-reasoning",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-20-non-reasoning",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-20-non-reasoning",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-20-non-reasoning` | Canonical gateway id |
| `claude-air-grok-4-20-non-reasoning` | Claude Code picker id |
| `grok-4.20-non-reasoning` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-20-non-reasoning:nitro` picks the fastest provider serving these weights and `grok-4-20-non-reasoning:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 2,000,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.3
Source: https://docs.aireserve.com/models/catalog/grok-4-3

xAI reasoning-capable model.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-3",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-3` | Canonical gateway id |
| `claude-air-grok-4-3` | Claude Code picker id |
| `grok-4.3` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-3:nitro` picks the fastest provider serving these weights and `grok-4-3:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 1,000,000 tokens |
| Max output | 900,000 tokens |
| Pricing | \$1.25 in / \$2.5 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.5
Source: https://docs.aireserve.com/models/catalog/grok-4-5

xAI reasoning-capable model.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-5` | Canonical gateway id |
| `claude-air-grok-4-5` | Claude Code picker id |
| `grok-4.5` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-5:nitro` picks the fastest provider serving these weights and `grok-4-5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 500,000 tokens |
| Max output | 450,000 tokens |
| Pricing | \$2 in / \$6 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok 4.6
Source: https://docs.aireserve.com/models/catalog/grok-4-6

xAI's newest flagship with frontier coding/STEM performance and a 500K context window.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-4-6`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4-6",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-4-6",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-4-6",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-4-6` | Canonical gateway id |
| `claude-air-grok-4-6` | Claude Code picker id |
| `grok` | Family default |
| `xai` | Family default |
| `grok-4.6` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-4-6:nitro` picks the fastest provider serving these weights and `grok-4-6:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 500,000 tokens |
| Max output | 450,000 tokens |
| Pricing | \$2 in / \$6 out per 1M tokens |
| Cached input | \$0.5 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok Build 0.1
Source: https://docs.aireserve.com/models/catalog/grok-build-0-1

xAI's fast coding model tuned for agentic software-engineering workflows.

**Chat** · xAI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `grok-build-0-1`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-build-0-1",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="grok-build-0-1",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "grok-build-0-1",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-build-0-1` | Canonical gateway id |
| `claude-air-grok-build-0-1` | Claude Code picker id |
| `grok-build-0.1` | xAI dotted id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `grok-build-0-1:nitro` picks the fastest provider serving these weights and `grok-build-0-1:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | xAI |
| Served by | xAI |
| Context window | 256,000 tokens |
| Max output | 230,400 tokens |
| Pricing | \$1 in / \$2 out per 1M tokens |
| Cached input | \$0.2 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# grok-imagine-image
Source: https://docs.aireserve.com/models/catalog/grok-imagine-image

grok-imagine-image on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · xAI · served by fal

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `grok-imagine-image`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-image",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="grok-imagine-image",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "grok-imagine-image",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-imagine-image` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | xAI |
| Served by | fal |
| Pricing | \$0.02 / image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# grok-imagine-image-edit
Source: https://docs.aireserve.com/models/catalog/grok-imagine-image-edit

Accepts up to 4 input images.

**Image editing** · xAI · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `grok-imagine-image-edit`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-image-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-image-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-imagine-image-edit` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | xAI |
| Served by | fal |
| Pricing | \$0.02 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# grok-imagine-video-1.5-i2v
Source: https://docs.aireserve.com/models/catalog/grok-imagine-video-1.5-i2v

grok-imagine-video-1.5-i2v on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image-to-video** · xAI · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `grok-imagine-video-1.5-i2v`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-1.5-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-1.5-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-imagine-video-1.5-i2v` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Image-to-video |
| Model maker | xAI |
| Served by | fal |
| Pricing | 480p \$0.08/s, 720p \$0.14/s, 1080p \$0.25/s · + \$0.01 per input image |
| Capabilities | Image input |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# grok-imagine-video-1.5-reference
Source: https://docs.aireserve.com/models/catalog/grok-imagine-video-1.5-reference

grok-imagine-video-1.5-reference on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Reference-to-video** · xAI · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `grok-imagine-video-1.5-reference`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-1.5-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-1.5-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-imagine-video-1.5-reference` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Reference-to-video |
| Model maker | xAI |
| Served by | fal |
| Pricing | 480p \$0.08/s, 720p \$0.14/s · + \$0.01 per input image |
| Capabilities | Reference media |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# grok-imagine-video-i2v
Source: https://docs.aireserve.com/models/catalog/grok-imagine-video-i2v

grok-imagine-video-i2v on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image-to-video** · xAI · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `grok-imagine-video-i2v`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-imagine-video-i2v` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Image-to-video |
| Model maker | xAI |
| Served by | fal |
| Pricing | 480p \$0.05/s, 720p \$0.07/s · + \$0.002 per input image |
| Capabilities | Image input |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok TTS
Source: https://docs.aireserve.com/models/catalog/grok-tts

Up to 4,096 characters per request · mp3 output.

**Text-to-speech** · xAI

## Call it

Endpoint: `POST /v1/audio/speech` — set `model` to `grok-tts`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/speech \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "grok-tts", "input": "Welcome to AI Reserve.", "voice": "ara"}' \
  --output speech.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="grok-tts",
    voice="ara",
    input="Welcome to AI Reserve.",
) as response:
    response.stream_to_file("speech.mp3")
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.audio.speech.create({
  model: "grok-tts",
  voice: "ara",
  input: "Welcome to AI Reserve.",
});
await Bun.write("speech.mp3", await res.arrayBuffer());
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-tts` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Text-to-speech |
| Model maker | xAI |
| Served by | xAI |
| Pricing | billed per input character — see guide |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Grok Voice (realtime)
Source: https://docs.aireserve.com/models/catalog/grok-voice

Speech-to-speech over a relayed WebSocket session; billed per session second.

**Realtime voice** · xAI

## Call it

Endpoint: `POST /v1/realtime/sessions` — set `model` to `grok-voice`.

```bash cURL theme={"dark"}
# Mints a short-lived relay ticket; open the returned websocket URL with it
curl -X POST https://api.aireserve.com/v1/realtime/sessions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "grok-voice", "voice": "ara"}'
```

Full request and response reference: [Realtime voice guide](/capabilities/realtime-voice).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `grok-voice` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Realtime voice |
| Model maker | xAI |
| Served by | xAI |
| Pricing | billed per session second — see guide |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2 Thinking
Source: https://docs.aireserve.com/models/catalog/kimi-k2-thinking

Moonshot Kimi K2 always-on thinking model (Moonshot API).

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2-thinking`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2-thinking",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2-thinking",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2-thinking",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2-thinking` | Canonical gateway id |
| `claude-air-kimi-k2-thinking` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2-thinking:nitro` picks the fastest provider serving these weights and `kimi-k2-thinking:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Context window | 262,144 tokens |
| Max output | 98,304 tokens |
| Pricing | \$0.6 in / \$2.5 out per 1M tokens |
| Cached input | \$0.06 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.5
Source: https://docs.aireserve.com/models/catalog/kimi-k2.5

Moonshot Kimi K2.5 vision-capable reasoning model (Moonshot API).

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.5` | Canonical gateway id |
| `claude-air-kimi-k2.5` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.5:nitro` picks the fastest provider serving these weights and `kimi-k2.5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.57 in / \$2.85 out per 1M tokens |
| Cached input | \$0.057 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6

Moonshot Kimi K2.6 (262K context) served by DeepInfra.

**Chat** · Moonshot · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6` | Canonical gateway id |
| `claude-air-kimi-k2.6` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6:nitro` picks the fastest provider serving these weights and `kimi-k2.6:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.75 in / \$3.5 out per 1M tokens |
| Cached input | \$0.15 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (Baseten)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-baseten

Moonshot Kimi K2.6 (262K context) served by Baseten Model APIs.

**Chat** · Moonshot · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-baseten` | Canonical gateway id |
| `claude-air-kimi-k2.6-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-baseten:nitro` picks the fastest provider serving these weights and `kimi-k2.6-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Baseten |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.16 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-deepinfra

Kimi K2.6 (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-deepinfra` | Canonical gateway id |
| `claude-air-kimi-k2.6-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-deepinfra:nitro` picks the fastest provider serving these weights and `kimi-k2.6-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.75 in / \$3.5 out per 1M tokens |
| Cached input | \$0.15 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-gmicloud

Kimi K2.6 (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-gmicloud` | Canonical gateway id |
| `claude-air-kimi-k2.6-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-gmicloud:nitro` picks the fastest provider serving these weights and `kimi-k2.6-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | GMI Cloud |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.855 in / \$3.6 out per 1M tokens |
| Cached input | \$0.144 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (Moonshot)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-moonshot

Kimi K2.6 (Moonshot) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-moonshot`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-moonshot",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-moonshot",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-moonshot",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-moonshot` | Canonical gateway id |
| `claude-air-kimi-k2.6-moonshot` | Claude Code picker id |
| `kimi-k2.6-together` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-moonshot:nitro` picks the fastest provider serving these weights and `kimi-k2.6-moonshot:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.16 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (Novita)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-novita

Kimi K2.6 (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-novita` | Canonical gateway id |
| `claude-air-kimi-k2.6-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-novita:nitro` picks the fastest provider serving these weights and `kimi-k2.6-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Novita AI |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.8 in / \$3.4 out per 1M tokens |
| Cached input | \$0.16 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (StreamLake)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-streamlake

Kimi K2.6 (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-streamlake` | Canonical gateway id |
| `claude-air-kimi-k2.6-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-streamlake:nitro` picks the fastest provider serving these weights and `kimi-k2.6-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | StreamLake |
| Context window | 262,144 tokens |
| Max output | 262,144 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.16 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-tensormesh`](/models/catalog/kimi-k2.6-tensormesh) | Tensormesh | \$0.96 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.6 (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.6-tensormesh

Kimi K2.6 (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.6-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.6-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.6-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.6-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.6-tensormesh` | Canonical gateway id |
| `claude-air-kimi-k2.6-tensormesh` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.6-tensormesh:nitro` picks the fastest provider serving these weights and `kimi-k2.6-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Tensormesh |
| Context window | 131,072 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.96 in / \$4 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.6](/models/catalog/kimi-k2.6) (`kimi-k2.6`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.6-baseten`](/models/catalog/kimi-k2.6-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-deepinfra`](/models/catalog/kimi-k2.6-deepinfra) | DeepInfra | \$0.75 in / \$3.5 out per 1M tokens |
| [`kimi-k2.6-gmicloud`](/models/catalog/kimi-k2.6-gmicloud) | GMI Cloud | \$0.855 in / \$3.6 out per 1M tokens |
| [`kimi-k2.6-moonshot`](/models/catalog/kimi-k2.6-moonshot) | Moonshot | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.6-novita`](/models/catalog/kimi-k2.6-novita) | Novita AI | \$0.8 in / \$3.4 out per 1M tokens |
| [`kimi-k2.6-streamlake`](/models/catalog/kimi-k2.6-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (Alibaba)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-alibaba

Kimi K2.7 Code (Alibaba) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-alibaba`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-alibaba",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-alibaba",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-alibaba",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-alibaba` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-alibaba` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-alibaba:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-alibaba:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Alibaba Cloud |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.19 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-baseten`](/models/catalog/kimi-k2.7-code-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-deepinfra`](/models/catalog/kimi-k2.7-code-deepinfra) | DeepInfra | \$0.68 in / \$3.4 out per 1M tokens |
| [`kimi-k2.7-code-gmicloud`](/models/catalog/kimi-k2.7-code-gmicloud) | GMI Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-novita`](/models/catalog/kimi-k2.7-code-novita) | Novita AI | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-streamlake`](/models/catalog/kimi-k2.7-code-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (Baseten)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-baseten

Moonshot's coding-tuned Kimi K2.7 Code (262K context) served by Baseten Model APIs.

**Chat** · Moonshot · served by Baseten

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-baseten`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-baseten",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-baseten",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-baseten",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-baseten` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-baseten` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-baseten:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-baseten:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Baseten |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.16 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-alibaba`](/models/catalog/kimi-k2.7-code-alibaba) | Alibaba Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-deepinfra`](/models/catalog/kimi-k2.7-code-deepinfra) | DeepInfra | \$0.68 in / \$3.4 out per 1M tokens |
| [`kimi-k2.7-code-gmicloud`](/models/catalog/kimi-k2.7-code-gmicloud) | GMI Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-novita`](/models/catalog/kimi-k2.7-code-novita) | Novita AI | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-streamlake`](/models/catalog/kimi-k2.7-code-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-deepinfra

Kimi K2.7 Code (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-deepinfra` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-deepinfra:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.68 in / \$3.4 out per 1M tokens |
| Cached input | \$0.136 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-alibaba`](/models/catalog/kimi-k2.7-code-alibaba) | Alibaba Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-baseten`](/models/catalog/kimi-k2.7-code-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-gmicloud`](/models/catalog/kimi-k2.7-code-gmicloud) | GMI Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-novita`](/models/catalog/kimi-k2.7-code-novita) | Novita AI | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-streamlake`](/models/catalog/kimi-k2.7-code-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (GMI Cloud)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-gmicloud

Kimi K2.7 Code (GMI Cloud) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by GMI Cloud

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-gmicloud`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-gmicloud",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-gmicloud",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-gmicloud",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-gmicloud` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-gmicloud` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-gmicloud:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-gmicloud:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | GMI Cloud |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.19 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-alibaba`](/models/catalog/kimi-k2.7-code-alibaba) | Alibaba Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-baseten`](/models/catalog/kimi-k2.7-code-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-deepinfra`](/models/catalog/kimi-k2.7-code-deepinfra) | DeepInfra | \$0.68 in / \$3.4 out per 1M tokens |
| [`kimi-k2.7-code-novita`](/models/catalog/kimi-k2.7-code-novita) | Novita AI | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-streamlake`](/models/catalog/kimi-k2.7-code-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (Moonshot)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-moonshot

Kimi K2.7 Code (Moonshot) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-moonshot`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-moonshot",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-moonshot",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-moonshot",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-moonshot` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-moonshot` | Claude Code picker id |
| `kimi-k2.7-code` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-moonshot:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-moonshot:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.19 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (Novita)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-novita

Kimi K2.7 Code (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-novita` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-novita:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Novita AI |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.19 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-alibaba`](/models/catalog/kimi-k2.7-code-alibaba) | Alibaba Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-baseten`](/models/catalog/kimi-k2.7-code-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-deepinfra`](/models/catalog/kimi-k2.7-code-deepinfra) | DeepInfra | \$0.68 in / \$3.4 out per 1M tokens |
| [`kimi-k2.7-code-gmicloud`](/models/catalog/kimi-k2.7-code-gmicloud) | GMI Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-streamlake`](/models/catalog/kimi-k2.7-code-streamlake) | StreamLake | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K2.7 Code (StreamLake)
Source: https://docs.aireserve.com/models/catalog/kimi-k2.7-code-streamlake

Kimi K2.7 Code (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k2.7-code-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2.7-code-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k2.7-code-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k2.7-code-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k2.7-code-streamlake` | Canonical gateway id |
| `claude-air-kimi-k2.7-code-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k2.7-code-streamlake:nitro` picks the fastest provider serving these weights and `kimi-k2.7-code-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | StreamLake |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.95 in / \$4 out per 1M tokens |
| Cached input | \$0.19 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) (`kimi-k2.7-code-moonshot`).

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k2.7-code-alibaba`](/models/catalog/kimi-k2.7-code-alibaba) | Alibaba Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-baseten`](/models/catalog/kimi-k2.7-code-baseten) | Baseten | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-deepinfra`](/models/catalog/kimi-k2.7-code-deepinfra) | DeepInfra | \$0.68 in / \$3.4 out per 1M tokens |
| [`kimi-k2.7-code-gmicloud`](/models/catalog/kimi-k2.7-code-gmicloud) | GMI Cloud | \$0.95 in / \$4 out per 1M tokens |
| [`kimi-k2.7-code-novita`](/models/catalog/kimi-k2.7-code-novita) | Novita AI | \$0.95 in / \$4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K3
Source: https://docs.aireserve.com/models/catalog/kimi-k3

Moonshot Kimi K3 2.8T MoE frontier reasoning model (1M context, always-on reasoning, Moonshot API).

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k3` | Canonical gateway id |
| `claude-air-kimi-k3` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k3:nitro` picks the fastest provider serving these weights and `kimi-k3:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`kimi-k3-fireworks`](/models/catalog/kimi-k3-fireworks) | Fireworks AI | \$3 in / \$15 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Kimi K3 (Fireworks)
Source: https://docs.aireserve.com/models/catalog/kimi-k3-fireworks

Kimi K3 (Fireworks) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · served by Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `kimi-k3-fireworks`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3-fireworks",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="kimi-k3-fireworks",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "kimi-k3-fireworks",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `kimi-k3-fireworks` | Canonical gateway id |
| `claude-air-kimi-k3-fireworks` | Claude Code picker id |
| `kimi` | Family default |
| `moonshot` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `kimi-k3-fireworks:nitro` picks the fastest provider serving these weights and `kimi-k3-fireworks:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Fireworks AI |
| Context window | 1,048,576 tokens |
| Max output | 943,718 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Cached input | \$0.3 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Kimi K3](/models/catalog/kimi-k3) (`kimi-k3`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 3.3 70B
Source: https://docs.aireserve.com/models/catalog/llama-3.3-70b

Meta Llama 3.3 70B served by DeepInfra.

**Chat** · Meta · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-3.3-70b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.3-70b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-3.3-70b` | Canonical gateway id |
| `claude-air-llama-3.3-70b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-3.3-70b:nitro` picks the fastest provider serving these weights and `llama-3.3-70b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | DeepInfra |
| Context window | 131,072 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.23 in / \$0.4 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Maverick
Source: https://docs.aireserve.com/models/catalog/llama-4-maverick

General-purpose Llama model.

**Chat** · Meta · served by OpenRouter + Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-maverick`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-maverick",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-maverick",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-maverick",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-maverick` | Canonical gateway id |
| `claude-air-llama-4-maverick` | Claude Code picker id |
| `llama` | Family default |
| `meta` | Family default |
| `maverick` | Nickname |
| `llama-4-maverick-bedrock` | Pinned Amazon Bedrock leg |
| `llama-4-maverick-openrouter` | Pinned OpenRouter leg |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-maverick:nitro` picks the fastest provider serving these weights and `llama-4-maverick:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | OpenRouter + Amazon Bedrock |
| Context window | 1,048,576 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.24 in / \$0.85 out per 1M tokens · from (varies by serving leg) |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-maverick-deepinfra`](/models/catalog/llama-4-maverick-deepinfra) | DeepInfra | \$0.2 in / \$0.8 out per 1M tokens |
| [`llama-4-maverick-novita`](/models/catalog/llama-4-maverick-novita) | Novita AI | \$0.27 in / \$0.85 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Maverick (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/llama-4-maverick-deepinfra

Llama 4 Maverick (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Meta · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-maverick-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-maverick-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-maverick-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-maverick-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-maverick-deepinfra` | Canonical gateway id |
| `claude-air-llama-4-maverick-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-maverick-deepinfra:nitro` picks the fastest provider serving these weights and `llama-4-maverick-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | DeepInfra |
| Context window | 1,048,576 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.2 in / \$0.8 out per 1M tokens |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Llama 4 Maverick](/models/catalog/llama-4-maverick) (`llama-4-maverick`).

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-maverick-novita`](/models/catalog/llama-4-maverick-novita) | Novita AI | \$0.27 in / \$0.85 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Maverick (Novita)
Source: https://docs.aireserve.com/models/catalog/llama-4-maverick-novita

Llama 4 Maverick (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Meta · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-maverick-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-maverick-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-maverick-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-maverick-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-maverick-novita` | Canonical gateway id |
| `claude-air-llama-4-maverick-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-maverick-novita:nitro` picks the fastest provider serving these weights and `llama-4-maverick-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | Novita AI |
| Context window | 1,048,576 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.27 in / \$0.85 out per 1M tokens |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Llama 4 Maverick](/models/catalog/llama-4-maverick) (`llama-4-maverick`).

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-maverick-deepinfra`](/models/catalog/llama-4-maverick-deepinfra) | DeepInfra | \$0.2 in / \$0.8 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Scout
Source: https://docs.aireserve.com/models/catalog/llama-4-scout

Llama 4 Scout on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Meta · served by OpenRouter + Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-scout`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-scout",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-scout",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-scout",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-scout` | Canonical gateway id |
| `claude-air-llama-4-scout` | Claude Code picker id |
| `scout` | Nickname |
| `llama-4-scout-bedrock` | Pinned Amazon Bedrock leg |
| `llama-4-scout-openrouter` | Pinned OpenRouter leg |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-scout:nitro` picks the fastest provider serving these weights and `llama-4-scout:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | OpenRouter + Amazon Bedrock |
| Context window | 1,310,720 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.11 in / \$0.34 out per 1M tokens · from (varies by serving leg) |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-scout-deepinfra`](/models/catalog/llama-4-scout-deepinfra) | DeepInfra | \$0.1 in / \$0.3 out per 1M tokens |
| [`llama-4-scout-novita`](/models/catalog/llama-4-scout-novita) | Novita AI | \$0.18 in / \$0.59 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Scout (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/llama-4-scout-deepinfra

Llama 4 Scout (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Meta · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-scout-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-scout-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-scout-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-scout-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-scout-deepinfra` | Canonical gateway id |
| `claude-air-llama-4-scout-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-scout-deepinfra:nitro` picks the fastest provider serving these weights and `llama-4-scout-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | DeepInfra |
| Context window | 327,680 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.1 in / \$0.3 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Llama 4 Scout](/models/catalog/llama-4-scout) (`llama-4-scout`).

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-scout-novita`](/models/catalog/llama-4-scout-novita) | Novita AI | \$0.18 in / \$0.59 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Llama 4 Scout (Novita)
Source: https://docs.aireserve.com/models/catalog/llama-4-scout-novita

Llama 4 Scout (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Meta · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `llama-4-scout-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-4-scout-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="llama-4-scout-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "llama-4-scout-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `llama-4-scout-novita` | Canonical gateway id |
| `claude-air-llama-4-scout-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `llama-4-scout-novita:nitro` picks the fastest provider serving these weights and `llama-4-scout-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | Novita AI |
| Context window | 131,072 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.18 in / \$0.59 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Llama 4 Scout](/models/catalog/llama-4-scout) (`llama-4-scout`).

| Model id | Served by | Pricing |
| - | - | - |
| [`llama-4-scout-deepinfra`](/models/catalog/llama-4-scout-deepinfra) | DeepInfra | \$0.1 in / \$0.3 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# minimax-h3-max-i2v
Source: https://docs.aireserve.com/models/catalog/minimax-h3-max-i2v

minimax-h3-max-i2v on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image-to-video** · MiniMax · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `minimax-h3-max-i2v`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-h3-max-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-h3-max-i2v",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-h3-max-i2v` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Image-to-video |
| Model maker | MiniMax |
| Served by | fal |
| Pricing | 480p \$0.05/s, 768p \$0.08/s, 1080p \$0.16/s |
| Capabilities | Image input |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# MiniMax M2.5 (StreamLake)
Source: https://docs.aireserve.com/models/catalog/minimax-m2.5-streamlake

MiniMax M2.5 (StreamLake) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · MiniMax · served by StreamLake · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `minimax-m2.5-streamlake`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.5-streamlake",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="minimax-m2.5-streamlake",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "minimax-m2.5-streamlake",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-m2.5-streamlake` | Canonical gateway id |
| `claude-air-minimax-m2.5-streamlake` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `minimax-m2.5-streamlake:nitro` picks the fastest provider serving these weights and `minimax-m2.5-streamlake:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | MiniMax |
| Served by | StreamLake |
| Context window | 204,800 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [MiniMax M2.5 (Tensormesh)](/models/catalog/minimax-m2.5-tensormesh) (`minimax-m2.5-tensormesh`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# MiniMax M2.5 (Tensormesh)
Source: https://docs.aireserve.com/models/catalog/minimax-m2.5-tensormesh

MiniMax M2.5 (Tensormesh) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · MiniMax · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `minimax-m2.5-tensormesh`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.5-tensormesh",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="minimax-m2.5-tensormesh",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "minimax-m2.5-tensormesh",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-m2.5-tensormesh` | Canonical gateway id |
| `claude-air-minimax-m2.5-tensormesh` | Claude Code picker id |
| `minimax-m2.5` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `minimax-m2.5-tensormesh:nitro` picks the fastest provider serving these weights and `minimax-m2.5-tensormesh:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | MiniMax |
| Served by | Tensormesh |
| Context window | 196,608 tokens |
| Max output | 128,000 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# MiniMax M3
Source: https://docs.aireserve.com/models/catalog/minimax-m3

MiniMax M3 (524K context) served by Together AI.

**Chat** · MiniMax · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `minimax-m3`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="minimax-m3",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "minimax-m3",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-m3` | Canonical gateway id |
| `claude-air-minimax-m3` | Claude Code picker id |
| `minimax` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `minimax-m3:nitro` picks the fastest provider serving these weights and `minimax-m3:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | MiniMax |
| Served by | Together AI |
| Context window | 1,048,576 tokens |
| Max output | 512,000 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0.06 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`minimax-m3-deepinfra`](/models/catalog/minimax-m3-deepinfra) | DeepInfra | \$0.28 in / \$1.1 out per 1M tokens |
| [`minimax-m3-novita`](/models/catalog/minimax-m3-novita) | Novita AI | \$0.3 in / \$1.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# MiniMax M3 (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/minimax-m3-deepinfra

MiniMax M3 (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · MiniMax · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `minimax-m3-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m3-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="minimax-m3-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "minimax-m3-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-m3-deepinfra` | Canonical gateway id |
| `claude-air-minimax-m3-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `minimax-m3-deepinfra:nitro` picks the fastest provider serving these weights and `minimax-m3-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | MiniMax |
| Served by | DeepInfra |
| Context window | 524,288 tokens |
| Max output | 512,000 tokens |
| Pricing | \$0.28 in / \$1.1 out per 1M tokens |
| Cached input | \$0.056 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [MiniMax M3](/models/catalog/minimax-m3) (`minimax-m3`).

| Model id | Served by | Pricing |
| - | - | - |
| [`minimax-m3-novita`](/models/catalog/minimax-m3-novita) | Novita AI | \$0.3 in / \$1.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# MiniMax M3 (Novita)
Source: https://docs.aireserve.com/models/catalog/minimax-m3-novita

MiniMax M3 (Novita) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · MiniMax · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `minimax-m3-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m3-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="minimax-m3-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "minimax-m3-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `minimax-m3-novita` | Canonical gateway id |
| `claude-air-minimax-m3-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `minimax-m3-novita:nitro` picks the fastest provider serving these weights and `minimax-m3-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | MiniMax |
| Served by | Novita AI |
| Context window | 1,000,000 tokens |
| Max output | 512,000 tokens |
| Pricing | \$0.3 in / \$1.2 out per 1M tokens |
| Cached input | \$0.06 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [MiniMax M3](/models/catalog/minimax-m3) (`minimax-m3`).

| Model id | Served by | Pricing |
| - | - | - |
| [`minimax-m3-deepinfra`](/models/catalog/minimax-m3-deepinfra) | DeepInfra | \$0.28 in / \$1.1 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Ministral 14B
Source: https://docs.aireserve.com/models/catalog/ministral-14b

Ministral 14B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `ministral-14b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ministral-14b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="ministral-14b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "ministral-14b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `ministral-14b` | Canonical gateway id |
| `claude-air-ministral-14b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `ministral-14b:nitro` picks the fastest provider serving these weights and `ministral-14b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 262,144 tokens |
| Max output | 209,715 tokens |
| Pricing | \$0.2 in / \$0.2 out per 1M tokens |
| Cached input | \$0.02 per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Ministral 3B
Source: https://docs.aireserve.com/models/catalog/ministral-3b

Ministral 3B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `ministral-3b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ministral-3b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="ministral-3b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "ministral-3b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `ministral-3b` | Canonical gateway id |
| `claude-air-ministral-3b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `ministral-3b:nitro` picks the fastest provider serving these weights and `ministral-3b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 131,072 tokens |
| Max output | 104,857 tokens |
| Pricing | \$0.1 in / \$0.1 out per 1M tokens |
| Cached input | \$0.01 per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Ministral 8B
Source: https://docs.aireserve.com/models/catalog/ministral-8b

Ministral 8B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `ministral-8b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ministral-8b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="ministral-8b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "ministral-8b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `ministral-8b` | Canonical gateway id |
| `claude-air-ministral-8b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `ministral-8b:nitro` picks the fastest provider serving these weights and `ministral-8b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 262,144 tokens |
| Max output | 209,715 tokens |
| Pricing | \$0.15 in / \$0.15 out per 1M tokens |
| Cached input | \$0.015 per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Mistral Large
Source: https://docs.aireserve.com/models/catalog/mistral-large

General-purpose Mistral model.

**Chat** · Mistral · served by OpenRouter + Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `mistral-large`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="mistral-large",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "mistral-large",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `mistral-large` | Canonical gateway id |
| `claude-air-mistral-large` | Claude Code picker id |
| `mistral` | Family default |
| `mistral-large-bedrock` | Pinned Amazon Bedrock leg |
| `mistral-large-openrouter` | Pinned OpenRouter leg |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `mistral-large:nitro` picks the fastest provider serving these weights and `mistral-large:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | OpenRouter + Amazon Bedrock |
| Context window | 128,000 tokens |
| Max output | 102,400 tokens |
| Pricing | \$0.5 in / \$1.5 out per 1M tokens · from (varies by serving leg) |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Mistral Medium 3.5
Source: https://docs.aireserve.com/models/catalog/mistral-medium-3.5

Mistral Medium 3.5 reasoning model on La Plateforme.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `mistral-medium-3.5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-medium-3.5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="mistral-medium-3.5",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "mistral-medium-3.5",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `mistral-medium-3.5` | Canonical gateway id |
| `claude-air-mistral-medium-3.5` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `mistral-medium-3.5:nitro` picks the fastest provider serving these weights and `mistral-medium-3.5:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 262,144 tokens |
| Max output | 209,715 tokens |
| Pricing | \$1.5 in / \$7.5 out per 1M tokens |
| Cached input | \$0.15 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Mistral Small 4
Source: https://docs.aireserve.com/models/catalog/mistral-small-4

Mistral Small 4 hybrid-reasoning multimodal model on La Plateforme.

**Chat** · Mistral

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `mistral-small-4`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-4",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="mistral-small-4",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "mistral-small-4",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `mistral-small-4` | Canonical gateway id |
| `claude-air-mistral-small-4` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `mistral-small-4:nitro` picks the fastest provider serving these weights and `mistral-small-4:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Mistral |
| Served by | Mistral |
| Context window | 262,144 tokens |
| Max output | 209,715 tokens |
| Pricing | \$0.15 in / \$0.6 out per 1M tokens |
| Cached input | \$0.015 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Moonshot v1 128K
Source: https://docs.aireserve.com/models/catalog/moonshot-v1-128k

Moonshot v1 128K on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `moonshot-v1-128k`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshot-v1-128k",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="moonshot-v1-128k",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "moonshot-v1-128k",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `moonshot-v1-128k` | Canonical gateway id |
| `claude-air-moonshot-v1-128k` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `moonshot-v1-128k:nitro` picks the fastest provider serving these weights and `moonshot-v1-128k:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Pricing | \$2 in / \$5 out per 1M tokens |
| Capabilities | Streaming, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Moonshot v1 32K
Source: https://docs.aireserve.com/models/catalog/moonshot-v1-32k

Moonshot v1 32K on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `moonshot-v1-32k`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshot-v1-32k",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="moonshot-v1-32k",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "moonshot-v1-32k",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `moonshot-v1-32k` | Canonical gateway id |
| `claude-air-moonshot-v1-32k` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `moonshot-v1-32k:nitro` picks the fastest provider serving these weights and `moonshot-v1-32k:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Pricing | \$1 in / \$3 out per 1M tokens |
| Capabilities | Streaming, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Moonshot v1 8K
Source: https://docs.aireserve.com/models/catalog/moonshot-v1-8k

Moonshot v1 8K on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Moonshot · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in, Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `moonshot-v1-8k`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshot-v1-8k",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="moonshot-v1-8k",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "moonshot-v1-8k",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `moonshot-v1-8k` | Canonical gateway id |
| `claude-air-moonshot-v1-8k` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `moonshot-v1-8k:nitro` picks the fastest provider serving these weights and `moonshot-v1-8k:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Moonshot |
| Served by | Moonshot |
| Pricing | \$0.2 in / \$2 out per 1M tokens |
| Capabilities | Streaming, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in, Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Muse Glimmer 30B
Source: https://docs.aireserve.com/models/catalog/muse-glimmer

Meta Muse Glimmer 30B agentic model (131K context) served by Together AI.

**Chat** · Meta · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `muse-glimmer`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-glimmer",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="muse-glimmer",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "muse-glimmer",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `muse-glimmer` | Canonical gateway id |
| `claude-air-muse-glimmer` | Claude Code picker id |
| `glimmer` | Nickname |
| `muse` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `muse-glimmer:nitro` picks the fastest provider serving these weights and `muse-glimmer:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Meta |
| Served by | Together AI |
| Context window | 131,072 tokens |
| Max output | 16,384 tokens |
| Pricing | \$0.35 in / \$1.5 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# nano-banana-2
Source: https://docs.aireserve.com/models/catalog/nano-banana-2

nano-banana-2 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Google · served by fal

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `nano-banana-2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="nano-banana-2",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "nano-banana-2",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nano-banana-2` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Google |
| Served by | fal |
| Pricing | \$0.08 / image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# nano-banana-2-edit
Source: https://docs.aireserve.com/models/catalog/nano-banana-2-edit

Accepts up to 8 input images.

**Image editing** · Google · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `nano-banana-2-edit`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nano-banana-2-edit` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | Google |
| Served by | fal |
| Pricing | \$0.08 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3 Nano
Source: https://docs.aireserve.com/models/catalog/nemotron-3-nano

Nemotron 3 Nano on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · NVIDIA · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3-nano`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-nano",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3-nano",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3-nano",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3-nano` | Canonical gateway id |
| `claude-air-nemotron-3-nano` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3-nano:nitro` picks the fastest provider serving these weights and `nemotron-3-nano:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.05 in / \$0.2 out per 1M tokens |
| Cached input | \$0.025 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`nemotron-3-nano-deepinfra`](/models/catalog/nemotron-3-nano-deepinfra) | DeepInfra | \$0.05 in / \$0.2 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3 Nano (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/nemotron-3-nano-deepinfra

Nemotron 3 Nano (DeepInfra) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · NVIDIA · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3-nano-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-nano-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3-nano-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3-nano-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3-nano-deepinfra` | Canonical gateway id |
| `claude-air-nemotron-3-nano-deepinfra` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3-nano-deepinfra:nitro` picks the fastest provider serving these weights and `nemotron-3-nano-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.05 in / \$0.2 out per 1M tokens |
| Cached input | \$0.025 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Nemotron 3 Nano](/models/catalog/nemotron-3-nano) (`nemotron-3-nano`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3 Super
Source: https://docs.aireserve.com/models/catalog/nemotron-3-super

NVIDIA Nemotron 3 Super reasoning model, served by DeepInfra (256K context).

**Chat** · NVIDIA · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3-super`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-super",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3-super",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3-super",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3-super` | Canonical gateway id |
| `claude-air-nemotron-3-super` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3-super:nitro` picks the fastest provider serving these weights and `nemotron-3-super:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.085 in / \$0.4 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3 Ultra
Source: https://docs.aireserve.com/models/catalog/nemotron-3-ultra

NVIDIA Nemotron 3 Ultra 550B frontier reasoning model, served by DeepInfra (256K context).

**Chat** · NVIDIA · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3-ultra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-ultra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3-ultra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3-ultra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3-ultra` | Canonical gateway id |
| `claude-air-nemotron-3-ultra` | Claude Code picker id |
| `nemotron-3-ultra-together` | Retired id (resolves here) |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3-ultra:nitro` picks the fastest provider serving these weights and `nemotron-3-ultra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | DeepInfra |
| Context window | 262,144 tokens |
| Max output | 182,520 tokens |
| Pricing | \$0.5 in / \$2.2 out per 1M tokens |
| Cached input | \$0.1 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`nemotron-3-ultra-nvidia`](/models/catalog/nemotron-3-ultra-nvidia) | NVIDIA NIM | \$0.6 in / \$2.4 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3 Ultra (NVIDIA)
Source: https://docs.aireserve.com/models/catalog/nemotron-3-ultra-nvidia

Nemotron 3 Ultra (NVIDIA) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · NVIDIA · served by NVIDIA NIM

> [!WARNING]
>
> **Requires an organization opt-in:** Training-consent opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3-ultra-nvidia`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-ultra-nvidia",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3-ultra-nvidia",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3-ultra-nvidia",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3-ultra-nvidia` | Canonical gateway id |
| `claude-air-nemotron-3-ultra-nvidia` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3-ultra-nvidia:nitro` picks the fastest provider serving these weights and `nemotron-3-ultra-nvidia:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | NVIDIA NIM |
| Context window | 1,000,000 tokens |
| Max output | 182,520 tokens |
| Pricing | \$0.6 in / \$2.4 out per 1M tokens |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |
| Opt-ins | Training-consent opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Nemotron 3 Ultra](/models/catalog/nemotron-3-ultra) (`nemotron-3-ultra`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nemotron 3.5 Lightning
Source: https://docs.aireserve.com/models/catalog/nemotron-3.5-lightning

NVIDIA Nemotron 3.5 Lightning 30B-A3B agent-execution model (1M context), served by DeepInfra.

**Chat** · NVIDIA · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nemotron-3.5-lightning`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3.5-lightning",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nemotron-3.5-lightning",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nemotron-3.5-lightning",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nemotron-3.5-lightning` | Canonical gateway id |
| `claude-air-nemotron-3.5-lightning` | Claude Code picker id |
| `lightning` | Nickname |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nemotron-3.5-lightning:nitro` picks the fastest provider serving these weights and `nemotron-3.5-lightning:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | NVIDIA |
| Served by | DeepInfra |
| Context window | 1,000,000 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.06 in / \$0.16 out per 1M tokens |
| Cached input | \$0.03 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nova 2 Lite
Source: https://docs.aireserve.com/models/catalog/nova-2-lite

Amazon Nova 2 Lite reasoning model on AWS Bedrock.

**Chat** · Amazon · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nova-2-lite`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nova-2-lite",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nova-2-lite",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nova-2-lite",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nova-2-lite` | Canonical gateway id |
| `amazon.nova-2-lite-v1:0` | AWS Bedrock id |
| `claude-air-nova-2-lite` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nova-2-lite:nitro` picks the fastest provider serving these weights and `nova-2-lite:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Amazon |
| Served by | Amazon Bedrock |
| Context window | 1,000,000 tokens |
| Max output | 65,535 tokens |
| Pricing | \$0.3 in / \$2.5 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nova Lite
Source: https://docs.aireserve.com/models/catalog/nova-lite

Nova Lite on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Amazon · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nova-lite`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nova-lite",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nova-lite",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nova-lite",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nova-lite` | Canonical gateway id |
| `amazon.nova-lite-v1:0` | AWS Bedrock id |
| `claude-air-nova-lite` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nova-lite:nitro` picks the fastest provider serving these weights and `nova-lite:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Amazon |
| Served by | Amazon Bedrock |
| Context window | 300,000 tokens |
| Max output | 5,120 tokens |
| Pricing | \$0.06 in / \$0.24 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nova Micro
Source: https://docs.aireserve.com/models/catalog/nova-micro

Nova Micro on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Amazon · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nova-micro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nova-micro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nova-micro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nova-micro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nova-micro` | Canonical gateway id |
| `amazon.nova-micro-v1:0` | AWS Bedrock id |
| `claude-air-nova-micro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nova-micro:nitro` picks the fastest provider serving these weights and `nova-micro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Amazon |
| Served by | Amazon Bedrock |
| Context window | 128,000 tokens |
| Max output | 5,120 tokens |
| Pricing | \$0.035 in / \$0.14 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Nova Pro
Source: https://docs.aireserve.com/models/catalog/nova-pro

General-purpose Amazon Nova model on AWS Bedrock.

**Chat** · Amazon · served by Amazon Bedrock

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `nova-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nova-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="nova-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "nova-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `nova-pro` | Canonical gateway id |
| `amazon.nova-pro-v1:0` | AWS Bedrock id |
| `claude-air-nova-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `nova-pro:nitro` picks the fastest provider serving these weights and `nova-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Amazon |
| Served by | Amazon Bedrock |
| Context window | 300,000 tokens |
| Max output | 5,120 tokens |
| Pricing | \$0.8 in / \$3.2 out per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3 Coder Next
Source: https://docs.aireserve.com/models/catalog/qwen-3-coder-next

Cost-efficient coding-specialized Qwen model on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3-coder-next`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3-coder-next",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3-coder-next",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3-coder-next",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3-coder-next` | Canonical gateway id |
| `claude-air-qwen-3-coder-next` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3-coder-next:nitro` picks the fastest provider serving these weights and `qwen-3-coder-next:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.12 in / \$0.8 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3 Coder Plus
Source: https://docs.aireserve.com/models/catalog/qwen-3-coder-plus

Coding-specialized Qwen model (1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3-coder-plus`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3-coder-plus",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3-coder-plus",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3-coder-plus",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3-coder-plus` | Canonical gateway id |
| `claude-air-qwen-3-coder-plus` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3-coder-plus:nitro` picks the fastest provider serving these weights and `qwen-3-coder-plus:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.65 in / \$3.25 out per 1M tokens |
| Cached input | \$0.163 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3 VL 235B
Source: https://docs.aireserve.com/models/catalog/qwen-3-vl-235b-a22b

Vision-language Qwen model on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3-vl-235b-a22b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3-vl-235b-a22b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3-vl-235b-a22b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3-vl-235b-a22b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3-vl-235b-a22b` | Canonical gateway id |
| `claude-air-qwen-3-vl-235b-a22b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3-vl-235b-a22b:nitro` picks the fastest provider serving these weights and `qwen-3-vl-235b-a22b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 262,144 tokens |
| Max output | 32,768 tokens |
| Pricing | \$0.21 in / \$1.9 out per 1M tokens |
| Cached input | \$0.052 per 1M tokens |
| Capabilities | Streaming, Image input, PDF / file input, Tool use, Prompt caching |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.5 397B
Source: https://docs.aireserve.com/models/catalog/qwen-3.5-397b

Qwen 3.5 397B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Qwen · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.5-397b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.5-397b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.5-397b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.5-397b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.5-397b` | Canonical gateway id |
| `claude-air-qwen-3.5-397b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.5-397b:nitro` picks the fastest provider serving these weights and `qwen-3.5-397b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Tensormesh |
| Context window | 262,144 tokens |
| Max output | 235,929 tokens |
| Pricing | \$0.6 in / \$3.6 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.6 27B
Source: https://docs.aireserve.com/models/catalog/qwen-3.6-27b

Qwen 3.6 27B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Qwen · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.6-27b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.6-27b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.6-27b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.6-27b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.6-27b` | Canonical gateway id |
| `claude-air-qwen-3.6-27b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.6-27b:nitro` picks the fastest provider serving these weights and `qwen-3.6-27b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Tensormesh |
| Context window | 262,144 tokens |
| Max output | 81,920 tokens |
| Pricing | \$0.32 in / \$3.2 out per 1M tokens |
| Capabilities | Streaming, Tool use |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.6 Flash
Source: https://docs.aireserve.com/models/catalog/qwen-3.6-flash

Fast Qwen flash model (1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.6-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.6-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.6-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.6-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.6-flash` | Canonical gateway id |
| `claude-air-qwen-3.6-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.6-flash:nitro` picks the fastest provider serving these weights and `qwen-3.6-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.188 in / \$1.13 out per 1M tokens |
| Cached input | \$0.047 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.6 Plus
Source: https://docs.aireserve.com/models/catalog/qwen-3.6-plus

Balanced Qwen model (1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.6-plus`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.6-plus",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.6-plus",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.6-plus",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.6-plus` | Canonical gateway id |
| `claude-air-qwen-3.6-plus` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.6-plus:nitro` picks the fastest provider serving these weights and `qwen-3.6-plus:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.325 in / \$1.95 out per 1M tokens |
| Cached input | \$0.081 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.7 Flash
Source: https://docs.aireserve.com/models/catalog/qwen-3.7-flash

Fast Qwen flash model (1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.7-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.7-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.7-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.7-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.7-flash` | Canonical gateway id |
| `claude-air-qwen-3.7-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.7-flash:nitro` picks the fastest provider serving these weights and `qwen-3.7-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.03 in / \$0.13 out per 1M tokens |
| Cached input | \$0.0075 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.7 Max
Source: https://docs.aireserve.com/models/catalog/qwen-3.7-max

Flagship Qwen model served by Together AI.

**Chat** · Qwen · served by Together AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.7-max`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.7-max",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.7-max",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.7-max",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.7-max` | Canonical gateway id |
| `claude-air-qwen-3.7-max` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.7-max:nitro` picks the fastest provider serving these weights and `qwen-3.7-max:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Together AI |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.25 in / \$3.75 out per 1M tokens |
| Capabilities | Streaming, Tool use, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`qwen-3.7-max-alibaba`](/models/catalog/qwen-3.7-max-alibaba) | Alibaba Cloud | \$1.48 in / \$4.42 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.7 Max (Alibaba)
Source: https://docs.aireserve.com/models/catalog/qwen-3.7-max-alibaba

Qwen 3.7 Max (Alibaba) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.7-max-alibaba`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.7-max-alibaba",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.7-max-alibaba",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.7-max-alibaba",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.7-max-alibaba` | Canonical gateway id |
| `claude-air-qwen-3.7-max-alibaba` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.7-max-alibaba:nitro` picks the fastest provider serving these weights and `qwen-3.7-max-alibaba:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.48 in / \$4.42 out per 1M tokens |
| Cached input | \$0.295 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Qwen 3.7 Max](/models/catalog/qwen-3.7-max) (`qwen-3.7-max`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.7 Plus
Source: https://docs.aireserve.com/models/catalog/qwen-3.7-plus

Fast Qwen model served by Fireworks AI.

**Chat** · Qwen · served by Fireworks AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.7-plus`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.7-plus",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.7-plus",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.7-plus",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.7-plus` | Canonical gateway id |
| `claude-air-qwen-3.7-plus` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.7-plus:nitro` picks the fastest provider serving these weights and `qwen-3.7-plus:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Fireworks AI |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.4 in / \$1.6 out per 1M tokens |
| Cached input | \$0.08 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`qwen-3.7-plus-alibaba`](/models/catalog/qwen-3.7-plus-alibaba) | Alibaba Cloud | \$0.32 in / \$1.28 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.7 Plus (Alibaba)
Source: https://docs.aireserve.com/models/catalog/qwen-3.7-plus-alibaba

Qwen 3.7 Plus (Alibaba) on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.7-plus-alibaba`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.7-plus-alibaba",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.7-plus-alibaba",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.7-plus-alibaba",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.7-plus-alibaba` | Canonical gateway id |
| `claude-air-qwen-3.7-plus-alibaba` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.7-plus-alibaba:nitro` picks the fastest provider serving these weights and `qwen-3.7-plus-alibaba:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.32 in / \$1.28 out per 1M tokens |
| Cached input | \$0.064 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Qwen 3.7 Plus](/models/catalog/qwen-3.7-plus) (`qwen-3.7-plus`).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.8 Flash
Source: https://docs.aireserve.com/models/catalog/qwen-3.8-flash

Fast Qwen flash model (1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.8-flash`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.8-flash",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.8-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.8-flash",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.8-flash` | Canonical gateway id |
| `claude-air-qwen-3.8-flash` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.8-flash:nitro` picks the fastest provider serving these weights and `qwen-3.8-flash:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$0.15 in / \$0.47 out per 1M tokens |
| Cached input | \$0.037 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.8 Max
Source: https://docs.aireserve.com/models/catalog/qwen-3.8-max

Qwen 3.8 Max flagship (2.4T MoE, 1M context) on Alibaba's official Model Studio API.

**Chat** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.8-max`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.8-max",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.8-max",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.8-max",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.8-max` | Canonical gateway id |
| `claude-air-qwen-3.8-max` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.8-max:nitro` picks the fastest provider serving these weights and `qwen-3.8-max:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$2 in / \$6 out per 1M tokens |
| Cached input | \$0.25 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`qwen-3.8-max-deepinfra`](/models/catalog/qwen-3.8-max-deepinfra) | DeepInfra | \$1.65 in / \$4.95 out per 1M tokens |
| [`qwen-3.8-max-novita`](/models/catalog/qwen-3.8-max-novita) | Novita AI | \$2 in / \$6 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.8 Max (DeepInfra)
Source: https://docs.aireserve.com/models/catalog/qwen-3.8-max-deepinfra

Qwen 3.8 Max served by DeepInfra (256K context serving window).

**Chat** · Qwen · served by DeepInfra

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.8-max-deepinfra`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.8-max-deepinfra",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.8-max-deepinfra",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.8-max-deepinfra",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.8-max-deepinfra` | Canonical gateway id |
| `claude-air-qwen-3.8-max-deepinfra` | Claude Code picker id |
| `alibaba` | Family default |
| `qwen` | Family default |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.8-max-deepinfra:nitro` picks the fastest provider serving these weights and `qwen-3.8-max-deepinfra:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | DeepInfra |
| Context window | 256,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$1.65 in / \$4.95 out per 1M tokens |
| Cached input | \$0.206 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Qwen 3.8 Max](/models/catalog/qwen-3.8-max) (`qwen-3.8-max`).

| Model id | Served by | Pricing |
| - | - | - |
| [`qwen-3.8-max-novita`](/models/catalog/qwen-3.8-max-novita) | Novita AI | \$2 in / \$6 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen 3.8 Max (Novita)
Source: https://docs.aireserve.com/models/catalog/qwen-3.8-max-novita

Qwen 3.8 Max served by Novita AI (full 1M context).

**Chat** · Qwen · served by Novita AI

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen-3.8-max-novita`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-3.8-max-novita",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen-3.8-max-novita",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen-3.8-max-novita",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-3.8-max-novita` | Canonical gateway id |
| `claude-air-qwen-3.8-max-novita` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen-3.8-max-novita:nitro` picks the fastest provider serving these weights and `qwen-3.8-max-novita:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Novita AI |
| Context window | 1,000,000 tokens |
| Max output | 131,072 tokens |
| Pricing | \$2 in / \$6 out per 1M tokens |
| Cached input | \$0.25 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching, 1M-token context |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

This id pins a specific serving route of [Qwen 3.8 Max](/models/catalog/qwen-3.8-max) (`qwen-3.8-max`).

| Model id | Served by | Pricing |
| - | - | - |
| [`qwen-3.8-max-deepinfra`](/models/catalog/qwen-3.8-max-deepinfra) | DeepInfra | \$1.65 in / \$4.95 out per 1M tokens |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# qwen-image-2-pro-edit
Source: https://docs.aireserve.com/models/catalog/qwen-image-2-pro-edit

Accepts up to 3 input images.

**Image editing** · Qwen · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `qwen-image-2-pro-edit`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2-pro-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2-pro-edit",
    "prompt": "Replace the sky with a dramatic sunset",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-image-2-pro-edit` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | Qwen |
| Served by | fal |
| Pricing | \$0.075 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# qwen-image-3.0
Source: https://docs.aireserve.com/models/catalog/qwen-image-3.0

qwen-image-3.0 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `qwen-image-3.0`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-3.0",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="qwen-image-3.0",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "qwen-image-3.0",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-image-3.0` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Pricing | \$0.03 / image |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# qwen-image-3.0-pro
Source: https://docs.aireserve.com/models/catalog/qwen-image-3.0-pro

qwen-image-3.0-pro on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · Qwen · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `qwen-image-3.0-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-3.0-pro",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="qwen-image-3.0-pro",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "qwen-image-3.0-pro",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen-image-3.0-pro` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | Qwen |
| Served by | Alibaba Cloud |
| Pricing | \$0.075 / image |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Qwen3 Coder 480B
Source: https://docs.aireserve.com/models/catalog/qwen3-coder-480b

Qwen3 Coder 480B on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Qwen · served by Tensormesh

> [!WARNING]
>
> **Requires an organization opt-in:** Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `qwen3-coder-480b`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-coder-480b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="qwen3-coder-480b",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "qwen3-coder-480b",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `qwen3-coder-480b` | Canonical gateway id |
| `claude-air-qwen3-coder-480b` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `qwen3-coder-480b:nitro` picks the fastest provider serving these weights and `qwen3-coder-480b:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Qwen |
| Served by | Tensormesh |
| Context window | 262,144 tokens |
| Max output | 65,536 tokens |
| Pricing | \$0.45 in / \$1.8 out per 1M tokens |
| Cached input | \$0 per 1M tokens |
| Capabilities | Streaming, Tool use, Prompt caching |
| Hosting | United States |
| Opt-ins | Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# ElevenLabs Scribe v2
Source: https://docs.aireserve.com/models/catalog/scribe-v2

ElevenLabs Scribe v2 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Speech-to-text** · ElevenLabs · served by fal

## Call it

Endpoint: `POST /v1/audio/transcriptions` — set `model` to `scribe-v2`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -F model="scribe-v2" \
  -F file=@recording.mp3
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

with open("recording.mp3", "rb") as audio:
    res = client.audio.transcriptions.create(
        model="scribe-v2",
        file=audio,
    )
print(res.text)
```

Full request and response reference: [Text-to-speech guide](/capabilities/text-to-speech).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `scribe-v2` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Audio & voice — Speech-to-text |
| Model maker | ElevenLabs |
| Served by | fal |
| Pricing | \$0.008 / minute |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.0
Source: https://docs.aireserve.com/models/catalog/seedance-2.0

seedance-2.0 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Text-to-video** · ByteDance · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.0`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.0` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | ByteDance |
| Served by | fal |
| Pricing | 480p \$0.141/s, 720p \$0.303/s, 1080p \$0.682/s, 4k \$1.56/s |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`seedance-2.0-bytedance`](/models/catalog/seedance-2.0-bytedance) | ByteDance Ark | 480p \$0.067/s, 720p \$0.151/s, 1080p \$0.374/s, 4k \$0.778/s |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.0-bytedance
Source: https://docs.aireserve.com/models/catalog/seedance-2.0-bytedance

Text-to-video, first/last-frame image-to-video and reference-to-video on one model id.

**Text-to-video** · ByteDance · served by ByteDance Ark · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.0-bytedance`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-bytedance",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-bytedance",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.0-bytedance` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | ByteDance |
| Served by | ByteDance Ark |
| Pricing | 480p \$0.067/s, 720p \$0.151/s, 1080p \$0.374/s, 4k \$0.778/s |
| Capabilities | Image input, Reference media |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`seedance-2.0`](/models/catalog/seedance-2.0) | fal | 480p \$0.141/s, 720p \$0.303/s, 1080p \$0.682/s, 4k \$1.56/s |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.0-fast
Source: https://docs.aireserve.com/models/catalog/seedance-2.0-fast

Text-to-video, first/last-frame image-to-video and reference-to-video on one model id.

**Text-to-video** · ByteDance · served by ByteDance Ark · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.0-fast`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-fast",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-fast",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.0-fast` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | ByteDance |
| Served by | ByteDance Ark |
| Pricing | 480p \$0.054/s, 720p \$0.121/s |
| Capabilities | Image input, Reference media |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.0-mini
Source: https://docs.aireserve.com/models/catalog/seedance-2.0-mini

Text-to-video, first/last-frame image-to-video and reference-to-video on one model id.

**Text-to-video** · ByteDance · served by ByteDance Ark · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.0-mini`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-mini",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-mini",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.0-mini` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | ByteDance |
| Served by | ByteDance Ark |
| Pricing | 480p \$0.034/s, 720p \$0.076/s |
| Capabilities | Image input, Reference media |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.0-mini-reference
Source: https://docs.aireserve.com/models/catalog/seedance-2.0-mini-reference

seedance-2.0-mini-reference on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Reference-to-video** · ByteDance · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.0-mini-reference`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-mini-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-mini-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.0-mini-reference` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Reference-to-video |
| Model maker | ByteDance |
| Served by | fal |
| Pricing | 480p \$0.072/s, 720p \$0.155/s |
| Capabilities | Reference media |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.5
Source: https://docs.aireserve.com/models/catalog/seedance-2.5

Text-to-video, first/last-frame image-to-video and reference-to-video on one model id.

**Text-to-video** · ByteDance · served by ByteDance Ark · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.5`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.5` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | ByteDance |
| Served by | ByteDance Ark |
| Pricing | 480p \$0.103/s, 720p \$0.231/s, 1080p \$0.569/s |
| Capabilities | Image input, Reference media |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# seedance-2.5-reference
Source: https://docs.aireserve.com/models/catalog/seedance-2.5-reference

seedance-2.5-reference on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Reference-to-video** · ByteDance · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `seedance-2.5-reference`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedance-2.5-reference` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Reference-to-video |
| Model maker | ByteDance |
| Served by | fal |
| Pricing | 480p \$0.221/s, 720p \$0.473/s, 1080p \$1.16/s |
| Capabilities | Reference media |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Seedream 5
Source: https://docs.aireserve.com/models/catalog/seedream-5

Seedream 5 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image generation** · ByteDance · served by ByteDance Ark · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/images/generations` — set `model` to `seedream-5`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/images/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5",
    "prompt": "A watercolor painting of a fox in a snowy forest",
    "n": 1,
    "size": "1024x1024"
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.images.generate(
    model="seedream-5",
    prompt="A watercolor painting of a fox in a snowy forest",
    n=1,
    size="1024x1024",
)
print(res.data[0].url)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.images.generate({
  model: "seedream-5",
  prompt: "A watercolor painting of a fox in a snowy forest",
  n: 1,
  size: "1024x1024",
});
console.log(res.data[0].url);
```

Full request and response reference: [Image generation guide](/capabilities/image-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `seedream-5` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image generation |
| Model maker | ByteDance |
| Served by | ByteDance Ark |
| Pricing | \$0.09 / image |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Sonar
Source: https://docs.aireserve.com/models/catalog/sonar

Sonar on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Chat** · Perplexity

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `sonar`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sonar",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="sonar",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "sonar",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `sonar` | Canonical gateway id |
| `claude-air-sonar` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `sonar:nitro` picks the fastest provider serving these weights and `sonar:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Perplexity |
| Served by | Perplexity |
| Context window | 127,072 tokens |
| Max output | 114,364 tokens |
| Pricing | \$1 in / \$1 out per 1M tokens |
| Capabilities | Streaming |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Sonar Deep Research
Source: https://docs.aireserve.com/models/catalog/sonar-deep-research

Perplexity deep research model.

**Chat** · Perplexity

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `sonar-deep-research`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sonar-deep-research",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="sonar-deep-research",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "sonar-deep-research",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `sonar-deep-research` | Canonical gateway id |
| `claude-air-sonar-deep-research` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `sonar-deep-research:nitro` picks the fastest provider serving these weights and `sonar-deep-research:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Perplexity |
| Served by | Perplexity |
| Context window | 128,000 tokens |
| Max output | 115,200 tokens |
| Pricing | \$2 in / \$8 out per 1M tokens |
| Capabilities | Streaming |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Sonar Pro
Source: https://docs.aireserve.com/models/catalog/sonar-pro

Perplexity search model with standard reasoning capability.

**Chat** · Perplexity

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `sonar-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sonar-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="sonar-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "sonar-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `sonar-pro` | Canonical gateway id |
| `claude-air-sonar-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `sonar-pro:nitro` picks the fastest provider serving these weights and `sonar-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Perplexity |
| Served by | Perplexity |
| Context window | 200,000 tokens |
| Max output | 8,000 tokens |
| Pricing | \$3 in / \$15 out per 1M tokens |
| Capabilities | Streaming |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Sonar Reasoning Pro
Source: https://docs.aireserve.com/models/catalog/sonar-reasoning-pro

Perplexity model explicitly optimized for reasoning.

**Chat** · Perplexity

## Call it

Endpoint: `POST /v1/chat/completions` — set `model` to `sonar-reasoning-pro`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "sonar-reasoning-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.chat.completions.create(
    model="sonar-reasoning-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(res.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.chat.completions.create({
  model: "sonar-reasoning-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(res.choices[0].message.content);
```

Full request and response reference: [Quickstart](/getting-started/quickstart).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `sonar-reasoning-pro` | Canonical gateway id |
| `claude-air-sonar-reasoning-pro` | Claude Code picker id |

Every alias resolves at the gateway and is disclosed back as `requestedModelAlias` in usage metadata. Routing variants also apply: `sonar-reasoning-pro:nitro` picks the fastest provider serving these weights and `sonar-reasoning-pro:floor` the cheapest ([details](/models#provider-routing-variants)).

## Specs

| Spec | Detail |
| - | - |
| Modality | Text & chat — Chat |
| Model maker | Perplexity |
| Served by | Perplexity |
| Context window | 128,000 tokens |
| Max output | 115,200 tokens |
| Pricing | \$2 in / \$8 out per 1M tokens |
| Capabilities | Streaming |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Text Embedding 3 Large
Source: https://docs.aireserve.com/models/catalog/text-embedding-3-large

Text Embedding 3 Large on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Embeddings** · OpenAI

## Call it

Endpoint: `POST /v1/embeddings` — set `model` to `text-embedding-3-large`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/embeddings \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "text-embedding-3-large", "input": "The quick brown fox"}'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.embeddings.create(
    model="text-embedding-3-large",
    input="The quick brown fox",
)
print(len(res.data[0].embedding))
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.embeddings.create({
  model: "text-embedding-3-large",
  input: "The quick brown fox",
});
console.log(res.data[0].embedding.length);
```

Full request and response reference: [API reference](/api-reference).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `text-embedding-3-large` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Embedding — Embeddings |
| Model maker | OpenAI |
| Served by | OpenAI |
| Pricing | — |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Text Embedding 3 Small
Source: https://docs.aireserve.com/models/catalog/text-embedding-3-small

Text Embedding 3 Small on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Embeddings** · OpenAI

## Call it

Endpoint: `POST /v1/embeddings` — set `model` to `text-embedding-3-small`.

```bash cURL theme={"dark"}
curl https://api.aireserve.com/v1/embeddings \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "text-embedding-3-small", "input": "The quick brown fox"}'
```

```python Python theme={"dark"}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aireserve.com/v1",
    api_key=os.environ["AIRESERVE_API_KEY"],
)

res = client.embeddings.create(
    model="text-embedding-3-small",
    input="The quick brown fox",
)
print(len(res.data[0].embedding))
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.aireserve.com/v1",
  apiKey: process.env.AIRESERVE_API_KEY,
});

const res = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: "The quick brown fox",
});
console.log(res.data[0].embedding.length);
```

Full request and response reference: [API reference](/api-reference).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `text-embedding-3-small` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Embedding — Embeddings |
| Model maker | OpenAI |
| Served by | OpenAI |
| Pricing | — |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# topaz-image-upscale
Source: https://docs.aireserve.com/models/catalog/topaz-image-upscale

Accepts up to 1 input image.

**Image editing** · Topaz Labs · served by fal

## Call it

Endpoint: `POST /v1/images/edits` — set `model` to `topaz-image-upscale`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/images/edits/{id}
curl https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "topaz-image-upscale",
    "images": ["https://example.com/photo.png"]
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/images/edits \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "topaz-image-upscale",
    "images": ["https://example.com/photo.png"]
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/images/edits/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o edited.png "$(echo "$JOB" | jq -r .result.images[0].url)"
```

Full request and response reference: [Image editing guide](/capabilities/image-generation#image-editing).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `topaz-image-upscale` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Image — Image editing |
| Model maker | Topaz Labs |
| Served by | fal |
| Pricing | \$0.32 / image |
| Capabilities | Edits an input image |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan-2.6
Source: https://docs.aireserve.com/models/catalog/wan-2.6

wan-2.6 on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Text-to-video** · Alibaba · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan-2.6`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2.6",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2.6",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan-2.6` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | Alibaba |
| Served by | fal |
| Pricing | 720p \$0.1/s, 1080p \$0.15/s |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan-3.0-prime-reference
Source: https://docs.aireserve.com/models/catalog/wan-3.0-prime-reference

wan-3.0-prime-reference on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Reference-to-video** · Alibaba · served by fal

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan-3.0-prime-reference`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-3.0-prime-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-3.0-prime-reference",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan-3.0-prime-reference` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Reference-to-video |
| Model maker | Alibaba |
| Served by | fal |
| Pricing | 480p \$0.068/s, 720p \$0.14/s, 1080p \$0.28/s |
| Capabilities | Reference media |
| Hosting | United States |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan3.0-i2v-higgsfield
Source: https://docs.aireserve.com/models/catalog/wan3.0-i2v-higgsfield

wan3.0-i2v-higgsfield on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Image-to-video** · Alibaba · served by Higgsfield

> [!WARNING]
>
> **Requires an organization opt-in:** Training-consent opt-in, Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan3.0-i2v-higgsfield`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-i2v-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-i2v-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "image": "https://example.com/first-frame.png",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan3.0-i2v-higgsfield` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Image-to-video |
| Model maker | Alibaba |
| Served by | Higgsfield |
| Pricing | see guide for per-resolution rates |
| Capabilities | Image input |
| Hosting | United States |
| Opt-ins | Training-consent opt-in, Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan3.0-reference-higgsfield
Source: https://docs.aireserve.com/models/catalog/wan3.0-reference-higgsfield

wan3.0-reference-higgsfield on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Reference-to-video** · Alibaba · served by Higgsfield

> [!WARNING]
>
> **Requires an organization opt-in:** Training-consent opt-in, Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan3.0-reference-higgsfield`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-reference-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-reference-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "reference_images": ["https://example.com/reference.png"],
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan3.0-reference-higgsfield` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Reference-to-video |
| Model maker | Alibaba |
| Served by | Higgsfield |
| Pricing | see guide for per-resolution rates |
| Capabilities | Reference media |
| Hosting | United States |
| Opt-ins | Training-consent opt-in, Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan3.0-video
Source: https://docs.aireserve.com/models/catalog/wan3.0-video

Wan 3.0 on Alibaba Model Studio: text, image and reference inputs on one model id.

**Text-to-video** · Alibaba · served by Alibaba Cloud · China-hosted

> [!WARNING]
>
> **Requires an organization opt-in:** China-hosted opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan3.0-video`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan3.0-video` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | Alibaba |
| Served by | Alibaba Cloud |
| Pricing | 480p \$0.05/s, 720p \$0.1/s, 1080p \$0.2/s |
| Capabilities | Image input, Reference media |
| Hosting | China-hosted provider ([what that means](/models#china-hosted-models)) |
| Opt-ins | China-hosted opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`wan3.0-video-higgsfield`](/models/catalog/wan3.0-video-higgsfield) | Higgsfield | see guide for per-resolution rates |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# wan3.0-video-higgsfield
Source: https://docs.aireserve.com/models/catalog/wan3.0-video-higgsfield

wan3.0-video-higgsfield on the AI Reserve gateway — model id, aliases, pricing, limits and a copy-paste request.

**Text-to-video** · Alibaba · served by Higgsfield

> [!WARNING]
>
> **Requires an organization opt-in:** Training-consent opt-in, Unverified-retention opt-in. Until an administrator enables it from the admin console the model is hidden from pickers and API requests to it are refused. See [organization consent gates](/models#organization-consent-gates).

## Call it

Endpoint: `POST /v1/videos/generations` — set `model` to `wan3.0-video-higgsfield`.

```bash cURL theme={"dark"}
# Submit — answers 202 with a job id, then poll GET /v1/videos/generations/{id}
curl https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }'
```

```bash cURL (submit, poll, download) theme={"dark"}
# 1) Submit — returns 202 with the job id
JOB=$(curl -s https://api.aireserve.com/v1/videos/generations \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video-higgsfield",
    "prompt": "A drone shot over a misty pine forest at sunrise",
    "duration_seconds": 5
  }')
JOB_ID=$(echo "$JOB" | jq -r .id)

# 2) Poll every few seconds until the job is terminal
while :; do
  JOB=$(curl -s "https://api.aireserve.com/v1/videos/generations/$JOB_ID" \
    -H "Authorization: Bearer $AIRESERVE_API_KEY")
  STATUS=$(echo "$JOB" | jq -r .status)
  echo "status: $STATUS"
  case "$STATUS" in succeeded|failed) break ;; esac
  sleep 3
done

# 3) Download the result
curl -o clip.mp4 "$(echo "$JOB" | jq -r .result.video.url)"
```

Full request and response reference: [Video generation guide](/capabilities/video-generation).

## IDs & aliases

| Send as `model` | What it is |
| - | - |
| `wan3.0-video-higgsfield` | Canonical gateway id |

## Specs

| Spec | Detail |
| - | - |
| Modality | Video — Text-to-video |
| Model maker | Alibaba |
| Served by | Higgsfield |
| Pricing | see guide for per-resolution rates |
| Hosting | United States |
| Opt-ins | Training-consent opt-in, Unverified-retention opt-in |

Prices are public list rates at generation time and may lag the provider card; `GET /v1/models` and the portal's pricing page are authoritative for billing.

## Same weights, other providers

| Model id | Served by | Pricing |
| - | - | - |
| [`wan3.0-video`](/models/catalog/wan3.0-video) | Alibaba Cloud | 480p \$0.05/s, 720p \$0.1/s, 1080p \$0.2/s |

Same weights, different machines: speed, time to first token and cache behavior are the serving provider's. The unsuffixed id is the default we picked for reliability; pick a suffix when you need a specific provider's [data-handling terms](https://privacy.aireserve.com/data-handling).

> **[Browse all models](/models)**
>
> Search and filter every model by modality, maker, capability and price.


# Embedding models
Source: https://docs.aireserve.com/models/embeddings

2 embedding models on the AI Reserve gateway — ids, serving providers, pricing and links to a copy-paste request for each.

Vector embeddings for search, clustering and retrieval.

Endpoints: `POST /v1/embeddings`. Prefer to search and filter? [Browse models](/models).

## OpenAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [Text Embedding 3 Large](/models/catalog/text-embedding-3-large) | `text-embedding-3-large` | Embeddings | — |
| [Text Embedding 3 Small](/models/catalog/text-embedding-3-small) | `text-embedding-3-small` | Embeddings | — |


# Image models
Source: https://docs.aireserve.com/models/image

16 image models on the AI Reserve gateway — ids, serving providers, pricing and links to a copy-paste request for each.

Text-to-image generation and image editing. Generation is synchronous; edits return a job you poll.

Endpoints: `POST /v1/images/generations` · `POST /v1/images/edits`. Prefer to search and filter? [Browse models](/models).

## Black Forest Labs

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [flux-2-flex](/models/catalog/flux-2-flex) *served by fal* | `flux-2-flex` | Image generation | \$0.05 / megapixel |
| [flux-2-flex-edit](/models/catalog/flux-2-flex-edit) *served by fal* | `flux-2-flex-edit` | Image editing | \$0.2 / image |

## Bria

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [bria-background-remove](/models/catalog/bria-background-remove) *served by fal* | `bria-background-remove` | Image editing | \$0.018 / image |

## ByteDance

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [Seedream 5](/models/catalog/seedream-5) *served by ByteDance Ark* *China-hosted, China-hosted opt-in* | `seedream-5` | Image generation | \$0.09 / image |

## Google

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [Gemini 2.5 Flash Image](/models/catalog/gemini-2.5-flash-image) | `gemini-2.5-flash-image` | Image generation | \$0.039 / image |
| [Gemini 3.1 Flash Image](/models/catalog/gemini-3.1-flash-image) | `gemini-3.1-flash-image` | Image generation | \$0.151 / image |
| [nano-banana-2](/models/catalog/nano-banana-2) *served by fal* | `nano-banana-2` | Image generation | \$0.08 / image |
| [nano-banana-2-edit](/models/catalog/nano-banana-2-edit) *served by fal* | `nano-banana-2-edit` | Image editing | \$0.08 / image |

## OpenAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [GPT Image 1](/models/catalog/gpt-image-1) | `gpt-image-1` | Image generation | \$5 in / \$40 out per 1M tokens · token-billed |
| [gpt-image-2-edit](/models/catalog/gpt-image-2-edit) *served by fal* | `gpt-image-2-edit` | Image editing | \$0.45 / image |

## Qwen

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [qwen-image-2-pro-edit](/models/catalog/qwen-image-2-pro-edit) *served by fal* | `qwen-image-2-pro-edit` | Image editing | \$0.075 / image |
| [qwen-image-3.0](/models/catalog/qwen-image-3.0) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-image-3.0` | Image generation | \$0.03 / image |
| [qwen-image-3.0-pro](/models/catalog/qwen-image-3.0-pro) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-image-3.0-pro` | Image generation | \$0.075 / image |

## Topaz Labs

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [topaz-image-upscale](/models/catalog/topaz-image-upscale) *served by fal* | `topaz-image-upscale` | Image editing | \$0.32 / image |

## xAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [grok-imagine-image](/models/catalog/grok-imagine-image) *served by fal* | `grok-imagine-image` | Image generation | \$0.02 / image |
| [grok-imagine-image-edit](/models/catalog/grok-imagine-image-edit) *served by fal* | `grok-imagine-image-edit` | Image editing | \$0.02 / image |


# Browse models
Source: https://docs.aireserve.com/models/index

Every model on the AI Reserve gateway in one place — filter by text, image, video or audio, by maker, serving provider and capability, then copy the model id or a ready-to-run request.

One API key unlocks every model below through a single, flat ID namespace — the same
`model` / `modelId` string works across the Converse SDKs, the OpenAI-compatible
endpoints, the Anthropic-compatible `/v1/messages` route, and the Bedrock wire-format
routes. Pick a modality, narrow by maker or capability, and every card gives you the id,
the aliases that resolve to it, and a request you can paste straight into a terminal.

Modality

<input type="search" placeholder="Search by model name, id, alias or provider…" aria-label="Search models" />

**Maker**

**Served by**

**Sort**

US-hosted only

No opt-in required

All

of  models

> [!NOTE]
>
> **Prefer a plain list?** The same catalog is published as static pages per modality —
> [Text & chat](/models/text), [Image](/models/image), [Video](/models/video),
> [Audio & voice](/models/audio), [Embeddings](/models/embeddings) — and every model has its
> own page under the **Models** tab with SDK examples, limits and same-weights alternatives.

## The live catalog

The browser above is generated from the same registries the gateway routes from and is
refreshed with every model change. At runtime, treat the API as the source of truth:

```bash theme={"dark"}
curl https://api.aireserve.com/v1/models \
  -H "Authorization: Bearer $AIRESERVE_API_KEY"
```

`GET /v1/models` returns the OpenAI-shaped list, filtered to what **your** organization can
call (China-hosted and consent-gated models appear only once an administrator has opted
in), so model pickers and framework integrations that enumerate models work unchanged.
Retired model IDs return `404 ResourceNotFoundException` — enumerate `/v1/models` rather
than hardcoding lists.

## How to read a model id

| You see | It means |
| - | - |
| `claude-opus-5-5`, `gpt-5.5`, `wan-2.6` | The **canonical gateway id** — the string to send as `model`. One id works on every route. |
| `claude-sonnet`, `claude-opus` | **Recommended-release aliases** that track our current Sonnet and Opus picks, so pinned integrations opt into upgrades by using the alias instead of a dated id. |
| `sonnet`, `gpt`, `maverick`, `grok-4.5`, `us.anthropic.…` | **Aliases** — tier words, family defaults, nicknames, xAI's dotted ids, AWS Bedrock ids and retired ids all resolve at the gateway; each model page lists the ones that land on it. |
| `glm-5.3-deepinfra`, `claude-opus-5-5-bedrock` | A **serving-provider suffix** pins the same weights to one disclosed provider ([details](#provider-suffixed-serving-variants)). |
| `deepseek-v4-flash:floor`, `…:nitro` | A **routing variant** lets the gateway pick the cheapest or fastest provider per request ([details](#provider-routing-variants)). |
| `claude-sonnet-4-6[1m]` | The **1M-context form** of an extended-context model ([details](#1m-token-context)). |
| `claude-air-gpt-5.5` | The **Claude Code picker id** for a non-Claude model — Claude Code only lists ids that start with `claude`, so the gateway advertises every other model under this self-disclosing prefix. |

## Chat & reasoning models

> [!NOTE]
>
> **Reasoning models and small `max_tokens`.** Models that think before answering (`gemini-3-flash-preview`, `gpt-5.x`,
> `gpt-6-astra`, `grok-4-1-fast-reasoning`, …) spend part of the token budget on internal reasoning. With a tight cap
> (e.g. `max_tokens: 50`) the budget can be consumed before any visible text is produced — the response then comes back
> with `finish_reason / stop_reason = max_tokens` (or `length`) and empty content. That's the model, not an error: raise
> `max_tokens` (a few hundred is a safe floor for reasoning models) or pick a non-reasoning model for short outputs.

Family-level notes — the per-model ids, prices and limits live in the browser above and on
[Text & chat models](/models/text).

| Family | Notes |
| - | - |
| OpenAI GPT | Vision on 4.1/4o/5.x/6; automatic prompt caching (not on the `-pro` tiers). The GPT-6 line has 1M context plus image and file input. The `-ultrafast` IDs serve the same GPT-6.1 Sol / GPT-6 Astra weights on OpenAI's fastest service tier (up to 8x faster token generation) at 6x the standard price on every token class — pick them when speed matters more than cost. |
| Anthropic Claude | Vision; explicit prompt caching ([minimums](/capabilities/prompt-caching)) — `claude-fable-5-1` cache reads cost 2.5% of input (75% below Fable 5); `claude-opus-5-5` (1M context) is the current Opus flagship, served first-party by Anthropic; `-bedrock` and `-vertex` serving variants available ([below](#bedrock-routed-variants-&-aws-model-ids)). |
| Google Gemini | Vision + native video input ([table](/capabilities/video-input)); implicit caching. |
| xAI Grok | Automatic caching; `grok-4-20-non-reasoning` serves the 4.20 weights without extended reasoning. |
| DeepSeek | `deepseek-v4.1-flash` is DeepSeek V4.1 Flash on US-hosted DeepInfra; `deepseek-flash` serves the same new weights on DeepSeek's official API and requires the China-hosting and training consents. V4.1 Flash is the only released V4.1 model — there is no separate non-Flash V4.1 endpoint. `deepseek-v3.2` is US-served by DeepInfra (DeepSeek retired it from its own API) with a `deepseek-v3.2-bedrock` AWS route and a consent-gated `-streamlake` variant; `deepseek-v4-flash-vision-exp-novita` is an experimental vision build served by Novita AI with same-weights `-deepinfra` serving variants. |
| Meta Llama | Served on OpenRouter and AWS Bedrock (same weights, load-balanced); `-bedrock` variants pin the Bedrock route. |
| Mistral | `mistral-large` served on OpenRouter and AWS Bedrock (same weights, load-balanced); `mistral-large-bedrock` pins the Bedrock route. |
| Moonshot / Kimi | `kimi-k3` and `moonshot-v1-*` are China-hosted ([below](#china-hosted-models)) — `kimi-k3-fireworks` is the US-served variant. The coding-tuned K2.7 Code serves via `kimi-k2.7-code-moonshot` (China-hosted, consent-gated) and the `-deepinfra` / `-novita` variants; the old US-served `kimi-k2.7-code` ID still resolves ([below](#deprecation-policy)). |
| Alibaba Qwen | `qwen-3.8-max` and `qwen-3.8-flash` are Alibaba-served (China-hosted, [below](#china-hosted-models)); `qwen-3.8-max-deepinfra` / `-novita` are the US-served variants. |
| Perplexity Sonar | Web-grounded answers with citations. |
| NVIDIA Nemotron | Open-weight, served by DeepInfra (US); the opt-in `nemotron-3-ultra-nvidia` variant sits behind an [organization training consent](#organization-consent-gates). |
| Other open-weight | `minimax-m3`, GLM 5.x, GLM 4.7 and `gpt-oss-*` on managed US hosting; serving variants [below](#provider-suffixed-serving-variants). `glm-5.3-flash-novita` is Z.AI's GLM-5.3-Flash (320B-A18B, 1M context, image input) served by Novita AI; `glm-4.7-novita` is Z.AI's GLM 4.7 flagship (200K context, text only) with same-weights `glm-4.7-deepinfra` and `glm-4.7-bedrock` variants. |

## Deprecation policy

No surprise deprecations: you hear it from us first.

* **At least 30 days of notice.** When a model must leave the catalog, the retirement
  date is announced a minimum of 30 days ahead. Until that date the model keeps
  working normally.
* **How notices arrive.** Your organization's admins receive an email naming the
  model, the retirement date, and what to use instead. It goes to every organization
  that used the model in the previous 60 days, and the same notice stays visible on
  the admin Models tab until the date passes.
* **Upstream retirements are absorbed where possible.** When a provider retires a
  model or an alias on their side, we keep the catalog ID working wherever we can by
  pointing it at the successor. Precedent: DeepSeek retired its `deepseek-chat` and
  `deepseek-reasoner` upstream aliases in July 2026, and both IDs kept working
  unchanged on this platform. Each now calls the explicit DeepSeek V4 successor with
  its original thinking behavior preserved. Likewise, when Together AI withdrew
  serverless serving of several open-weight deployments in September 2026, the
  affected IDs were repointed at the same weights on a surviving provider:
  `kimi-k2.7-code` → `kimi-k2.7-code-moonshot`, `kimi-k2.6-together` →
  `kimi-k2.6-moonshot` (both China-hosted and consent-gated — the re-route serves
  only after your organization's opt-ins, [below](#organization-consent-gates)),
  `minimax-m2.5` → `minimax-m2.5-tensormesh` (consent-gated), and
  `nemotron-3-ultra-together` → `nemotron-3-ultra`; and when Baseten deprecated
  its GLM 4.7 deployment in October 2026, `glm-4.7-baseten` was repointed at the
  same weights on Novita AI (`glm-4.7-novita`, same price and context window). A
  deprecation notice is sent only when an ID truly cannot be preserved; an ID
  retired upstream with no successor returns an explicit "retired by its
  provider" error rather than a generic 404 (as `mistral-small` does since
  September 2026, when OpenRouter withdrew its last endpoint;
  `nemotron-3-nano-nvidia` since August 2026 and `nemotron-3-super-nvidia`
  since October 2026, when NVIDIA retired the hosted endpoints — the
  DeepInfra-served `nemotron-3-nano` and `nemotron-3-super` remain available;
  and `minimax-m2.7` since September 2026, when Together withdrew its only
  serving).

## Bedrock-routed variants & AWS model IDs

Eighteen models are also offered *via AWS Bedrock serving* under
`-bedrock` IDs — same shapes, same key, one-string A/B against the direct
path — including the current Claude line (`claude-fable-5-1-bedrock`,
`claude-fable-5-bedrock`, `claude-opus-5-5-bedrock`, `claude-opus-5-bedrock`,
`claude-sonnet-5-5-bedrock`, `claude-sonnet-5-bedrock`, `claude-opus-4-8-bedrock`,
`claude-opus-4-7-bedrock`). See [Bedrock-routed models](/migrate/from-bedrock#bedrock-routed-models) for the full mapping.
On the Bedrock wire-format routes (`/model/{id}/converse[-stream]`) the
gateway additionally accepts native AWS model IDs (`us.anthropic.…`,
inference-profile ARNs) so unmodified boto3 code works without renaming models — see
[AWS SDK (boto3)](/connect/aws-sdk).

## Vertex-routed variants

Three Claude models are additionally offered *via Google Vertex AI serving* under
`-vertex` IDs — `claude-sonnet-4-6-vertex`, `claude-sonnet-4-5-vertex`, and
`claude-haiku-4-5-vertex` — same shapes, same key, one-string A/B against the direct
path. Google operates the model inside Google Cloud infrastructure in the United States
(us-east5) as a data processor; the model's publisher does not receive prompts or
completions. See the
[provider data-handling disclosures](https://privacy.aireserve.com/data-handling)
for the full routing notes.

## Provider-suffixed serving variants

Several open-weight models are served by more than one disclosed provider. DeepSeek
V4.1 Flash uses `deepseek-v4.1-flash` for its US-hosted DeepInfra primary,
`deepseek-v4.1-flash-novita` for the same weights served by Novita AI (US), and
`deepseek-flash` for the separately consent-gated DeepSeek official endpoint. A provider
suffix pins other requests to a provider's deployment of the same weights — for example
`deepseek-v4-flash-deepinfra` / `deepseek-v4-flash-novita` (DeepInfra and Novita AI
serving of DeepSeek V4 Flash), `qwen-3.8-max-deepinfra` / `qwen-3.8-max-novita`,
`glm-5.3-flash-baseten`, `glm-5.2-together`, or `kimi-k3-fireworks`. Baseten (US)
serves `-baseten` variants of GLM 5.3 (`glm-5.3-baseten`), GLM 5.2 (`glm-5.2-baseten`),
DeepSeek V4 Pro (`deepseek-v4-pro-baseten`), Kimi K2.6 (`kimi-k2.6-baseten`), and
Kimi K2.7 Code (`kimi-k2.7-code-baseten`). Z.AI's GLM 4.7 (200K context) serves
entirely through provider-suffixed variants — `glm-4.7-novita` (primary),
`glm-4.7-deepinfra`, and `glm-4.7-bedrock` (all US; the AWS route is the same
weights on Amazon Bedrock, see [Bedrock-routed variants](#bedrock-routed-variants-&-aws-model-ids);
the `glm-4.7-baseten` variant retired with Baseten's
deployment in October 2026 and now resolves to `glm-4.7-novita`). The `-streamlake` variants
(`deepseek-v3.2-streamlake`, `deepseek-v4-flash-streamlake`, `deepseek-v4-pro-streamlake`,
`glm-5.2-streamlake`, `kimi-k2.6-streamlake`, `kimi-k2.7-code-streamlake`,
`minimax-m2.5-streamlake`) are served by StreamLake, Kuaishou's international AI cloud —
they are labeled China-based and additionally consent-gated (see
[China-hosted models](#china-hosted-models) and
[Organization consent gates](#organization-consent-gates) below). The suffix names the serving provider whose
[data-handling terms](https://privacy.aireserve.com/data-handling) apply — the
model's original publisher never receives requests on these routes. Unsuffixed
open-weight IDs default to a disclosed US serving provider — for example the Nemotron 3
family (`nemotron-3-super`, `nemotron-3-nano`, `nemotron-3-ultra`) has been served by
DeepInfra since August 2026.

Same weights, different machines: output speed, time to first token, and prompt-cache
behavior are the provider's, so two suffixes of one model can differ by 2–3× in tokens
per second (measured across the `gpt-oss-120b` legs, October 2026). The unsuffixed ID is
the default we picked for speed and reliability; reach for a suffix when you need a
specific provider's data-handling terms or want to compare. The portal's Analytics
**Usage by Model** table breaks a model out by serving provider (once more than one has
served it) with p50 / p95 latency and cache-hit rate on your own traffic, which is the
fairest comparison.

Since September 2026, GMI Cloud (US) serves seven `-gmicloud` variants:
`deepseek-v4-flash-gmicloud`, `deepseek-v4-pro-gmicloud`, `glm-5.2-gmicloud`,
`glm-5.3-gmicloud`, `glm-5.3-flash-gmicloud`, `kimi-k2.6-gmicloud`, and
`kimi-k2.7-code-gmicloud` — same weights as each base model, often at the lowest
US-hosted rate for those weights (`deepseek-v3.2-gmicloud` retired with GMI's V3.2
serving in September 2026 and resolves to `deepseek-v3.2`). GMI Cloud publishes no
API-content retention terms yet, so the `-gmicloud` variants require the organization
data-retention consent (see "Organization consent gates" below).

Novita AI retires its DeepSeek V4 Flash serving on **October 9, 2026 at 16:00 UTC**
([Novita changelog](https://docs.novita.ai/changelog/28-09-26)). `deepseek-v4-flash-novita`,
`deepseek-v4-flash-reasoner-novita`, `deepseek-v4-flash-vision-exp-novita`, and
`gpt-oss-20b-novita` keep working until then and are no longer fallback destinations for
any other route. Novita's designated successor is DeepSeek V4.1 Flash, available now as
`deepseek-v4.1-flash-novita` — a different model, so it is never substituted silently;
switch to it (or to another serving variant of the same V4 Flash weights, such as
`deepseek-v4-flash-deepinfra`) before the cutoff. Organizations that used the retiring
variants recently receive the standard deprecation notice ([below](#deprecation-policy)).

## Provider routing variants

Don't want to pick a provider suffix yourself? Append a routing variant to the model ID
and the gateway picks the serving provider per request:

* **`:nitro`** — the fastest provider currently serving those weights (rolling median
  latency on live traffic). Alias: `:fastest`.
* **`:floor`** — the cheapest provider by blended token price. Alias: `:cheapest`.

```bash theme={"dark"}
curl https://api.aireserve.com/v1/chat/completions \
  -H "Authorization: Bearer $AIRESERVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash:floor",
    "messages": [{"role": "user", "content": "Hello"}]
  }'
```

The response body and the `x-aireserve-served-model` header name the provider-suffixed
ID that actually served (for example `deepseek-v4-flash-deepinfra`), so the serve is always
disclosed. Variants never change what you're allowed to use: access rules, consent
gates, and model allowlists apply exactly as they do without the suffix. Your failover
protection also survives the reroute: the model's [fallback chain](/capabilities/fallbacks)
still applies to whichever provider the variant picks (fallbacks are opt-in per
organization or per request; an organization that has at least one fallback chain
configured also keeps the platform's standard provider failover for its other models;
ask support to change either). On models
with a single serving provider, on providers we haven't yet verified with live production
traffic, and on the [China-hosted models](#china-hosted-models) — which always serve
exactly the provider their ID promises — the suffix is accepted and simply serves the
model unchanged. Migrating from OpenRouter? `:nitro` and `:floor` work as-is.

## 1M-token context

The extended-context models — `claude-sonnet-4-6`, `fable-5`, and
`opus-4-8` — serve a full 1M-token window through the gateway. Two equivalent
ways to opt in:

* Append the `[1m]` suffix to the model ID (e.g. `claude-sonnet-4-6[1m]`) — the gateway accepts this form directly.
* Send the `anthropic-beta: context-1m-2025-08-07` header, which the gateway relays to Anthropic.

Tokens are billed at the model's normal rates. Running Claude Code? It budgets a
200K window by default behind a custom base URL — pin the `[1m]` form through
`ANTHROPIC_MODEL` to get the full window; see
[Why the `[1m]` suffix?](/connect/claude-code#why-the-1m-suffix) for the details.

## China-hosted models

Some catalog models are served by providers operating under PRC jurisdiction:
`deepseek-chat` and `deepseek-reasoner` (DeepSeek's own API), the Moonshot official-API
models (`kimi-k3`, `kimi-k2.5`, `kimi-k2-thinking`, `moonshot-v1-8k`,
`moonshot-v1-32k`, `moonshot-v1-128k`), the Alibaba Cloud Model Studio-served entries
(`qwen-3.8-max` and the other Model Studio-served Qwen IDs, plus the `-alibaba`
suffixed serving variants), the `-deepseek` / `-moonshot` suffixed serving variants,
the `-streamlake` suffixed serving variants (StreamLake is Kuaishou's international
AI cloud — data storage is stated as Singapore, but the operator's parent is
PRC-headquartered and its inference hosting location is unstated),
and the ByteDance-served image and video models. The distinguishing test is who
operates the serving endpoint, not the model's origin — Chinese-origin open weights
served by US providers (for example `deepseek-v4-pro`, `qwen-3.7-max`,
`kimi-k2.6`, or `deepseek-reasoner-bedrock` on AWS) are not China-hosted. Note
that Alibaba's Qwen chat endpoint runs in the United States (Virginia) for every Qwen
chat model except `qwen-3-coder-next`, which Alibaba serves only from its
international (Singapore) endpoint; all of these models are labeled China-based
because the operator is PRC-headquartered.

Organization admins control access with a per-client opt-in: when disabled, China-hosted
models are excluded everywhere — the chat picker, auto-routing, and API traffic through
the gateway. See the
[provider data-handling disclosures](https://privacy.aireserve.com/data-handling)
for what each provider receives.

## Organization consent gates

Separately from the China-hosted opt-in, models served by providers whose terms permit
training on API inputs — DeepSeek's own API, Moonshot's own API, the NVIDIA-served
`-nvidia` Nemotron variants, and the StreamLake-served `-streamlake` variants
(StreamLake's international Terms of Service license it to use inputs and outputs
for model training, with no published opt-out) — are locked for every organization
until an enterprise administrator explicitly opts in from the admin console. The
`-streamlake` variants stack both gates: the China-hosted opt-in and the training
consent are each required. The same applies to models
whose provider retention cannot yet be verified or disabled (the `-tensormesh` and
`-gmicloud` serving variants). Locked models appear greyed-out in the model catalog with the required
consent named, are excluded from chat and automatic routing, and API requests to them
are refused. The
[provider data-handling disclosures](https://privacy.aireserve.com/data-handling#notes)
carry the full consent-gate matrix.

## Tier switching (organization opt-in)

Off for every organization until an enterprise administrator turns it on from the admin
console's **Routing** tab, by choosing **NVIDIA NeMo Switchyard** as the organization's model
router and picking the efficient model. The Routing tab is an open marketplace of routers under
the AI Reserve control plane: one model router and one provider router per organization, each
tunable through AI Reserve's standard quality / cost / speed dial or its own native settings,
with routers that are not yet available shown greyed out. The separate **Models** tab controls
model availability and routing eligibility. When enabled, the gateway may serve a routine
turn of a coding-agent session (Claude Code, Codex, and other tool-calling harnesses) on the
**efficient model the administrator chose** instead of the model the request named, and bring
the requested model back when the conversation shows trouble — repeated or serious tool
errors, a stalled session, or a compacted context. Only requests that already carry tool calls
or tool results are candidates: a plain chat message or single-turn API call is never
switched, and non-coding surfaces (Microsoft Office, the portal chat, and the Slack agent) are
excluded outright, whatever their turns carry. The decision is a deterministic read of the
tool calls and results already in the request (a TypeScript port of
[NVIDIA NeMo Switchyard's](https://github.com/NVIDIA-NeMo/Switchyard) open-source stage
router), steadied on a best-effort basis within a coding session so tiers are not flipped
back and forth on borderline turns (the steadying memory lives on the gateway instance that
served the earlier turn, so it is not guaranteed on every turn); no request content leaves
the gateway to make it, and the per-session memory is a tier label — never conversation
content. This is an in-process open-source
integration, not an NVIDIA-hosted routing service or a claim of NVIDIA endorsement.

Every switched response is disclosed: the `x-aireserve-served-model` header names the model
that served, and the usage record carries both the requested and the served model. A switch
never crosses your governance: the efficient model must itself be routable for your
organization (not blocked, consent-gated, or restricted) and permitted by the requesting key's
quota allow- and blocklists; turns carrying images or files anywhere — including screenshots
returned by tools — are never switched; and a turn is left alone when the efficient model
could not take it (a thinking setting it does not support, a context larger than its window)
or would not be at least 2× cheaper on both input and output. Requests with `model: "auto"`
and requests from organizations that have not opted in are unaffected.

## Image generation

Every image model — generation via `POST /v1/images/generations` and editing via
`POST /v1/images/edits` — is listed with pricing on [Image models](/models/image) and in the
browser above under **Image**. The [image generation guide](/capabilities/image-generation)
covers parameters, response shapes and the async edit job flow. The Qwen Image 3 models and
`seedream-5` (ByteDance's official Ark API) are China-hosted (see above) and follow the same
per-client opt-in as the chat models. The retired `dall-e-3`, `imagen-3`, `imagen-4`,
`imagen-4-fast`, and `imagen-4-ultra` IDs return errors — migrate to
`gemini-3.1-flash-image` or `gpt-image-1`.

## Video generation

Every video model on the async `POST /v1/videos/generations` job API — text-to-video,
image-to-video and reference-to-video — is listed with per-second pricing on
[Video models](/models/video) and in the browser above under **Video**. The
[video generation guide](/capabilities/video-generation) covers inputs, durations,
resolutions and polling. `wan3.0-video` (Alibaba Model Studio) and the ByteDance official-API
models (`seedance-2.5`, `seedance-2.0-bytedance`, `seedance-2.0-mini`, `seedance-2.0-fast`)
are China-hosted (see above); `wan-2.6`, `seedance-2.0`, and every fal image-to-video /
reference-to-video model are served by fal in the United States.

## Capability reference

| Capability | Where documented |
| - | - |
| Streaming | [Streaming](/capabilities/streaming) — all chat models |
| Tool use / function calling | [Tool use](/capabilities/tool-use) |
| Vision (image input) | [Images](/capabilities/vision) — per-model table |
| Video input | [Video input](/capabilities/video-input) — per-model table |
| Prompt caching | [Prompt caching](/capabilities/prompt-caching) — per-model minimums |
| Token counting | `POST /v1/messages/count_tokens` (Anthropic-shape) |


# Text & chat models
Source: https://docs.aireserve.com/models/text

222 text & chat models on the AI Reserve gateway — ids, serving providers, pricing and links to a copy-paste request for each.

Chat, reasoning, coding and vision models. Every id below works on the OpenAI-compatible, Anthropic-compatible and Bedrock-shaped routes with the same key.

Endpoints: `POST /v1/chat/completions` · `POST /v1/messages` · `POST /v1/responses` · `POST /model/{id}/converse`. Prefer to search and filter? [Browse models](/models).

## Amazon

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Nova 2 Lite](/models/catalog/nova-2-lite) *served by Amazon Bedrock* | `nova-2-lite` | 1M | \$0.3 / \$2.5 | Vision, Tools, 1M ctx |
| [Nova Lite](/models/catalog/nova-lite) *served by Amazon Bedrock* | `nova-lite` | 300K | \$0.06 / \$0.24 | Vision, Tools |
| [Nova Micro](/models/catalog/nova-micro) *served by Amazon Bedrock* | `nova-micro` | 128K | \$0.035 / \$0.14 | Tools |
| [Nova Pro](/models/catalog/nova-pro) *served by Amazon Bedrock* | `nova-pro` | 300K | \$0.8 / \$3.2 | Vision, Tools |

## Anthropic

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Claude Fable 5](/models/catalog/claude-fable-5) | `claude-fable-5` | 1M | \$10 / \$50 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Fable 5.1](/models/catalog/claude-fable-5-1) | `claude-fable-5-1` | 1M | \$10 / \$50 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Fable 5.1 (Amazon Bedrock)](/models/catalog/claude-fable-5-1-bedrock) | `claude-fable-5-1-bedrock` | 1M | \$10 / \$50 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Fable 5.1 (Amazon Bedrock (US regions))](/models/catalog/claude-fable-5-1-bedrock-us) | `claude-fable-5-1-bedrock-us` | 1M | \$11 / \$55 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Fable 5 (Amazon Bedrock)](/models/catalog/claude-fable-5-bedrock) | `claude-fable-5-bedrock` | 1M | \$10 / \$50 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Fable 5 (Amazon Bedrock (US regions))](/models/catalog/claude-fable-5-bedrock-us) | `claude-fable-5-bedrock-us` | 1M | \$11 / \$55 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Haiku 4.5](/models/catalog/claude-haiku-4-5-20251001) | `claude-haiku-4-5-20251001` | 200K | \$1 / \$5 | Vision, Tools, Reasoning, Caching |
| [Claude Haiku 4.5 (Amazon Bedrock)](/models/catalog/claude-haiku-4-5-bedrock) | `claude-haiku-4-5-bedrock` | 200K | \$1 / \$5 | Vision, Tools, Reasoning, Caching |
| [Claude Haiku 4.5 (Amazon Bedrock (US regions))](/models/catalog/claude-haiku-4-5-bedrock-us) | `claude-haiku-4-5-bedrock-us` | 200K | \$1.1 / \$5.5 | Vision, Tools, Reasoning, Caching |
| [Claude Haiku 4.5 (Google Vertex AI)](/models/catalog/claude-haiku-4-5-vertex) | `claude-haiku-4-5-vertex` | 200K | \$1 / \$5 | Vision, Tools, Reasoning, Caching |
| [Claude Opus 4.5](/models/catalog/claude-opus-4-5) | `claude-opus-4-5` | 200K | \$5 / \$25 | Vision, Tools, Reasoning, Caching |
| [Claude Opus 4.6](/models/catalog/claude-opus-4-6) | `claude-opus-4-6` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.6 (Amazon Bedrock)](/models/catalog/claude-opus-4-6-bedrock) | `claude-opus-4-6-bedrock` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.6 (Amazon Bedrock (US regions))](/models/catalog/claude-opus-4-6-bedrock-us) | `claude-opus-4-6-bedrock-us` | 1M | \$5.5 / \$27.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.7](/models/catalog/claude-opus-4-7) | `claude-opus-4-7` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.7 (Amazon Bedrock)](/models/catalog/claude-opus-4-7-bedrock) | `claude-opus-4-7-bedrock` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.7 (Amazon Bedrock (US regions))](/models/catalog/claude-opus-4-7-bedrock-us) | `claude-opus-4-7-bedrock-us` | 1M | \$5.5 / \$27.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.8](/models/catalog/claude-opus-4-8) | `claude-opus-4-8` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.8 (Amazon Bedrock)](/models/catalog/claude-opus-4-8-bedrock) | `claude-opus-4-8-bedrock` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 4.8 (Amazon Bedrock (US regions))](/models/catalog/claude-opus-4-8-bedrock-us) | `claude-opus-4-8-bedrock-us` | 1M | \$5.5 / \$27.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5](/models/catalog/claude-opus-5) | `claude-opus-5` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5.5](/models/catalog/claude-opus-5-5) | `claude-opus-5-5` | 1M | \$4 / \$20 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5.5 (Amazon Bedrock)](/models/catalog/claude-opus-5-5-bedrock) | `claude-opus-5-5-bedrock` | 1M | \$4 / \$20 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5.5 (Amazon Bedrock (US regions))](/models/catalog/claude-opus-5-5-bedrock-us) | `claude-opus-5-5-bedrock-us` | 1M | \$4.4 / \$22 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5 (Amazon Bedrock)](/models/catalog/claude-opus-5-bedrock) | `claude-opus-5-bedrock` | 1M | \$5 / \$25 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Opus 5 (Amazon Bedrock (US regions))](/models/catalog/claude-opus-5-bedrock-us) | `claude-opus-5-bedrock-us` | 1M | \$5.5 / \$27.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.5](/models/catalog/claude-sonnet-4-5) | `claude-sonnet-4-5` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.5 (Amazon Bedrock)](/models/catalog/claude-sonnet-4-5-bedrock) | `claude-sonnet-4-5-bedrock` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.5 (Amazon Bedrock (US regions))](/models/catalog/claude-sonnet-4-5-bedrock-us) | `claude-sonnet-4-5-bedrock-us` | 1M | \$3.3 / \$16.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.5 (Google Vertex AI)](/models/catalog/claude-sonnet-4-5-vertex) | `claude-sonnet-4-5-vertex` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.6](/models/catalog/claude-sonnet-4-6) | `claude-sonnet-4-6` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.6 (Amazon Bedrock)](/models/catalog/claude-sonnet-4-6-bedrock) | `claude-sonnet-4-6-bedrock` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.6 (Amazon Bedrock (US regions))](/models/catalog/claude-sonnet-4-6-bedrock-us) | `claude-sonnet-4-6-bedrock-us` | 1M | \$3.3 / \$16.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 4.6 (Google Vertex AI)](/models/catalog/claude-sonnet-4-6-vertex) | `claude-sonnet-4-6-vertex` | 1M | \$3 / \$15 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5](/models/catalog/claude-sonnet-5) | `claude-sonnet-5` | 1M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5.5](/models/catalog/claude-sonnet-5-5) | `claude-sonnet-5-5` | 1M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5.5 (Amazon Bedrock)](/models/catalog/claude-sonnet-5-5-bedrock) | `claude-sonnet-5-5-bedrock` | 1M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5.5 (Amazon Bedrock (US regions))](/models/catalog/claude-sonnet-5-5-bedrock-us) | `claude-sonnet-5-5-bedrock-us` | 1M | \$2.2 / \$11 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5 (Amazon Bedrock)](/models/catalog/claude-sonnet-5-bedrock) | `claude-sonnet-5-bedrock` | 1M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [Claude Sonnet 5 (Amazon Bedrock (US regions))](/models/catalog/claude-sonnet-5-bedrock-us) | `claude-sonnet-5-bedrock-us` | 1M | \$2.2 / \$11 | Vision, Tools, Reasoning, Caching, 1M ctx |

## DeepSeek

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [DeepSeek Chat](/models/catalog/deepseek-chat) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-chat` | 164K | \$0.181 / \$0.725 | Tools, Caching |
| [DeepSeek V4.1 Flash (Official)](/models/catalog/deepseek-flash) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-flash` | 1.05M | \$0.181 / \$0.725 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek Reasoner](/models/catalog/deepseek-reasoner) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-reasoner` | 64K | \$0.181 / \$0.725 | Tools, Caching |
| [DeepSeek Reasoner (Amazon Bedrock)](/models/catalog/deepseek-reasoner-bedrock) | `deepseek-reasoner-bedrock` | 64K | \$0.55 / \$2.19 | Caching |
| [DeepSeek V3.2](/models/catalog/deepseek-v3.2) *served by DeepInfra* | `deepseek-v3.2` | 164K | \$0.26 / \$0.38 | Tools, Caching |
| [DeepSeek V3.2 (Amazon Bedrock)](/models/catalog/deepseek-v3.2-bedrock) | `deepseek-v3.2-bedrock` | 164K | \$0.62 / \$1.85 | Tools |
| [DeepSeek V3.2 (StreamLake)](/models/catalog/deepseek-v3.2-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-v3.2-streamlake` | 131K | \$0.286 / \$0.429 | Tools, Caching |
| [DeepSeek V4 Flash](/models/catalog/deepseek-v4-flash) *served by DeepInfra* | `deepseek-v4-flash` | 1.05M | \$0.09 / \$0.18 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (Baseten)](/models/catalog/deepseek-v4-flash-baseten) | `deepseek-v4-flash-baseten` | 1.05M | \$0.13 / \$0.26 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (DeepInfra)](/models/catalog/deepseek-v4-flash-deepinfra) | `deepseek-v4-flash-deepinfra` | 1.05M | \$0.09 / \$0.18 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (GMI Cloud)](/models/catalog/deepseek-v4-flash-gmicloud) *Unverified-retention opt-in* | `deepseek-v4-flash-gmicloud` | 1.05M | \$0.091 / \$0.182 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (Novita)](/models/catalog/deepseek-v4-flash-novita) *served by Novita AI* | `deepseek-v4-flash-novita` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Reasoner](/models/catalog/deepseek-v4-flash-reasoner) *served by DeepInfra* | `deepseek-v4-flash-reasoner` | 1.05M | \$0.09 / \$0.18 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Reasoner (Baseten)](/models/catalog/deepseek-v4-flash-reasoner-baseten) | `deepseek-v4-flash-reasoner-baseten` | 1.05M | \$0.13 / \$0.26 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Reasoner (DeepInfra)](/models/catalog/deepseek-v4-flash-reasoner-deepinfra) | `deepseek-v4-flash-reasoner-deepinfra` | 1.05M | \$0.09 / \$0.18 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Reasoner (Novita)](/models/catalog/deepseek-v4-flash-reasoner-novita) *served by Novita AI* | `deepseek-v4-flash-reasoner-novita` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Reasoner (Together)](/models/catalog/deepseek-v4-flash-reasoner-together) *served by Together AI* | `deepseek-v4-flash-reasoner-together` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (StreamLake)](/models/catalog/deepseek-v4-flash-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-v4-flash-streamlake` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (Tensormesh)](/models/catalog/deepseek-v4-flash-tensormesh) *Unverified-retention opt-in* | `deepseek-v4-flash-tensormesh` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash (Together)](/models/catalog/deepseek-v4-flash-together) *served by Together AI* | `deepseek-v4-flash-together` | 1.05M | \$0.14 / \$0.28 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Vision Exp (DeepInfra)](/models/catalog/deepseek-v4-flash-vision-exp-deepinfra) | `deepseek-v4-flash-vision-exp-deepinfra` | 1.05M | \$0.216 / \$0.647 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek V4 Flash Vision Exp (Novita)](/models/catalog/deepseek-v4-flash-vision-exp-novita) *served by Novita AI* | `deepseek-v4-flash-vision-exp-novita` | 1.05M | \$0.44 / \$1.32 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro](/models/catalog/deepseek-v4-pro) *served by Together AI* | `deepseek-v4-pro` | 1.05M | \$1.32 / \$3.96 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (Alibaba)](/models/catalog/deepseek-v4-pro-alibaba) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `deepseek-v4-pro-alibaba` | 1M | \$1.42 / \$2.83 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (Baseten)](/models/catalog/deepseek-v4-pro-baseten) | `deepseek-v4-pro-baseten` | 1.05M | \$1.32 / \$3.96 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (DeepInfra)](/models/catalog/deepseek-v4-pro-deepinfra) | `deepseek-v4-pro-deepinfra` | 1.05M | \$1.3 / \$2.6 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (DeepSeek)](/models/catalog/deepseek-v4-pro-deepseek) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-v4-pro-deepseek` | 1.05M | \$0.797 / \$2.39 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (GMI Cloud)](/models/catalog/deepseek-v4-pro-gmicloud) *Unverified-retention opt-in* | `deepseek-v4-pro-gmicloud` | 1.05M | \$0.957 / \$1.91 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (Novita)](/models/catalog/deepseek-v4-pro-novita) *served by Novita AI* | `deepseek-v4-pro-novita` | 1.05M | \$1.32 / \$3.96 | Tools, Caching, 1M ctx |
| [DeepSeek V4 Pro (StreamLake)](/models/catalog/deepseek-v4-pro-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `deepseek-v4-pro-streamlake` | 1.05M | \$1.74 / \$3.48 | Tools, Caching, 1M ctx |
| [DeepSeek V4.1 Flash](/models/catalog/deepseek-v4.1-flash) *served by DeepInfra* | `deepseek-v4.1-flash` | 1.05M | \$0.14 / \$0.42 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek V4.1 Flash 1017](/models/catalog/deepseek-v4.1-flash-1017) *served by Fireworks AI* | `deepseek-v4.1-flash-1017` | 1.05M | \$0.3 / \$1.2 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek V4.1 Flash 1017 Fast](/models/catalog/deepseek-v4.1-flash-1017-fast) *served by Baseten* | `deepseek-v4.1-flash-1017-fast` | 1.05M | \$0.6 / \$2.4 | Vision, Tools, Caching, 1M ctx |
| [DeepSeek V4.1 Flash (Novita)](/models/catalog/deepseek-v4.1-flash-novita) *served by Novita AI* | `deepseek-v4.1-flash-novita` | 1.05M | \$0.3 / \$1.2 | Vision, Tools, Caching, 1M ctx |

## Fireworks AI

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Ember-1](/models/catalog/ember-1) | `ember-1` | 1.05M | \$3 / \$15 | Tools, Caching, 1M ctx |

## Google

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Gemini 2.5 Flash](/models/catalog/gemini-2.5-flash) | `gemini-2.5-flash` | 1.05M | \$0.3 / \$2.5 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 2.5 Pro](/models/catalog/gemini-2.5-pro) | `gemini-2.5-pro` | 1.05M | \$1.25 / \$10 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3 Flash (Preview)](/models/catalog/gemini-3-flash-preview) | `gemini-3-flash-preview` | 1.05M | \$0.5 / \$3 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.1 Flash Lite](/models/catalog/gemini-3.1-flash-lite) | `gemini-3.1-flash-lite` | 1.05M | \$0.25 / \$1.5 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.1 Pro (Preview)](/models/catalog/gemini-3.1-pro-preview) | `gemini-3.1-pro-preview` | 1.05M | \$2 / \$12 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.5 Flash](/models/catalog/gemini-3.5-flash) | `gemini-3.5-flash` | 1.05M | \$1.5 / \$9 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.5 Flash Lite](/models/catalog/gemini-3.5-flash-lite) | `gemini-3.5-flash-lite` | 1.05M | \$0.3 / \$2.5 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.6 Flash](/models/catalog/gemini-3.6-flash) | `gemini-3.6-flash` | 1.05M | \$0.75 / \$3.75 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.7 Flash](/models/catalog/gemini-3.7-flash) | `gemini-3.7-flash` | 1.05M | \$0.75 / \$3.75 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemini 3.8 Flash](/models/catalog/gemini-3.8-flash) | `gemini-3.8-flash` | 1.05M | \$0.75 / \$3.75 | Vision, Video in, Tools, Caching, 1M ctx |
| [Gemma 4 31B](/models/catalog/gemma-4-31b) *served by Tensormesh* *Unverified-retention opt-in* | `gemma-4-31b` | 33K | \$0.14 / \$0.56 | Tools, Caching |

## Meta

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Llama 3.3 70B](/models/catalog/llama-3.3-70b) *served by DeepInfra* | `llama-3.3-70b` | 131K | \$0.23 / \$0.4 | Tools |
| [Llama 4 Maverick](/models/catalog/llama-4-maverick) *served by OpenRouter + Amazon Bedrock* | `llama-4-maverick` | 1.05M | from \$0.24 / \$0.85 | Tools, 1M ctx |
| [Llama 4 Maverick (DeepInfra)](/models/catalog/llama-4-maverick-deepinfra) | `llama-4-maverick-deepinfra` | 1.05M | \$0.2 / \$0.8 | Tools, 1M ctx |
| [Llama 4 Maverick (Novita)](/models/catalog/llama-4-maverick-novita) *served by Novita AI* | `llama-4-maverick-novita` | 1.05M | \$0.27 / \$0.85 | Tools, 1M ctx |
| [Llama 4 Scout](/models/catalog/llama-4-scout) *served by OpenRouter + Amazon Bedrock* | `llama-4-scout` | 1.31M | from \$0.11 / \$0.34 | Tools, 1M ctx |
| [Llama 4 Scout (DeepInfra)](/models/catalog/llama-4-scout-deepinfra) | `llama-4-scout-deepinfra` | 328K | \$0.1 / \$0.3 | Tools |
| [Llama 4 Scout (Novita)](/models/catalog/llama-4-scout-novita) *served by Novita AI* | `llama-4-scout-novita` | 131K | \$0.18 / \$0.59 | Tools |
| [Muse Glimmer 30B](/models/catalog/muse-glimmer) *served by Together AI* | `muse-glimmer` | 131K | \$0.35 / \$1.5 | Tools |

## MiniMax

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [MiniMax M2.5 (StreamLake)](/models/catalog/minimax-m2.5-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `minimax-m2.5-streamlake` | 205K | \$0.3 / \$1.2 | Tools, Caching |
| [MiniMax M2.5 (Tensormesh)](/models/catalog/minimax-m2.5-tensormesh) *Unverified-retention opt-in* | `minimax-m2.5-tensormesh` | 197K | \$0.3 / \$1.2 | Tools, Caching |
| [MiniMax M3](/models/catalog/minimax-m3) *served by Together AI* | `minimax-m3` | 1.05M | \$0.3 / \$1.2 | Tools, Caching, 1M ctx |
| [MiniMax M3 (DeepInfra)](/models/catalog/minimax-m3-deepinfra) | `minimax-m3-deepinfra` | 524K | \$0.28 / \$1.1 | Tools, Caching |
| [MiniMax M3 (Novita)](/models/catalog/minimax-m3-novita) *served by Novita AI* | `minimax-m3-novita` | 1M | \$0.3 / \$1.2 | Tools, Caching, 1M ctx |

## Mistral

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Codestral](/models/catalog/codestral-2508) | `codestral-2508` | 256K | \$0.3 / \$0.9 | Tools |
| [Ministral 14B](/models/catalog/ministral-14b) | `ministral-14b` | 262K | \$0.2 / \$0.2 | Tools |
| [Ministral 3B](/models/catalog/ministral-3b) | `ministral-3b` | 131K | \$0.1 / \$0.1 | Tools |
| [Ministral 8B](/models/catalog/ministral-8b) | `ministral-8b` | 262K | \$0.15 / \$0.15 | Tools |
| [Mistral Large](/models/catalog/mistral-large) *served by OpenRouter + Amazon Bedrock* | `mistral-large` | 128K | from \$0.5 / \$1.5 | Tools |
| [Mistral Medium 3.5](/models/catalog/mistral-medium-3.5) | `mistral-medium-3.5` | 262K | \$1.5 / \$7.5 | Vision, Tools |
| [Mistral Small 4](/models/catalog/mistral-small-4) | `mistral-small-4` | 262K | \$0.15 / \$0.6 | Vision, Tools |

## Moonshot

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Kimi K2 Thinking](/models/catalog/kimi-k2-thinking) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2-thinking` | 262K | \$0.6 / \$2.5 | Tools, Caching |
| [Kimi K2.5](/models/catalog/kimi-k2.5) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2.5` | 262K | \$0.57 / \$2.85 | Vision, Tools, Caching |
| [Kimi K2.6](/models/catalog/kimi-k2.6) *served by DeepInfra* | `kimi-k2.6` | 262K | \$0.75 / \$3.5 | Tools, Caching |
| [Kimi K2.6 (Baseten)](/models/catalog/kimi-k2.6-baseten) | `kimi-k2.6-baseten` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.6 (DeepInfra)](/models/catalog/kimi-k2.6-deepinfra) | `kimi-k2.6-deepinfra` | 262K | \$0.75 / \$3.5 | Tools, Caching |
| [Kimi K2.6 (GMI Cloud)](/models/catalog/kimi-k2.6-gmicloud) *Unverified-retention opt-in* | `kimi-k2.6-gmicloud` | 262K | \$0.855 / \$3.6 | Tools, Caching |
| [Kimi K2.6 (Moonshot)](/models/catalog/kimi-k2.6-moonshot) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2.6-moonshot` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.6 (Novita)](/models/catalog/kimi-k2.6-novita) *served by Novita AI* | `kimi-k2.6-novita` | 262K | \$0.8 / \$3.4 | Tools, Caching |
| [Kimi K2.6 (StreamLake)](/models/catalog/kimi-k2.6-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2.6-streamlake` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.6 (Tensormesh)](/models/catalog/kimi-k2.6-tensormesh) *Unverified-retention opt-in* | `kimi-k2.6-tensormesh` | 131K | \$0.96 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (Alibaba)](/models/catalog/kimi-k2.7-code-alibaba) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `kimi-k2.7-code-alibaba` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (Baseten)](/models/catalog/kimi-k2.7-code-baseten) | `kimi-k2.7-code-baseten` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (DeepInfra)](/models/catalog/kimi-k2.7-code-deepinfra) | `kimi-k2.7-code-deepinfra` | 262K | \$0.68 / \$3.4 | Tools, Caching |
| [Kimi K2.7 Code (GMI Cloud)](/models/catalog/kimi-k2.7-code-gmicloud) *Unverified-retention opt-in* | `kimi-k2.7-code-gmicloud` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (Moonshot)](/models/catalog/kimi-k2.7-code-moonshot) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2.7-code-moonshot` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (Novita)](/models/catalog/kimi-k2.7-code-novita) *served by Novita AI* | `kimi-k2.7-code-novita` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K2.7 Code (StreamLake)](/models/catalog/kimi-k2.7-code-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k2.7-code-streamlake` | 262K | \$0.95 / \$4 | Tools, Caching |
| [Kimi K3](/models/catalog/kimi-k3) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `kimi-k3` | 1.05M | \$3 / \$15 | Vision, Tools, Caching, 1M ctx |
| [Kimi K3 (Fireworks)](/models/catalog/kimi-k3-fireworks) *served by Fireworks AI* | `kimi-k3-fireworks` | 1.05M | \$3 / \$15 | Vision, Tools, Caching, 1M ctx |
| [Moonshot v1 128K](/models/catalog/moonshot-v1-128k) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `moonshot-v1-128k` | — | \$2 / \$5 | Caching |
| [Moonshot v1 32K](/models/catalog/moonshot-v1-32k) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `moonshot-v1-32k` | — | \$1 / \$3 | Caching |
| [Moonshot v1 8K](/models/catalog/moonshot-v1-8k) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `moonshot-v1-8k` | — | \$0.2 / \$2 | Caching |

## NVIDIA

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Nemotron 3 Nano](/models/catalog/nemotron-3-nano) *served by DeepInfra* | `nemotron-3-nano` | 262K | \$0.05 / \$0.2 | Tools, Caching |
| [Nemotron 3 Nano (DeepInfra)](/models/catalog/nemotron-3-nano-deepinfra) | `nemotron-3-nano-deepinfra` | 262K | \$0.05 / \$0.2 | Tools, Caching |
| [Nemotron 3 Super](/models/catalog/nemotron-3-super) *served by DeepInfra* | `nemotron-3-super` | 262K | \$0.085 / \$0.4 | Tools |
| [Nemotron 3 Ultra](/models/catalog/nemotron-3-ultra) *served by DeepInfra* | `nemotron-3-ultra` | 262K | \$0.5 / \$2.2 | Tools, Caching |
| [Nemotron 3 Ultra (NVIDIA)](/models/catalog/nemotron-3-ultra-nvidia) *served by NVIDIA NIM* *Training-consent opt-in* | `nemotron-3-ultra-nvidia` | 1M | \$0.6 / \$2.4 | Tools, 1M ctx |
| [Nemotron 3.5 Lightning](/models/catalog/nemotron-3.5-lightning) *served by DeepInfra* | `nemotron-3.5-lightning` | 1M | \$0.06 / \$0.16 | Tools, Caching, 1M ctx |

## OpenAI

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [GPT-4 Turbo](/models/catalog/gpt-4-turbo) | `gpt-4-turbo` | — | \$10 / \$30 | Caching |
| [GPT-4.1](/models/catalog/gpt-4.1) | `gpt-4.1` | 1.05M | \$2 / \$8 | Vision, Tools, Caching, 1M ctx |
| [GPT-4.1 Mini](/models/catalog/gpt-4.1-mini) | `gpt-4.1-mini` | 1.05M | \$0.4 / \$1.6 | Vision, Tools, Caching, 1M ctx |
| [GPT-4o](/models/catalog/gpt-4o) | `gpt-4o` | 128K | \$2.5 / \$10 | Vision, Tools, Caching |
| [GPT-4o Mini](/models/catalog/gpt-4o-mini) | `gpt-4o-mini` | 128K | \$0.15 / \$0.6 | Tools, Caching |
| [GPT-5.1](/models/catalog/gpt-5.1) | `gpt-5.1` | 400K | \$1.25 / \$10 | Vision, Tools, Reasoning, Caching |
| [GPT-5.2](/models/catalog/gpt-5.2) | `gpt-5.2` | 400K | \$1.75 / \$14 | Vision, Tools, Reasoning, Caching |
| [GPT-5.2 Pro](/models/catalog/gpt-5.2-pro) | `gpt-5.2-pro` | 400K | \$21 / \$168 | Vision, Tools, Reasoning |
| [GPT-5.3 Codex](/models/catalog/gpt-5.3-codex) | `gpt-5.3-codex` | 400K | \$1.75 / \$14 | Vision, Tools, Reasoning, Caching |
| [GPT-5.4](/models/catalog/gpt-5.4) | `gpt-5.4` | 1.05M | \$2.5 / \$15 | Vision, Tools, Caching, 1M ctx |
| [GPT-5.4 Mini](/models/catalog/gpt-5.4-mini) | `gpt-5.4-mini` | 400K | \$0.75 / \$4.5 | Vision, Tools, Caching |
| [GPT-5.4 Nano](/models/catalog/gpt-5.4-nano) | `gpt-5.4-nano` | 400K | \$0.2 / \$1.25 | Vision, Tools, Caching |
| [GPT-5.4 Pro](/models/catalog/gpt-5.4-pro) | `gpt-5.4-pro` | 1.05M | \$30 / \$180 | Vision, Tools, Reasoning, 1M ctx |
| [GPT-5.5](/models/catalog/gpt-5.5) | `gpt-5.5` | 1.05M | \$5 / \$30 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-5.5 Pro](/models/catalog/gpt-5.5-pro) | `gpt-5.5-pro` | 1.05M | \$30 / \$180 | Vision, Tools, Reasoning, 1M ctx |
| [GPT-5.6 Luna](/models/catalog/gpt-5.6-luna) | `gpt-5.6-luna` | 1.05M | \$0.2 / \$1.2 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-5.6 Sol](/models/catalog/gpt-5.6-sol) | `gpt-5.6-sol` | 1.05M | \$4 / \$20 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-5.6 Sol Ultra](/models/catalog/gpt-5.6-sol-ultra) | `gpt-5.6-sol-ultra` | 1.05M | \$4 / \$20 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-5.6 Terra](/models/catalog/gpt-5.6-terra) | `gpt-5.6-terra` | 1.05M | \$2 / \$12 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6 Astra](/models/catalog/gpt-6-astra) | `gpt-6-astra` | 1.05M | \$10 / \$50 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6 Astra Ultrafast](/models/catalog/gpt-6-astra-ultrafast) | `gpt-6-astra-ultrafast` | 1.05M | \$60 / \$300 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6 Luna](/models/catalog/gpt-6-luna) | `gpt-6-luna` | 1.05M | \$0.1 / \$0.5 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6 Sol](/models/catalog/gpt-6-sol) | `gpt-6-sol` | 1.05M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6.1 Sol](/models/catalog/gpt-6.1-sol) | `gpt-6.1-sol` | 1.05M | \$2 / \$10 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-6.1 Sol Ultrafast](/models/catalog/gpt-6.1-sol-ultrafast) | `gpt-6.1-sol-ultrafast` | 1.05M | \$12 / \$60 | Vision, Tools, Reasoning, Caching, 1M ctx |
| [GPT-OSS 120B](/models/catalog/gpt-oss-120b) *served by Fireworks AI* | `gpt-oss-120b` | 131K | \$0.15 / \$0.6 | Tools, Caching |
| [GPT-OSS 120B (Baseten)](/models/catalog/gpt-oss-120b-baseten) | `gpt-oss-120b-baseten` | 131K | \$0.1 / \$0.5 | Tools |
| [GPT-OSS 120B (DeepInfra)](/models/catalog/gpt-oss-120b-deepinfra) | `gpt-oss-120b-deepinfra` | 131K | \$0.037 / \$0.17 | Tools |
| [GPT-OSS 120B (Tensormesh)](/models/catalog/gpt-oss-120b-tensormesh) *Unverified-retention opt-in* | `gpt-oss-120b-tensormesh` | 131K | \$0.15 / \$0.6 | Tools, Caching |
| [GPT-OSS 20B](/models/catalog/gpt-oss-20b) *served by DeepInfra* | `gpt-oss-20b` | 131K | \$0.03 / \$0.14 | Tools |
| [GPT-OSS 20B (DeepInfra)](/models/catalog/gpt-oss-20b-deepinfra) | `gpt-oss-20b-deepinfra` | 131K | \$0.03 / \$0.14 | Tools |
| [GPT-OSS 20B (Novita)](/models/catalog/gpt-oss-20b-novita) *served by Novita AI* | `gpt-oss-20b-novita` | 131K | \$0.04 / \$0.15 | Tools |
| [GPT-OSS 20B (Tensormesh)](/models/catalog/gpt-oss-20b-tensormesh) *Unverified-retention opt-in* | `gpt-oss-20b-tensormesh` | 131K | \$0.07 / \$0.28 | Tools, Caching |

## Perplexity

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Sonar](/models/catalog/sonar) | `sonar` | 127K | \$1 / \$1 | — |
| [Sonar Deep Research](/models/catalog/sonar-deep-research) | `sonar-deep-research` | 128K | \$2 / \$8 | — |
| [Sonar Pro](/models/catalog/sonar-pro) | `sonar-pro` | 200K | \$3 / \$15 | — |
| [Sonar Reasoning Pro](/models/catalog/sonar-reasoning-pro) | `sonar-reasoning-pro` | 128K | \$2 / \$8 | — |

## Qwen

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Qwen 3 Coder Next](/models/catalog/qwen-3-coder-next) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3-coder-next` | 262K | \$0.12 / \$0.8 | Tools |
| [Qwen 3 Coder Plus](/models/catalog/qwen-3-coder-plus) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3-coder-plus` | 1M | \$0.65 / \$3.25 | Tools, Caching, 1M ctx |
| [Qwen 3 VL 235B](/models/catalog/qwen-3-vl-235b-a22b) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3-vl-235b-a22b` | 262K | \$0.21 / \$1.9 | Vision, Tools, Caching |
| [Qwen 3.5 397B](/models/catalog/qwen-3.5-397b) *served by Tensormesh* *Unverified-retention opt-in* | `qwen-3.5-397b` | 262K | \$0.6 / \$3.6 | Tools |
| [Qwen 3.6 27B](/models/catalog/qwen-3.6-27b) *served by Tensormesh* *Unverified-retention opt-in* | `qwen-3.6-27b` | 262K | \$0.32 / \$3.2 | Tools |
| [Qwen 3.6 Flash](/models/catalog/qwen-3.6-flash) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.6-flash` | 1M | \$0.188 / \$1.13 | Tools, Caching, 1M ctx |
| [Qwen 3.6 Plus](/models/catalog/qwen-3.6-plus) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.6-plus` | 1M | \$0.325 / \$1.95 | Tools, Caching, 1M ctx |
| [Qwen 3.7 Flash](/models/catalog/qwen-3.7-flash) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.7-flash` | 1M | \$0.03 / \$0.13 | Tools, Caching, 1M ctx |
| [Qwen 3.7 Max](/models/catalog/qwen-3.7-max) *served by Together AI* | `qwen-3.7-max` | 1M | \$1.25 / \$3.75 | Tools, 1M ctx |
| [Qwen 3.7 Max (Alibaba)](/models/catalog/qwen-3.7-max-alibaba) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.7-max-alibaba` | 1M | \$1.48 / \$4.42 | Tools, Caching, 1M ctx |
| [Qwen 3.7 Plus](/models/catalog/qwen-3.7-plus) *served by Fireworks AI* | `qwen-3.7-plus` | 1M | \$0.4 / \$1.6 | Tools, Caching, 1M ctx |
| [Qwen 3.7 Plus (Alibaba)](/models/catalog/qwen-3.7-plus-alibaba) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.7-plus-alibaba` | 1M | \$0.32 / \$1.28 | Tools, Caching, 1M ctx |
| [Qwen 3.8 Flash](/models/catalog/qwen-3.8-flash) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.8-flash` | 1M | \$0.15 / \$0.47 | Tools, Caching, 1M ctx |
| [Qwen 3.8 Max](/models/catalog/qwen-3.8-max) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `qwen-3.8-max` | 1M | \$2 / \$6 | Tools, Caching, 1M ctx |
| [Qwen 3.8 Max (DeepInfra)](/models/catalog/qwen-3.8-max-deepinfra) | `qwen-3.8-max-deepinfra` | 256K | \$1.65 / \$4.95 | Tools, Caching |
| [Qwen 3.8 Max (Novita)](/models/catalog/qwen-3.8-max-novita) *served by Novita AI* | `qwen-3.8-max-novita` | 1M | \$2 / \$6 | Tools, Caching, 1M ctx |
| [Qwen3 Coder 480B](/models/catalog/qwen3-coder-480b) *served by Tensormesh* *Unverified-retention opt-in* | `qwen3-coder-480b` | 262K | \$0.45 / \$1.8 | Tools, Caching |

## xAI

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [Grok 3](/models/catalog/grok-3) | `grok-3` | 131K | \$1.25 / \$2.5 | Tools, Caching |
| [Grok 3 Mini](/models/catalog/grok-3-mini) | `grok-3-mini` | 131K | \$0.3 / \$0.5 | Tools, Caching |
| [Grok 4.1 Fast](/models/catalog/grok-4-1-fast-non-reasoning) | `grok-4-1-fast-non-reasoning` | 2M | \$1.25 / \$2.5 | Tools, Caching, 1M ctx |
| [Grok 4.1 Fast (Reasoning)](/models/catalog/grok-4-1-fast-reasoning) | `grok-4-1-fast-reasoning` | 2M | \$1.25 / \$2.5 | Tools, Caching, 1M ctx |
| [Grok 4.20](/models/catalog/grok-4-20) | `grok-4-20` | 2M | \$1.25 / \$2.5 | Vision, Tools, Caching, 1M ctx |
| [Grok 4.20 Multi-Agent](/models/catalog/grok-4-20-multi-agent) | `grok-4-20-multi-agent` | 2M | \$1.25 / \$2.5 | Vision, Tools, Caching, 1M ctx |
| [Grok 4.20 (Non-Reasoning)](/models/catalog/grok-4-20-non-reasoning) | `grok-4-20-non-reasoning` | 2M | \$1.25 / \$2.5 | Vision, Tools, Caching, 1M ctx |
| [Grok 4.3](/models/catalog/grok-4-3) | `grok-4-3` | 1M | \$1.25 / \$2.5 | Vision, Tools, Caching, 1M ctx |
| [Grok 4.5](/models/catalog/grok-4-5) | `grok-4-5` | 500K | \$2 / \$6 | Vision, Tools, Caching |
| [Grok 4.6](/models/catalog/grok-4-6) | `grok-4-6` | 500K | \$2 / \$6 | Vision, Tools, Caching |
| [Grok Build 0.1](/models/catalog/grok-build-0-1) | `grok-build-0-1` | 256K | \$1 / \$2 | Vision, Tools, Caching |

## Z.ai

| Model | Model id | Context | In / out per 1M | Capabilities |
| - | - | - | - | - |
| [GLM 4.7 (Amazon Bedrock)](/models/catalog/glm-4.7-bedrock) | `glm-4.7-bedrock` | 203K | \$0.6 / \$2.2 | Tools |
| [GLM 4.7 (DeepInfra)](/models/catalog/glm-4.7-deepinfra) | `glm-4.7-deepinfra` | 203K | \$0.4 / \$1.75 | Tools, Caching |
| [GLM 4.7 (Novita)](/models/catalog/glm-4.7-novita) *served by Novita AI* | `glm-4.7-novita` | 205K | \$0.6 / \$2.2 | Tools, Caching |
| [GLM 5.2](/models/catalog/glm-5.2) *served by DeepInfra* | `glm-5.2` | 1.05M | \$0.563 / \$1.8 | Tools, Caching, 1M ctx |
| [GLM 5.2 (Alibaba)](/models/catalog/glm-5.2-alibaba) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `glm-5.2-alibaba` | 1.05M | \$0.966 / \$3.04 | Tools, Caching, 1M ctx |
| [GLM 5.2 (Baseten)](/models/catalog/glm-5.2-baseten) | `glm-5.2-baseten` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.2 (DeepInfra)](/models/catalog/glm-5.2-deepinfra) | `glm-5.2-deepinfra` | 1.05M | \$0.563 / \$1.8 | Tools, Caching, 1M ctx |
| [GLM 5.2 (GMI Cloud)](/models/catalog/glm-5.2-gmicloud) *Unverified-retention opt-in* | `glm-5.2-gmicloud` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.2 (Novita)](/models/catalog/glm-5.2-novita) *served by Novita AI* | `glm-5.2-novita` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.2 (StreamLake)](/models/catalog/glm-5.2-streamlake) *China-hosted, China-hosted opt-in, Training-consent opt-in* | `glm-5.2-streamlake` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.2 (Tensormesh)](/models/catalog/glm-5.2-tensormesh) *Unverified-retention opt-in* | `glm-5.2-tensormesh` | 250K | \$1.4 / \$4.4 | Tools |
| [GLM 5.2 (Together)](/models/catalog/glm-5.2-together) *served by Together AI* | `glm-5.2-together` | 512K | \$1.4 / \$4.4 | Tools, Caching |
| [GLM 5.3](/models/catalog/glm-5.3) *served by Fireworks AI* | `glm-5.3` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.3 (Baseten)](/models/catalog/glm-5.3-baseten) | `glm-5.3-baseten` | 1.05M | \$1.4 / \$4.4 | Tools, Caching, 1M ctx |
| [GLM 5.3 (DeepInfra)](/models/catalog/glm-5.3-deepinfra) | `glm-5.3-deepinfra` | 1.05M | \$0.563 / \$2.5 | Tools, Caching, 1M ctx |
| [GLM 5.3 Flash (Baseten)](/models/catalog/glm-5.3-flash-baseten) | `glm-5.3-flash-baseten` | 1.05M | \$0.15 / \$0.5 | Tools, Caching, 1M ctx |
| [GLM 5.3 Flash (GMI Cloud)](/models/catalog/glm-5.3-flash-gmicloud) *Unverified-retention opt-in* | `glm-5.3-flash-gmicloud` | 1.05M | \$0.113 / \$0.375 | Tools, Caching, 1M ctx |
| [GLM 5.3 Flash (Novita)](/models/catalog/glm-5.3-flash-novita) *served by Novita AI* | `glm-5.3-flash-novita` | 1.05M | \$0.15 / \$0.5 | Vision, Tools, Caching, 1M ctx |
| [GLM 5.3 (GMI Cloud)](/models/catalog/glm-5.3-gmicloud) *Unverified-retention opt-in* | `glm-5.3-gmicloud` | 1.05M | \$1.12 / \$3.52 | Tools, Caching, 1M ctx |


# Video models
Source: https://docs.aireserve.com/models/video

18 video models on the AI Reserve gateway — ids, serving providers, pricing and links to a copy-paste request for each.

Text-to-video, image-to-video and reference-to-video. Every request is an async job: submit, poll, download.

Endpoints: `POST /v1/videos/generations` · `GET /v1/videos/generations/{id}`. Prefer to search and filter? [Browse models](/models).

## Alibaba

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [wan-2.6](/models/catalog/wan-2.6) *served by fal* | `wan-2.6` | Text-to-video | 720p \$0.1/s, 1080p \$0.15/s |
| [wan-3.0-prime-reference](/models/catalog/wan-3.0-prime-reference) *served by fal* | `wan-3.0-prime-reference` | Reference-to-video | 480p \$0.068/s, 720p \$0.14/s, 1080p \$0.28/s |
| [wan3.0-i2v-higgsfield](/models/catalog/wan3.0-i2v-higgsfield) *served by Higgsfield* *Training-consent opt-in, Unverified-retention opt-in* | `wan3.0-i2v-higgsfield` | Image-to-video | see guide for per-resolution rates |
| [wan3.0-reference-higgsfield](/models/catalog/wan3.0-reference-higgsfield) *served by Higgsfield* *Training-consent opt-in, Unverified-retention opt-in* | `wan3.0-reference-higgsfield` | Reference-to-video | see guide for per-resolution rates |
| [wan3.0-video](/models/catalog/wan3.0-video) *served by Alibaba Cloud* *China-hosted, China-hosted opt-in* | `wan3.0-video` | Text-to-video | 480p \$0.05/s, 720p \$0.1/s, 1080p \$0.2/s |
| [wan3.0-video-higgsfield](/models/catalog/wan3.0-video-higgsfield) *served by Higgsfield* *Training-consent opt-in, Unverified-retention opt-in* | `wan3.0-video-higgsfield` | Text-to-video | see guide for per-resolution rates |

## Black Forest Labs

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [flux-3-i2v](/models/catalog/flux-3-i2v) *served by fal* | `flux-3-i2v` | Image-to-video | 720p \$0.17/s, 1080p \$0.29/s |

## ByteDance

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [seedance-2.0](/models/catalog/seedance-2.0) *served by fal* | `seedance-2.0` | Text-to-video | 480p \$0.141/s, 720p \$0.303/s, 1080p \$0.682/s, 4k \$1.56/s |
| [seedance-2.0-bytedance](/models/catalog/seedance-2.0-bytedance) *served by ByteDance Ark* *China-hosted, China-hosted opt-in* | `seedance-2.0-bytedance` | Text-to-video | 480p \$0.067/s, 720p \$0.151/s, 1080p \$0.374/s, 4k \$0.778/s |
| [seedance-2.0-fast](/models/catalog/seedance-2.0-fast) *served by ByteDance Ark* *China-hosted, China-hosted opt-in* | `seedance-2.0-fast` | Text-to-video | 480p \$0.054/s, 720p \$0.121/s |
| [seedance-2.0-mini](/models/catalog/seedance-2.0-mini) *served by ByteDance Ark* *China-hosted, China-hosted opt-in* | `seedance-2.0-mini` | Text-to-video | 480p \$0.034/s, 720p \$0.076/s |
| [seedance-2.0-mini-reference](/models/catalog/seedance-2.0-mini-reference) *served by fal* | `seedance-2.0-mini-reference` | Reference-to-video | 480p \$0.072/s, 720p \$0.155/s |
| [seedance-2.5](/models/catalog/seedance-2.5) *served by ByteDance Ark* *China-hosted, China-hosted opt-in* | `seedance-2.5` | Text-to-video | 480p \$0.103/s, 720p \$0.231/s, 1080p \$0.569/s |
| [seedance-2.5-reference](/models/catalog/seedance-2.5-reference) *served by fal* | `seedance-2.5-reference` | Reference-to-video | 480p \$0.221/s, 720p \$0.473/s, 1080p \$1.16/s |

## MiniMax

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [minimax-h3-max-i2v](/models/catalog/minimax-h3-max-i2v) *served by fal* | `minimax-h3-max-i2v` | Image-to-video | 480p \$0.05/s, 768p \$0.08/s, 1080p \$0.16/s |

## xAI

| Model | Model id | Type | Pricing |
| - | - | - | - |
| [grok-imagine-video-1.5-i2v](/models/catalog/grok-imagine-video-1.5-i2v) *served by fal* | `grok-imagine-video-1.5-i2v` | Image-to-video | 480p \$0.08/s, 720p \$0.14/s, 1080p \$0.25/s · + \$0.01 per input image |
| [grok-imagine-video-1.5-reference](/models/catalog/grok-imagine-video-1.5-reference) *served by fal* | `grok-imagine-video-1.5-reference` | Reference-to-video | 480p \$0.08/s, 720p \$0.14/s · + \$0.01 per input image |
| [grok-imagine-video-i2v](/models/catalog/grok-imagine-video-i2v) *served by fal* | `grok-imagine-video-i2v` | Image-to-video | 480p \$0.05/s, 720p \$0.07/s · + \$0.002 per input image |


# Gateway latency benchmark
Source: https://docs.aireserve.com/performance/gateway-latency

How much latency AI Reserve adds on top of calling the provider directly, measured side by side with OpenRouter and Vercel AI Gateway on the same models, the same providers, from the same client.

A gateway earns its place by adding capabilities without adding noticeable latency. We
measure ours the hard way: the same request, to the same model at the same provider, sent
through each gateway and to the provider directly, interleaved from one client, and we
publish the paired difference. The method, the numbers and the raw data are below.

## What is measured

* **Two surfaces, one model each.** Anthropic Messages with Claude Sonnet 4.6 served by
  Anthropic, and OpenAI Responses with GPT-5.5 served by OpenAI: the two wire formats every
  gateway in the comparison serves, so the provider side is identical for every target.
* **Pinned providers.** Each gateway is asked for the same upstream provider by its own
  routing controls (for example OpenRouter's `provider.order` with `allow_fallbacks: false`),
  so no target wins by routing to a different host.
* **Two numbers per target.** For streaming requests, time to the first text token (TTFT).
  For non-streaming requests, total time to the complete response. Both from the client's
  side, from the moment the request is sent.
* **Paired overhead, with its uncertainty.** In every round each target is called once in
  random order. A gateway's overhead is the median, over all rounds, of its time minus the
  direct provider call's time in the same round, which cancels the provider's own
  minute-to-minute drift. Each median is published with a 95% confidence interval
  (1.58 × IQR ÷ √rounds, the notched box-plot rule). A median that does not clear its own
  interval is labelled **within noise**: the run cannot tell that gateway apart from calling
  the provider directly, in either direction.
* **Small output, by design.** `max_tokens: 32` and the prompt "Reply with exactly one
  word: pong." keep generation time short, so the numbers measure the path, not the model.
* **One client.** A GitHub-hosted runner in the US East region, warm-up request per target
  excluded. The number of rounds is stated with each run (60 per mode for runs from
  2026-10-18 on; the first published run used 20). More rounds narrow the intervals and
  steady the medians.

## Results

Run of 2026-10-18 (UTC), 60 rounds per mode, `max_tokens: 32`, targets: Anthropic directly, OpenAI directly, AI Reserve, OpenRouter, Vercel AI Gateway.

**Anthropic Messages, Claude Sonnet 4.6 at Anthropic**

Overhead added on top of calling the provider directly (median of paired rounds, ± its 95% confidence interval):

| Gateway | Stream, to first token | Non-stream, total |
| - | - | - |
| AI Reserve | +101 ±30 ms | +105 ±28 ms |
| OpenRouter | within noise (−4 ±40 ms) | +44 ±31 ms |
| Vercel AI Gateway | +162 ±62 ms | +199 ±64 ms |

"Within noise" means the median does not clear its own interval: the run cannot tell that gateway apart from calling the provider directly, in either direction.

Absolute latency from the runner, p50 (p95), and the fastest single round:

| Target | Stream, to first token | Non-stream, total |
| - | - | - |
| Anthropic directly | 728 (1006) ms, best 580 | 775 (1115) ms, best 618 |
| AI Reserve | 816 (1158) ms, best 650 | 868 (1342) ms, best 714 |
| OpenRouter | 697 (1048) ms, best 568 | 842 (1267) ms, best 669 |
| Vercel AI Gateway | 910 (1244) ms, best 610 | 980 (2166) ms, best 754 |

Model ids as sent: Anthropic directly `claude-sonnet-4-6`, AI Reserve `claude-sonnet-4-6`, OpenRouter `anthropic/claude-sonnet-4.6`, Vercel AI Gateway `anthropic/claude-sonnet-4.6`.

**OpenAI Responses, GPT-5.5 at OpenAI**

Overhead added on top of calling the provider directly (median of paired rounds, ± its 95% confidence interval):

| Gateway | Stream, to first token | Non-stream, total |
| - | - | - |
| AI Reserve | +132 ±38 ms | within noise (+39 ±42 ms) |
| OpenRouter | +466 ±60 ms | +225 ±54 ms |
| Vercel AI Gateway | +73 ±50 ms | −69 ±36 ms |

Absolute latency from the runner, p50 (p95), and the fastest single round:

| Target | Stream, to first token | Non-stream, total |
| - | - | - |
| OpenAI directly | 750 (1225) ms, best 528 | 1007 (1335) ms, best 700 |
| AI Reserve | 885 (1228) ms, best 642 | 1053 (1370) ms, best 818 |
| OpenRouter | 1196 (1609) ms, best 970 | 1249 (1458) ms, best 916 |
| Vercel AI Gateway | 836 (1195) ms, best 604 | 947 (1299) ms, best 739 |

Model ids as sent: OpenAI directly `gpt-5.5`, AI Reserve `gpt-5.5`, OpenRouter `openai/gpt-5.5`, Vercel AI Gateway `openai/gpt-5.5`.

## Reading the numbers

* **Overhead** is what the gateway adds; the p50 and p95 columns include the provider's own
  latency, which dominates both.
* **A negative median is not, by itself, the gateway beating the provider.** A request
  through a gateway travels one more hop than a direct call, and the best rounds in the table
  show roughly what that hop costs: a gateway's fastest round is usually tens of milliseconds
  behind the provider's fastest. The sign of a median can come from the tail instead. A
  provider's own response time varies by a second or more from one request to the next, the
  pairing does not cancel that, and a run in which a few more slow responses happen to land
  on the direct calls tips the median negative. The interval says whether that happened. A
  negative median inside its own interval is within noise, and the honest reading is that the
  gateway added nothing the run could measure. One that clears its interval is a real but
  small effect, pooled already-open connections to the provider and a network path that
  happens to be shorter than the client's, and it is worth tens of milliseconds, not
  hundreds.
* **p95** shows tail behavior over a short run and moves between runs; the medians and their
  intervals are the stable comparison.
* The runner sits in one US region. A client in Europe or Asia sees different absolute
  numbers for every target, but the gateway overheads move together.

## What is not in this table

* **Other gateways.** The comparison covers the gateways that serve both surfaces above with
  provider pinning. We add a gateway when we can run it under the same rules, from the same
  client, with a production key.
* **Other models.** The two surfaces above are the ones every target serves identically.
  Per-model latency across our own catalog is a different question, answered per model in
  the [catalog](/models) and in your own usage analytics.

## Reproduce it

Everything a run needs is on this page: the prompt, `max_tokens`, the model id sent to each
target, the provider-pinning rule, the interleaving and the paired-median definition. Send
the same request to each target from one client, alternate the order every round, and take
the median of the per-round differences together with its interval (1.58 × IQR ÷ √rounds).
We keep the raw per-request samples of every
published run (round, target, mode, status, time to first token, total time) and will share
them, or run the same harness against your own region or model mix, on request in your
shared Slack channel.


# Handling provider downtime
Source: https://docs.aireserve.com/reliability/business-continuity

Your continuity plan for the gateway: how you would know about an incident, how we keep you running through a provider incident, how you switch to a direct provider connection if the platform itself is down, what you never lose, and what we commit to.

No gateway can route around its own outage, and we would rather say so than imply otherwise.
What we can do is make an outage visible fast, make the switch to a direct provider
connection a configuration change rather than a migration, and leave nothing of yours
stranded. The platform side of the story, what is redundant and what is not, is on
[Reliability](/reliability).

## How you would know

* **Incident updates from us.** For any incident that affects your traffic we post in your
  shared Slack channel and email your organization's administrators: a first update within
  30 minutes of our detection, further updates at least hourly until it is resolved, an
  all-clear, and a written post-incident review within ten business days. The 30 minutes
  does not depend on anyone noticing: detection is automated (external checks on the API
  every 60 seconds, a platform-health sweep every 5 minutes, the provider status feed) and
  pages the engineer on duty at any hour, and the first update is deliberately short,
  focusing on what is affected, what we know, and when the next update will come, so that
  you are never waiting for information.
  Security incidents involving personal data follow the notice terms of the
  [Data Processing Agreement](https://aireserve.com/legal/dpa) in addition.
* **Provider status, live.** [aireserve.com/status](https://aireserve.com/status) aggregates
  the status pages of every provider behind the catalog, so you can see in one place whether
  the incident is upstream of us.
* **Your errors say which it is.** During a platform incident the API answers `503` with a
  stable `SERVICE_UNAVAILABLE` code and a `Retry-After` header, or stops answering at all; a
  provider incident surfaces as a provider-attributed error with `error.source` set, so your
  code can tell the two apart without waiting for a human. See
  [Errors](/api-reference/errors).
* **Anything else.** Write to [security@aireserve.com](mailto:security@aireserve.com); the
  inbox is monitored by our team around the clock, as is your shared Slack channel.

## How we keep you running

Two layers do this. During a provider incident the gateway itself keeps your requests
flowing: same-model failover to a sibling provider and the fallback chains you configure,
described in the next section, all without you changing anything. If the platform itself is
unavailable, the second layer is yours: the API is wire-compatible with OpenAI (Chat
Completions and Responses), Anthropic (Messages) and the Bedrock SDK surface, so a client
that points at AI Reserve can point at the provider directly by changing a base URL and a
key, with no code change. Keep that switch ready before you need it.

### Keep a direct provider path ready

| If you use | Direct-provider switch |
| - | - |
| OpenAI SDK (Python, TypeScript, others) | Drop the `base_url` override and use your OpenAI key. OpenAI model ids are unchanged (`gpt-5.5`). |
| Anthropic SDK | Drop the `base_url` override and use your Anthropic key. Claude model ids are unchanged (`claude-sonnet-4-6`). |
| Claude Code | Unset `ANTHROPIC_BASE_URL` and `ANTHROPIC_AUTH_TOKEN`, then set `ANTHROPIC_API_KEY` to your Anthropic key. |
| Codex CLI | Set `model_provider` back to the built-in `openai` entry in `~/.codex/config.toml`, with `OPENAI_API_KEY` in the environment. |
| Cursor, Zed, Cline, Continue, Aider, Roo | Clear the custom base URL; the tool uses its built-in provider with your own key. |
| AWS SDK (Bedrock surface) | Remove the endpoint override; your AWS credentials talk to Bedrock directly. |
| Any other OpenAI-compatible provider (xAI, Google Gemini, Alibaba Cloud Model Studio, Mistral, DeepSeek, Fireworks, Groq, …) | Point the same OpenAI SDK client at that provider's OpenAI-compatible endpoint with its key. Use the model id from the [catalog](/models), which names the provider behind every entry. |

For first-party models (OpenAI, Anthropic, Google, xAI) the catalog id is the provider's own
model id, so nothing else changes. For open-weight models served by a third-party host, the
[catalog](/models) names the provider behind each entry; use that provider's id for the same
weights. The one shape that does not transfer is a provider-native SDK the gateway does not
speak (for example Google's GenAI SDK): keep an OpenAI-compatible client as the direct path
for those providers.

### Ride out a provider incident without leaving the gateway

Most incidents are upstream of us: one provider is down or throttling while the rest of the
catalog is fine. Two things stand between that and your users, and both run on our side:

* **Same model, another provider, automatically.** Several models are served by more than
  one provider with identical weights and paired for failover (the Claude models on Anthropic
  and on Amazon Bedrock, for example). Once failover is on for your organization, a request
  that fails at the primary provider is retried on the sibling provider by the gateway, same
  model, same request, with nothing to configure per model and nothing for your code to do.
  The response names the leg that served in `x-aireserve-served-model` (for example
  `claude-sonnet-4-6-bedrock`), and `x-aireserve-served-provider` as well when the request
  rode a configured pin or pool.
* **Your fallback chain.** For a model you have chained, the gateway walks the chain of
  models you accept, in order, on the same failures (put the sibling provider first to keep
  the same weights ahead of a different model). You set it once per model in the portal
  under Inference → Router, or per request with `models: [...]`; a model you have not
  chained gets the sibling failover above and nothing more.

Both are off until you turn them on: configuring any fallback chain in the portal (or
sending `models` on a request) switches failover on for your organization, and requests on
your own provider keys ([BYOK](/capabilities/byok)) never fail over to another provider.
Every attempt goes through AI Reserve on your key, so billing, usage history and policy are
unchanged. Details and edge cases: [Fallback models](/capabilities/fallbacks).

The rest of this section is the same chain written on your side, for teams that prefer to
own it in code. The gateway relays provider incidents as provider-attributed errors
(`error.source` is `provider`), and the fix is to switch models, not endpoints: keep a short
chain of models you accept, one per provider, and walk it in order.

The SDK's built-in retries handle blips on their own (connection errors, 408, 429 and 5xx
with backoff, honoring `Retry-After`). Move to the next model only when a model is still
failing after those retries. Never move on a 4xx: that is a request you need to fix, and a
`402` is a spend cap doing its job. If `error.source` is `platform`, the chain cannot help
and the [direct-provider switch](#keep-a-direct-provider-path-ready) above applies instead.

```python Python theme={"dark"}
import os
from openai import OpenAI, APIConnectionError, APITimeoutError, InternalServerError

client = OpenAI(base_url="https://api.aireserve.com/v1", api_key=os.environ["AIRESERVE_API_KEY"])

# One model per provider, in order of preference. Every attempt goes through the gateway.
CHAIN = ["claude-fable-5-1", "gpt-5.5", "kimi-k3-fireworks"]

def complete(**request):
    # `request` is the whole call (messages, temperature, tools, stream, ...).
    # Only `model` changes between attempts; the chain owns it, the caller owns the rest.
    last = None
    for model in CHAIN:
        try:
            return client.chat.completions.create(model=model, **request)
        except InternalServerError as err:
            if (err.body or {}).get("error", {}).get("source") == "platform":
                raise  # the gateway itself is failing: switch endpoints, not models
            last = err  # provider still failing after the SDK's retries: next provider
        except (APIConnectionError, APITimeoutError) as err:
            last = err
    raise last

response = complete(
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "Summarize ticket #4821."},
    ],
    temperature=0.2,
    max_tokens=300,
)
print(response.model, response.choices[0].message.content)
```

```typescript TypeScript theme={"dark"}
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.aireserve.com/v1", apiKey: process.env.AIRESERVE_API_KEY });

// One model per provider, in order of preference. Every attempt goes through the gateway.
const CHAIN = ["claude-fable-5-1", "gpt-5.5", "kimi-k3-fireworks"];

type Request = Omit<OpenAI.ChatCompletionCreateParamsNonStreaming, "model">;

function platformFault(err: unknown): boolean {
  return err instanceof OpenAI.APIError && (err.error as { source?: string } | undefined)?.source === "platform";
}

function providerFault(err: unknown): boolean {
  if (err instanceof OpenAI.APIConnectionError) return true;
  return err instanceof OpenAI.APIError && typeof err.status === "number" && err.status >= 500;
}

export async function complete(request: Request) {
  // Only `model` changes between attempts; the chain owns it, the caller owns the rest.
  let last: unknown;
  for (const model of CHAIN) {
    try {
      return await client.chat.completions.create({ ...request, model });
    } catch (err) {
      if (platformFault(err) || !providerFault(err)) throw err; // ours to fix, or yours: a 4xx
      last = err; // provider still failing after the SDK's retries: next provider
    }
  }
  throw last;
}

const response = await complete({
  messages: [
    { role: "system", content: "Answer in two sentences." },
    { role: "user", content: "Summarize ticket #4821." },
  ],
  temperature: 0.2,
  max_tokens: 300,
});
console.log(response.model, response.choices[0].message.content);
```

The same chain with no code: send `models: [...]` on the request and the gateway walks it
for you, naming the model that answered in the `x-aireserve-served-model` header. See
[Fallback models](/capabilities/fallbacks).

Two practical notes:

* **Streaming.** The same chain applies to streamed requests; move to the next model only
  when the stream fails before its first token. A stream that breaks mid-answer is a retry
  of the same request, not a reason to change models.
* **Test the chain.** Run every model in it from staging once a quarter, the same way you
  would test a backup restore. A fallback nobody has exercised is a hope, not a plan.

### Your own provider keys

With [BYOK](/capabilities/byok), requests ride your own OpenAI, Anthropic or other provider
account through AI Reserve. Those keys work with us and without us, so the direct-provider
switch above needs no second account and no new billing relationship. Customers on platform
keys should keep a provider account on standby for the models that matter most; we are glad
to help set one up and to size its rate limits against your traffic.

## What you never lose

* **Your keys and credentials** are yours. AI Reserve keys can be rotated or revoked by your
  administrators at any time; BYOK keys stay in your provider account.
* **Your usage history.** Every request is a row in your usage analytics, with requested and
  served model, tokens, cost, status and latency, exportable as CSV from the portal's
  analytics or through the [MCP usage tools](/connect/mcp-tools), so a finance close or an
  audit never depends on a single moment of uptime.
* **Your data.** API prompts and responses pass through the gateway in memory only and are
  never written to disk; what is stored is usage metadata. Content that the optional web chat
  stores for history is deleted within 14 days of a verified request. The authoritative
  statements are on [privacy.aireserve.com](https://privacy.aireserve.com).
* **No lock-in by format.** Because the wire formats are the providers' own, there is no
  AI Reserve-specific request shape to unwind.

## What we commit to

| Commitment | Detail |
| - | - |
| Honest errors | Platform faults, provider faults and caller errors are distinguishable by code and `error.source`; a failure that was ours is never dressed as yours. |
| Incident communication | First update within 30 minutes of detection, updates at least hourly, an all-clear, and a written review within ten business days for affected customers. |
| Personal-data incidents | Notice per the Data Processing Agreement's incident terms. |
| No charge for failures | A request that fails at the gateway or at the provider is not billed; the wallet reservation is released. |
| Published measurements, not a paper SLA | We publish measured availability on [Reliability](/reliability) and will publish a service-level agreement with credits once cross-region failover is in place and exercised. |
| Your exit | Keys, usage history and the direct-provider switch above are available at any time, incident or not. |


# Reliability
Source: https://docs.aireserve.com/reliability/index

How the gateway stays up: provider failover, traffic splitting, transport recovery, a multi-zone platform with highly available data stores, deploy safety, and the numbers we measure ourselves against.

An AI gateway can fail you in two ways: the provider behind your model can go down, or the
gateway itself can. This page covers what is in place for both, in plain terms, including
the parts that are not redundant yet. The companion page,
[Handling provider downtime](/reliability/business-continuity), covers how you would know
about an incident, how we keep you running, and what we commit to.

## The short version

| Layer | What is in place |
| - | - |
| Provider failover | [Fallback chains](/capabilities/fallbacks) per request or per organization, platform provider failover for models served by more than one provider, and a fleet-wide health breaker that routes around a failing provider and probes it back in. |
| Traffic splitting | Weighted pools across providers that serve identical weights, with a canary that trips a degraded leg out of the split automatically. Every response discloses which model and provider answered. |
| Transport recovery | Connection retries, a one-time re-send of a stream that drops before its first byte, first-token budgets and end-to-end request deadlines, so a hung provider never hangs you. |
| Platform | A multi-zone Google Cloud region, independently autoscaled services with warm minimums, a regional high-availability PostgreSQL with point-in-time recovery, high-availability Redis, a global load balancer. |
| Change safety | Every change ships to a full staging environment first, production deploys are approved and configuration-guarded, a post-deploy error canary watches the cutover, and rollback is one command. |
| Monitoring | External uptime checks every 60 seconds, a platform-health sweep every 5 minutes, a provider status feed, and alerting to the team around the clock. |

## Provider failover

**Fallback chains.** Name the models you accept, in order, on the request (`models` or
`fallbacks`) or set a default chain per model in the portal under Inference → Router. When
the primary fails on an upstream error (provider 5xx, rate limit, timeout, connection error)
after the gateway's own retries, the same request is sent to the next model in your list.
The response carries `x-aireserve-served-model` whenever something other than the primary
answered. Details, limits and edge cases: [Fallback models](/capabilities/fallbacks).

**Platform provider failover.** Several models are served by more than one provider with
identical weights, for example the Claude models on Anthropic and on Amazon Bedrock. Once
failover is on for your organization, a failure at the primary provider rolls the same
request to the sibling leg automatically: same model, same request, nothing to configure per
model and nothing for your code to do. Your ledger records both the model you asked for and
the leg that served, so billing and reporting follow what actually ran.

**Who turns it on.** Failover is off for a new organization, so a provider's real error
reaches you instead of a serve on a model nobody chose. Your administrators switch it on in
the portal: configuring any fallback chain under Inference → Router enables both layers for
the organization (provider failover for the models we have paired across providers, plus
the chains you wrote for specific models), and a single request opts in on its own by
carrying `models`.
To keep a chained model on the same weights first, list its sibling as the first rung
(`claude-sonnet-4-6-bedrock` ahead of a different model, for example). We can also set a
chain up for you; ask in your shared Slack channel.

**Health breaker.** Provider legs share one health record across the whole gateway fleet.
Three slow failures (hangs or 5xx) on a leg inside a rolling two-minute window trip it open:
new requests from organizations with a chain are routed to the next healthy rung instead of
each one rediscovering the failure and paying the full timeout. A leg closes again only after
consecutive successful synthetic probes, never on a timer, so a provider that is still sick
does not get traffic back. Rate limits (429) deliberately do not trip the breaker; they are
handled per request by retries and the chain walk, which costs milliseconds rather than a
leg.

**What never fails over.** Errors that are yours to fix (a malformed request, an unknown
model, a budget or spend cap you have exhausted) are returned honestly with a
[stable error code](/api-reference/errors) and are never retried on another model.
Requests on your own provider key ([BYOK](/capabilities/byok)) never fall back to a
different provider.

## Traffic splitting and routing control

**Serving pools.** For a model served on more than one provider with identical weights, we
can split an organization's traffic across those providers by weight, for example 70/30
between Anthropic and Bedrock, including a minimum-prompt-size rule so only long prompts take
a given leg. A canary compares each leg with the source leg over consecutive five-minute
windows on p95 latency, cache-hit ratio, rate-limit rate and upstream error rate, and trips a
degraded leg out of the split automatically; its share redistributes to the healthy legs and
a human re-arms it after the cause is understood. Ask us to set a pool up for your
organization.

**Routing variants and pins.** `:nitro` and `:floor` suffixes ask for the fastest or the
cheapest provider of a model per request, and an organization can pin a model to one provider
for data-residency or contractual reasons. See
[Provider routing variants](/models#provider-routing-variants).

**Disclosure.** Whenever a request is answered by something other than exactly what you asked
for, the response says so: `x-aireserve-served-model` names the model that answered and
`x-aireserve-served-provider` the provider, and the usage ledger keeps the requested and
served identities side by side on every row. No header means the request was served as
requested.

## Transport recovery

* **Stale connections.** A connection to the inference engine or a provider that was closed
  on the far side while idle is retried once at connect time, before anything is sent.
* **Streams that die before the first byte.** A streamed request whose provider connection
  drops before any content has been written is re-sent once, automatically. Nothing has
  reached you and nothing has been billed, so the retry is invisible.
* **First-token and silence budgets.** A stream that produces no first token inside its
  budget is cut with a 504 instead of hanging your client, and the leg that hung is counted
  against its health. Once content is flowing, only silence can end a stream, never a wall
  clock, so long generations are safe.
* **Deadlines.** The request budget is minted at the edge and travels with the request to
  every hop, so a slow upstream is given up on at the budget, not after a chain of nested
  timeouts.
* **Retry-After.** Every 503 the gateway answers for itself carries `Retry-After`, and the
  SDKs' default retry policies honor it. See [Retry policy](/api-reference/errors#retry-policy-bedrock-standard-mode-analog).

## The platform

| Component | Posture |
| - | - |
| Region | Google Cloud `us-east4` (Northern Virginia). Every service runs across the region's zones; a single zone failure is absorbed. |
| Edge | A global external Application Load Balancer with Google-managed TLS in front of the API, with no CDN in the path so streams are never buffered. A Cloud Armor policy sits at the edge. |
| Serving tier | Four independently scaled services (API gateway, inference proxy, inference engine, portal) on Cloud Run, each with warm minimum instances, startup CPU boost and no CPU throttling, scaling to dozens of instances under load. |
| Database | Cloud SQL for PostgreSQL in regional high-availability mode (synchronous standby in a second zone, automatic failover), point-in-time recovery, and seven daily backups. |
| Cache and coordination | Memorystore for Redis in standard high-availability mode with an automatic failover replica. The request-path features that use it (rate limiting, the health breaker) fail open or fall back to a per-instance copy if Redis is unavailable, rather than failing requests. |
| Secrets | Google Secret Manager, mounted at deploy time; provider keys never live in images or code. |

> [!WARNING]
>
> **One region today.** Multi-zone protects against a zone or instance failure, not against a region-wide Google Cloud
> event, which would take the API down until the region recovers. There is no automatic cross-region failover yet; a
> second region in active-passive mode is the next infrastructure milestone, and [Handling provider
> downtime](/reliability/business-continuity) covers what you do in the meantime.

## Change safety

* **Staging first, every time.** Every merge deploys to a full staging environment (same
  services, same configuration shape) and runs the smoke suite before anything reaches
  production.
* **Approved, pinned production deploys.** Production deploys are dispatched explicitly,
  reviewer-approved and pinned to a commit. A configuration guard refuses a deploy that would
  silently change a strict serving flag.
* **Post-deploy error canary.** After traffic cuts over, a canary compares each serving
  service's error rate against the window before the deploy and raises an alarm on a
  regression.
* **Rollback is one command.** Previous revisions are retained; a rollback is a traffic switch
  to the last known-good revision, done by a person within minutes.
* **Smoke test on a real path.** The suite exercises the production path customers use
  (gateway, proxy, engine, providers, voice) rather than an internal shortcut.

## Monitoring and alerting

* External uptime checks from Google's global checker fleet probe the API and the portal
  every 60 seconds over the same DNS, certificate and load-balancer path customers use.
* A platform-health sweep runs every 5 minutes with detectors for success rate, latency and
  timeouts per model and provider, provider-origin and router-origin rate limiting,
  settlement lag, traffic flat-lines and per-customer latency; each fires once per crossing,
  with a cooldown, and posts a recovery line when it clears.
* Provider status pages are aggregated at [aireserve.com/status](https://aireserve.com/status)
  so you can see at a glance whether an incident is upstream.
* Alerts reach the team in Slack and by email at any hour; billing and provider-account
  canaries run every 15 minutes so a dead provider key is found before you find it.

## What we measure

Figures for the 30 days to October 14, 2026, measured at the API edge (every request to
`api.aireserve.com`, all customers, all endpoints):

| Measure | Result |
| - | - |
| Requests | 7.5 million |
| Requests answered without a 5xx, provider-caused failures counted against us | 99.90% |
| Outage windows (five-minute windows where most requests failed) | None |
| Degraded windows (five-minute windows with more than 10% 5xx) | Five short periods, about 40 minutes in total. The majority were caused by our own components, not by providers; each has a fix in place or in progress. |

We publish these numbers rather than a service-level agreement. No uptime guarantee or
service credits are in force today; an SLA follows once cross-region failover is in place and
has been exercised. If you need the same figures for your own traffic, your usage analytics
carry status and latency per request, and your account team can pull them for a review.

Questions, or a questionnaire to fill in? Write to [security@aireserve.com](mailto:security@aireserve.com)
or ask in your shared Slack channel.


# Data & privacy
Source: https://docs.aireserve.com/trust/data-privacy

Where your prompts go, which subprocessors we use, and how each provider handles data — the authoritative disclosures.

The authoritative privacy and security disclosures live on our privacy site,
[privacy.aireserve.com](https://privacy.aireserve.com) — a narrative security
overview as the front door, with the per-provider data-handling matrix and the
subprocessor list behind it — and are kept continuously up to date there. This
site links to them rather than copying them, so there is exactly one source of
truth.

> **[Provider Data Handling](https://privacy.aireserve.com/data-handling)**
>
> What each model provider receives, retention windows, and training-use commitments —
> per provider, per model family.

> **[Subprocessors](https://privacy.aireserve.com/subprocessors)**
>
> The current list of subprocessors that support the AI Reserve platform, and what each
> one does.

Looking for which models are served under PRC jurisdiction? See the
[China-hosted models](/models#china-hosted-models) note in the model catalog.

> [!NOTE]
>
> Every request through the gateway is metered against your organization's key with
> per-user and per-team spend controls and full usage analytics — see your
> [portal dashboard](https://portal.aireserve.com) for live usage.