One API.
Every intelligence.

Build with the world's leading AI models through a single, production-ready API.

One integration gives your application access to GPT, Claude, Gemini, DeepSeek, Grok, Qwen and every other model in the catalog — without managing separate providers, SDKs or infrastructure.

One API key 117 models live 19 providers Production ready
curl https://api.ultragpt.pro/v1/chat/completions \  -H "Authorization: Bearer $ULTRAGPT_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "gpt-6-astra",    "messages": [      {        "role": "user",        "content": "Explain quantum computing simply."      }    ]  }'
Sample cURL request for model gpt-6-astra.
Why UltraGPT API

Build once. Switch intelligence anytime.

One integration

Connect once instead of maintaining a separate integration, SDK and auth flow for every provider you want to reach.

Every model

Every model in the catalog answers to the same request shape — pick any of them by id, nothing else about the call changes.

Switch without rewriting

Change the model with a single parameter. Messages, tools and streaming all carry over untouched.

Production ready

Streaming, structured outputs, tool calling and a routing layer built to sit in front of a real application.

One API, many providers

One endpoint. Hundreds of models.

Every provider below is live in the catalog right now, synced automatically — not a fixed list we update by hand. 117 models, one request shape.

OpenAI20
AAlibaba12
Google10
XxAI9
Anthropic7
DeepSeek6
ByteDance5
Cohere4
ZZ.ai4
Xiaomi3
KKling3
BBlack Forest Labs2
  • OpenAI20
  • AAlibaba12
  • Google10
  • XxAI9
  • Anthropic7
  • DeepSeek6
  • ByteDance5
  • Cohere4
  • ZZ.ai4
  • Xiaomi3
  • KKling3
  • BBlack Forest Labs2

+7 more providers in the full model directory.

Model switching

Change the model. Keep your code.

Pick a different model below and watch the request: one field changes, everything else — messages, headers, parsing — stays exactly as it was.

request.json
model: gpt-6-astra
{  "model": "gpt-6-astra",  "messages": [    {      "role": "user",      "content": "Draft a launch announcement for our new feature."    }  ]}
GPT-6 Astra
OpenAI

OpenAI's flagship model for demanding end-to-end work

model id
gpt-6-astra
context window
1.1M tokens
API price / 1M tokens
$10 in · $50 out
capabilities
tools · vision · reasoning
request shape
unchanged
your parsing code
unchanged
Request builder

Build a request. Know its cost before you send it.

Pick a live model and shape the request. You see the code that goes over the wire, the most it can cost at today's API prices, and how the API will treat each parameter. Then run it for real in the developer playground.

Parameters
Run in the developer playground
Pre-flight
$10 in · $50 out / 1M
GPT-6 Astragpt-6-astra
Input (estimate)
≈16 tok
Balance needed to start
≤$0.026

The worst case is input plus all 512 max_tokens at this model's API price. You're charged only for the tokens actually used, and a request that errors or returns nothing is free.

  • Fits the context window — ≈528 of 1.1M tokens (input + max_tokens)
  • temperature is supported — Sent to the provider as-is.
  • Streams as server-sent events — stream_options.include_usage adds a final chunk with usage and cost.

Prices and parameters come live from the API catalog. Need a key? Create one on the developer portal.

curl https://api.ultragpt.pro/v1/chat/completions \  -H "Authorization: Bearer $ULTRAGPT_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "gpt-6-astra",    "messages": [      {        "role": "user",        "content": "Write a short product description for an AI developer platform."      }    ],    "stream": true,    "stream_options": {      "include_usage": true    },    "temperature": 0.7,    "max_tokens": 512  }'
Multimodal

One API. Every format.

The same /v1/messages request carries text and vision. Dedicated endpoints cover image and audio. Coverage below is counted live from the catalog, not promised in copy.

Streaming

Responses that arrive as they happen.

Add "stream": true and read the response as server-sent events — each event a partial delta, the final one carrying the model id and stop reason.

cURL
curl https://api.ultragpt.pro/v1/chat/completions \  -H "Authorization: Bearer $ULTRAGPT_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "gpt-6-astra",    "messages": [      {        "role": "user",        "content": "What's next for AI infrastructure?"      }    ],    "stream": true,    "stream_options": {      "include_usage": true    }  }'
UltraGPT
Structured outputs & tools

Get JSON back. Call your own tools.

Structured outputs

Set "response_format" to a JSON schema on a model with structured-output support and get back a response that parses without cleanup.

{
"product": "UltraGPT API",
"price_usd": 19.9,
"features": [
"one request shape",
"400+ models",
"streaming"
]
}

Tool calling

Pass a tools array with JSON-Schema parameters. When the model asks to call one, run it your side and return the result as a tool message.

  1. 1User message
  2. 2UltraGPT
  3. 3Tool call requested
  4. 4Your tool runs
  5. 5Result returned
  6. 6Final response
Quickstart

From zero to production in minutes.

  1. Create your API key

    Sign in to the app, open Settings → API keys, and generate a key. Store it as an environment variable — never in client-side code.

  2. Choose a model

    Pick any model id from the catalog — a fast everyday chat model or a heavier reasoning one. The request shape never changes.

  3. Send your first request

    POST to /v1/messages with your key and a messages array. Swap languages below; the request is identical either way.

