# EagleAI Model API > Two frontier language models, sold two ways from one domain. Ten > flat-price endpoints, from $0.0001 to $0.1469, where the price is per > request and does not vary with how long the answer turns out to be and > the path picks how large a request is accepted. And one per-token > surface, uncapped, where the same two deployments are billed by the > token over OpenAI Chat Completions. Base URL: https://eagleai.online Auth: `X-API-Key: ` on every request. No header is 401, a wrong key is 403. Streaming: send `"stream": true` for SSE on any endpoint. Those three lines describe the ten flat-price endpoints, which is most of this page. The per-token surface has its own base URL, its own auth, its own limits and its own error shape; it is documented under "Per-token" below, and nothing in the tables between here and there applies to it. Each endpoint sells one request *size*. The path picks the size, so a caller cannot be talked into paying for more than it asked for. Every limit is checked here before anything is forwarded upstream: an oversized request is refused with 400 or 413 and is not billed. Nothing is silently truncated. ## claude-opus-5 Messages wire format. Body: `model`, `messages`, `max_tokens`. `model` must be `claude-opus-5`; any other name is 400 and never leaves this server. | POST path | price | max input | max output | req/min | |---|---|---|---|---| | /api/v1/opus5/micro/messages | $0.0001 | 1,000 | 1,400 | 5 | | /api/v1/opus5/nano/messages | $0.0009 | 2,000 | 2,000 | 3 | | /api/v1/opus5/small/messages | $0.0849 | 3,000 | 2,400 | 2 | | /api/v1/opus5/medium/messages | $0.1009 | 4,000 | 2,800 | 2 | | /api/v1/opus5/messages | $0.1110 | 4,000 | 3,000 | 5 | `max_tokens` must be at least 1,200 on every path above, and omitting it gets you the endpoint's full budget. This model spends roughly 986 tokens thinking before it writes its first word, even at the lowest effort the Messages wire offers, so a smaller budget buys thinking and no answer. A request under 1,200 is refused with 400 before it is sent upstream, and you are not billed for it. ## gpt-5.6-sol Responses wire format. Body: `model`, `input`, and optionally `max_output_tokens`. `model` must be `gpt-5.6-sol`. | POST path | price | max input | max output | req/min | |---|---|---|---|---| | /api/v1/micro/responses | $0.0001 | 150 | 80 | 60 | | /api/v1/nano/responses | $0.0009 | 500 | 250 | 20 | | /api/v1/small/responses | $0.0229 | 1,000 | 500 | 10 | | /api/v1/medium/responses | $0.0629 | 2,100 | 1,500 | 5 | | /api/v1/responses | $0.1469 | 2,100 | 4,000 | 163 | Every size below the largest sends reasoning effort `none`, so the whole output budget goes to the answer rather than to thinking. There is no minimum on this wire: an 80-token budget returns 80 tokens of answer. The two smallest sizes of each model — micro and nano, four endpoints in all — are priced below what their tokens cost us. That is deliberate and it is not a trial: there is no expiry, no card, and no request cap beyond the per-minute one shown. Every size above them is priced above its own worst case, so no request can cost us more than it earns. The limits in these tables are the ones the server enforces, not a softer advertised figure: a request at exactly the stated maximum is accepted, and the price shown is what that request costs. A worked call: curl https://eagleai.online/api/v1/micro/responses \ -H "X-API-Key: $EAGLEAI_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-5.6-sol","input":"one sentence on tides", "max_output_tokens":80}' Status codes worth handling on the ten endpoints above: 400 wrong model or malformed body, 401 no key, 403 bad key, 413 body too large, 429 over the rate limit or the token budget — 429 always carries `Retry-After` in seconds. ## Per-token The same two deployments, billed by the token rather than by the request, on a second base URL. None of the size caps above apply here and that is the point of the surface: on a per-token meter a large request is revenue rather than a fixed-price loss, so the reason the tiers exist disappears. A caller may fill the whole context window and ask for the whole output ceiling. Base URL: https://eagleai.online/api/openrouter/v1 Auth: `Authorization: Bearer ` or `X-API-Key: ` — the same issued keys, either header. Missing, unrecognised or expired is 401. Wire: OpenAI Chat Completions in and out, on both models. Opus is translated to a messages-style API in front of the model and back again, so a client only ever speaks the one protocol. POST /api/openrouter/v1/chat/completions | `model` | context | max output | req/min | concurrent | tokens/min | |---|---|---|---|---|---| | eagleai/gpt-5.6-sol | 272,000 | 128,000 | 1,000 | 203 | 1,000,000 | | eagleai/claude-opus-5 | 200,000 | 64,000 | 40 | 4 | 40,000 | Those last three columns are each deployment's own provisioned quota rather than a number we chose, and all three are enforced here before the upstream is contacted. Over any of them is an immediate 429 carrying `Retry-After` in seconds. The token budget works differently from the other two, and the difference is worth stating rather than leaving to be inferred from a 429. It is a ceiling on the deployment, not an allowance handed to each key: every caller of one model draws on the same minute. A request is refused only once that minute is already spent, and never for being large — Opus's 200,000-token context does not fit inside its own 40,000-token minute, so a "does this request fit" rule would refuse every Opus request there is. What a request spends against the minute is its measured prompt at admission, corrected to the real prompt-plus-completion total the moment the upstream reports one; the window therefore trails by whatever is in flight and no further. Where a deployment declares a separate output allowance, completions are metered against that as well. Nothing queues: a request held open until a slot frees scores as a slow request rather than as a refused one, which is the wrong trade for a marketplace that measures latency. Streaming and tool calling on both models. Structured outputs (`response_format`) on `eagleai/gpt-5.6-sol` only — the upstream refuses them on the Messages route, so asking for one on Opus is a 400 from here, naming the parameter, rather than a 400 from an upstream you cannot see. Text is the only declared input modality on either model. The Opus route refuses, by name and with a 400, everything else it cannot honour rather than dropping it quietly: `n` other than 1, `logprobs`, `top_logprobs`, a non-empty `logit_bias`, a non-zero `frequency_penalty` or `presence_penalty`, `seed`, and message content parts it does not recognise. The refusal names the field in `error.param`, so it is found by the developer who set it rather than by their users. Sending any of those as `null` is always fine — that is how an OpenAI client spells "not set", and several SDKs send the whole field list with nulls in it — as are `frequency_penalty: 0` and `presence_penalty: 0`, which are the OpenAI defaults and ask for what the upstream already does. `parallel_tool_calls: false` is genuinely honoured rather than ignored, and `user` is accepted and forwarded as the upstream's `metadata.user_id`. Prices are per input token and per output token and are deliberately not restated on this page. They are rendered from the same rate table the invoice is computed from, and published, without a key, at: GET https://eagleai.online/api/openrouter/v1/models That document carries the current rate for each model and the limits in the table above. A discounted cached-input rate appears there for `eagleai/gpt-5.6-sol` and only for it: that upstream caches prompts automatically, while nothing on the Opus route ever sends a cache flag, so a cached rate there could never be earned and publishing one would be a price you cannot get. Status codes: 400 unknown model, invalid JSON, or a parameter this surface will not silently drop; 401 missing, unrecognised or expired key; 403 a key not authorised for that model, or one carrying a prepaid credit allowance, which this surface refuses rather than meters; 413 request body too large; 422 a body that does not validate, with the offending field in `error.param`; 429 over a rate, token or concurrency limit, with `Retry-After`; 502 and 504 upstream failures; 503 the surface is switched off or unconfigured. The body is the OpenAI error object — `{"error": {"message", "type", "code"}}` — not the `{"detail": ...}` the flat-price endpoints return. ## API - [gpt-5.6-sol OpenAPI](https://eagleai.online/api/v1/openapi.json): full request and response schema for all five Sol endpoints. - [claude-opus-5 OpenAPI](https://eagleai.online/api/v1/opus5/openapi.json): the same for all five Opus endpoints. - [Per-token model catalogue](https://eagleai.online/api/openrouter/v1/models): the two per-token listings with their live rates, context windows and limits. No key required. - [Service catalog](https://eagleai.online/.well-known/agents.json): this page as JSON, including per-endpoint prices and limits. ## Buying a key - [gpt-5.6-sol on APIHub](https://apihub.io/marketplace/eagleai-gpt56-sol): pay per request in USDC on Base, no account with us needed. - [claude-opus-5 on APIHub](https://apihub.io/marketplace/eagleai-opus5): same, for the Opus endpoints. - [Direct key](mailto:sales@eagleai.online): for the eight smaller sizes, for volume, for the per-token surface, or to skip the marketplace. The per-token surface is built to be resold by a router that invoices per token after the fact, which is why a key carrying a prepaid credit allowance is refused there — there is no per-request worst case to reserve against on an uncapped surface. ## Privacy [Privacy and data retention](https://eagleai.online/privacy.html) — what a request leaves behind, on both surfaces. Prompts, messages and completions are held in memory only for as long as it takes to forward them, and are never written to disk, to a database, or to our logs. One metering record per request is kept for 365 days and then deleted: identifiers, token counts, timings and money — 33 fields on the flat-price endpoints, 18 on the per-token surface — and no content. The caller field in it is a truncated SHA-256 of the API key — pseudonymous, not anonymous. Keys issued with a prepaid credit allowance also get one spend row per request, which has no retention window and is kept until an operator clears it; the notice says so rather than implying otherwise. Requests are served from dedicated deployments we operate on a third-party cloud AI platform, whose abuse monitoring may retain prompts for up to 30 days. We do not name that platform here; we will name it in writing to any customer who asks. Modified abuse monitoring (zero data retention) is NOT enabled on these deployments; if zero retention is a requirement for you, this API is not a fit, and it is better to read that here than to find it out later. ## Terms [Terms of Service](https://eagleai.online/terms.html) — keys, acceptable use, billing, capacity and the limits of what we promise. The parts worth knowing before you integrate rather than after: a key is a bearer credential and its traffic is yours to pay for; revocation takes effect on the next service restart rather than instantly; a refused request is never billed; prices may change but never retroactively; and there is **no service level agreement** — no uptime commitment, no latency commitment and no service credit. Throughput and latency figures we publish are measurements from a dated run, not a rate we guarantee. We claim no certification or compliance attestation of any kind, which is why the catalogue publishes `"hipaa": false` alongside `"zdr": false`. Reselling is allowed and expected; the per-token surface is built for it.