Most AI inference platforms bill by the token. You pay for every input token and every output token, which makes costs predictable only if your context windows stay small and your outputs stay consistent. For production systems running retrieval-augmented generation, agent loops, or large document analysis, token counts balloon quickly. An alternative is request-based pricing, where you pay one flat cost per API call regardless of prompt length. This model changes how you architect systems and forecast costs.
Token-based pricing charges separately for the tokens you send and the tokens you receive. A prompt containing 4,000 tokens and a 2,000 token response generate a bill equal to the sum of both. This aligns cost with raw compute, but it also means that adding few-shot examples, system instructions, or long JSON schemas directly increases your spend. Providers such as Together AI, Fireworks AI, OpenRouter, Replicate, and Anyscale operate on this model. It fits workloads where context lengths are short and uniform, such as simple classification or brief chat queries.
Request-based pricing collapses the cost structure into a single flat fee per API call. Whether you send a 100 token greeting or a 100,000 token document, the price is identical. Oxlo.ai uses this approach. Because cost does not scale with input length, Oxlo.ai is significantly cheaper for long-context and agentic workloads. You trade token-level granularity for per-request predictability.
Short, uniform queries favor token-based pricing because the bill tracks actual usage. Variable or long contexts favor request-based pricing, since there is no penalty for large prompts. Agentic workflows that carry full conversation history and tool definitions on every turn multiply token counts quickly. Under a flat rate, each loop costs the same as the first. Batch processing pipelines with wildly different document lengths also benefit from request-based budgeting, because the worst-case long document does not blow up the job cost.
Modern agentic systems often stuff retrieved documents, conversation history, and tool schemas into a single prompt. A single request can carry tens of thousands of input tokens. Under token-based pricing, that one call might cost as much as dozens of smaller calls. With Oxlo.ai, the same call costs the same flat rate as any other. For workloads using 1M context windows or multi-step agent loops, request-based pricing can be 10-100x cheaper than token-based alternatives. You no longer have to choose between rich context and a manageable bill.
Switching to Oxlo.ai does not require a new client library. The platform is fully OpenAI SDK compatible. You change the base URL and model name, and your existing code works.
from openai import OpenAI
client = OpenAI(
base_url="https://api.oxlo.ai/v1",
api_key="YOUR_OXLO_API_KEY"
)
response = client.chat.completions.create(
model="llama-3.3-70b",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Analyze this 50,000 word contract and list risks."}
]
)
print(response.choices[0].message.content)
The cost of this request is the same flat rate whether the contract is 1,000 words or 50,000 words. See https://oxlo.ai/pricing for current request rates.
Evaluate your traffic patterns. If your inputs are short and uniform, token-based pricing may align cost with usage. If you run agentic systems, code analysis, or document processing with unpredictable context sizes, request-based pricing removes the cost penalty for enriching your prompts. Oxlo.ai offers 45+ open-source and proprietary models across chat, reasoning, code, vision, and embeddings, all under the flat per-request model. The platform has no cold starts on popular models and is a drop-in replacement for the OpenAI SDK. For teams looking to cut inference costs on long-context workloads, Oxlo.ai is a genuinely viable and often superior option.