curl https://api.ultragpt.pro/v1/chat/completions \  -H "Authorization: Bearer $ULTRAGPT_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "model": "gpt-6-astra",    "messages": [      {        "role": "user",        "content": "Hello!"      }    ]  }'
Sample cURL request for model gpt-6-astra.

Need a key first? Create one in the app →

Documentation

Reference for everything above.

Every endpoint and parameter shown on this page has a full write-up in the real docs.

Quickstart

Make your first request

Full parameter reference, request/response examples and error codes for this section live in the docs.

Open in docs
Explore full documentation →
Architecture

Built for applications, not experiments.

Authentication

Every request carries your API key as a Bearer token over HTTPS.

Request routing

The router reads the model field and directs the request to the right provider.

Model normalization

One request/response shape across every model in the catalog, whatever the upstream provider expects.

Streaming

Server-sent events for models that support it, with the same delta framing regardless of provider.

Structured & tool responses

JSON-schema outputs and tool-call turns are normalized the same way as plain text.

Usage & workspaces

Per-project keys with their own usage reporting, all rolling up under one account.

Reliability

Built to hold up under real traffic.

The dashboard below is the shape a status page takes once it's wired to live metrics — the numbers shown now are an example, not a report.

API status
Live · checked 13:38 UTC
API status
Operational
Models monitored
117/117 up
Success rate, 24h
—
Median latency, 24h
—
Median time to first token
—
Monthly uptime target
99.9%
Default limits per key (the same for every account)600 requests / min · 50 concurrent · 2M tokens / min — test keys: 10 RPM, 1 concurrent
Per-model uptime and incidents on the status page →
Security

Your API. Your applications. Your control.

API key authentication

Every request is authenticated with a Bearer key from your account — no key, no response.

Transport over HTTPS

Requests and responses travel over HTTPS end to end, same as the rest of the API.

Per-project keys

Workspaces can issue a separate key per project or environment, each with its own usage reporting — revoking one never touches the others.

Keep keys server-side. A key pasted into client-side code is visible to anyone who opens dev tools. Manage keys in the app →

Application
HTTPS
UltraGPT API
Authenticated request
Model router
Usage

Simple usage-based API access.

API access runs through your UltraGPT subscription — the same plan as the app, no separate per-token bill to manage. Rates below are the same per-model figures shown in the model directory, useful for estimating what a given model costs to run.

ModelProviderInputOutput
Grok 4.7grok-4.7XxAI$2 / 1M tok$6 / 1M tok
GPT-6 Astragpt-6-astraOpenAI$10 / 1M tok$50 / 1M tok
Claude Opus 4.8claude-opus-4.8Anthropic$5 / 1M tok$25 / 1M tok
Gemini 3.8 Flashgemini-3.8-flashGoogle$0.75 / 1M tok$3.75 / 1M tok
Command A+command-a-plusCohere$0.3 / 1M tok$1.5 / 1M tok
GLM 5.2glm-5.2ZZ.ai$0.06 / 1M tok$7 / 1M tok
Hy3hy3OOther$0.132 / 1M tok$0.528 / 1M tok

Web search: $0.008 / search · Bring your own key: 5% fee · Cached input bills at each model's lower cached rate · Response-cache hits are free.

View API pricingSee subscription plans →
Use cases

Built for what you're building.

AI SaaS

Add multiple models to your product without a separate integration for every provider.

AI agents

Give agents access to several reasoning models behind one interface they already know how to call.

Coding assistants

Route coding tasks to models with strong tool calling and long context, without a second SDK.

Content platforms

Generate text and images from one API instead of stitching together separate providers.

Internal tools

Bring model access into internal software behind the same key your product already uses.

Automation

Connect UltraGPT to existing workflows and pipelines as one more HTTP call.

Growth

Start with one request. Scale to millions.

The same request shape carries a weekend prototype and a production integration — nothing to migrate when one becomes the other.

Prototype
API integration
Model selection
Observability
Production
FAQ

Questions developers ask.

What is the UltraGPT API?
A single HTTP API that sits in front of the same model catalog the UltraGPT app uses. One key and one request shape reach every model, instead of a separate integration per provider.
Which models are available?
The same live catalog shown at /models — synced automatically, so a model added to the catalog is available through the API without any change on our side.
Do I need separate API keys for each provider?
No. One UltraGPT API key authenticates every request, whichever model you call.
Can I switch models without changing my integration?
Yes — change the "model" field and send the same request. Messages, streaming and tool definitions carry over unchanged.
Does UltraGPT support streaming?
Yes. Add "stream": true to a /v1/messages request and read the response as server-sent events.
Does it support image and audio models?
Yes — image generation and edits go through /v1/images, speech-to-text and text-to-speech through /v1/audio.
Can I use tool calling?
Yes, on models with tool-calling support. Pass a "tools" array with JSON-Schema parameters; run the requested tool and return the result as a tool message.
How is API usage billed?
Through your existing UltraGPT subscription — there is no separate, per-token API bill to manage.
Where can I find API documentation?
The full reference lives at /docs, alongside the quickstart, concepts and guides.
How do I create an API key?
Sign in to the app and open Settings → API keys. Workspaces can issue a separate key per project.
Can I use the API in production?
Yes — it's the same infrastructure the UltraGPT app runs on, built to sit behind a real application rather than only a demo.

Your next AI product starts with one API.

Connect your application to the intelligence of UltraGPT.

Or browse the model directory first.