A practitioner's guide to picking the right LLM API for coding, long docs, cheap extraction, reasoning, vision, voice, and on-device work.
There is no single "best" LLM API, and anyone who tells you otherwise is selling something. The right pick depends on the job: an agent that edits code has nothing in common with a pipeline that classifies ten million support tickets a night. This post organizes the decision by use case, so you can map your workload to a class of model instead of chasing benchmark leaderboards.
Pricing here is directional. Rates move month to month and vary by region and commitment, so treat every number as a rough order of magnitude and verify current rates on the provider's pricing page before you budget.
This is the most demanding category. Agentic coding means long tool-use loops, large context windows full of repo files, and low tolerance for the model going off the rails halfway through a refactor. You want a frontier model here, not a budget one. The top tier from Anthropic (Claude), OpenAI (GPT), and Google (Gemini) all field models tuned for tool calling and multi-step execution.
The cost tradeoff is real but usually worth it. A coding agent might burn 50k to 200k tokens per task, so per-token price matters, but a cheaper model that fails the task and needs a retry is more expensive than the smart one that gets it right. Reserve the frontier model for the reasoning and code generation, and route trivial sub-steps (file summaries, lint parsing) to a cheaper tier.
For contracts, research papers, or a quarter of logs, the deciding factor is the context window and how well the model actually uses the middle of it. Gemini has led on raw window size (up to the million-token range), while Claude and GPT frontier models handle very long contexts well with strong recall.
Long context is where prompt caching pays off the most. If you ask many questions against the same 200k-token document, cache the document once and each follow-up only pays full price for the new tokens. Cached input tokens typically run a fraction of the normal rate, so a Q&A workload over a fixed corpus can drop its bill substantially. Structure your prompts so the stable content (the document, the system prompt) comes first and the variable content (the question) comes last.
Sentiment tagging, entity extraction, routing, moderation, structured-data pulls. These are simple per-call but run at enormous volume, so unit cost dominates and you do not need a frontier model. Use the small, fast tiers: OpenAI's mini models, Claude Haiku, Gemini Flash, or an open-weight model like Llama, Qwen, or Mistral that you host or rent cheaply.
Two levers cut cost hard here. First, batch APIs: most providers offer roughly 50% off if you submit jobs asynchronously and accept results within a window (often up to 24 hours). Perfect for nightly ETL. Second, constrained output (JSON schema / structured outputs) keeps responses short and parseable, which trims output tokens and eliminates a fragile parsing layer.
# Route by task complexity, not by habit
def pick_model(task):
if task.type in ("classify", "extract", "route"):
return "small-fast" # Haiku / GPT-mini / Gemini Flash
if task.type == "long_doc":
return "long-context" # Gemini / Claude with caching on
if task.type in ("code", "agent", "reasoning"):
return "frontier" # top-tier Claude / GPT / Gemini
return "small-fast"
model = pick_model(task)
Math, multi-hop logic, planning, hard debugging. This is where the "reasoning" or "thinking" model variants earn their keep by spending extra tokens on internal deliberation before answering. All three frontier providers ship a reasoning mode.
The tradeoff is latency and cost: a reasoning model can take tens of seconds and generate far more (billed) tokens than a normal call. Do not put one behind a chat box where users expect instant replies. Use it for offline or tolerant-latency work, and set a reasoning-effort or thinking-budget parameter so you are not paying for deep deliberation on easy questions.
Screenshots, document scans, charts, UI understanding, product images. The frontier models from all three major providers are natively multimodal and handle images alongside text in the same call. Gemini and GPT are strong general choices; Claude is solid for document and screenshot understanding in agent workflows.
Watch the token math: images are billed as a token count derived from resolution, and a high-res image can cost as much as a page of text. Downscale to the smallest resolution that still answers the question. For pure OCR of clean documents, a dedicated OCR service can be cheaper than a general vision model.
Live voice agents and low-latency conversation need speech-to-speech or streaming APIs, not a request/response text call wrapped in a TTS layer. OpenAI's Realtime API and Gemini's live streaming interfaces are built for this, handling audio in and audio out with interruption support.
The constraint here is latency, not per-token price. Budget for time-to-first-audio under a few hundred milliseconds, keep the model tier modest so it responds fast, and offload any heavy reasoning to a separate background call so the voice loop stays snappy.
When you need data to never leave your infrastructure, want zero per-call fees at scale, or must run offline, reach for open-weight models: Llama, Qwen, and Mistral all ship strong instruction-tuned and small variants. You can run them locally, on your own GPUs, or through a hosting provider.
The tradeoff shifts from per-token price to fixed infrastructure and ops cost. A self-hosted model is cheap per call but you own the GPUs, the scaling, and the uptime. For bursty or low-volume work, a serverless open-weight endpoint or an aggregator (OpenRouter and similar) that lets you hit many models through one API and one bill is usually the better deal until volume justifies dedicated capacity.
Work through four questions in order:
- Latency budget: Does a human wait on this? Realtime rules out reasoning models and favors small tiers.
- Volume: Millions of calls push you toward cheap tiers, batch APIs, and open-weight hosting. Thousands can afford frontier.
- Difficulty: Does the task actually need frontier reasoning, or does a mini model pass your evals? Test before assuming.
- Data constraints: Regulatory or privacy limits may force on-device or a specific region regardless of the above.
Build a small routing layer early. The snippet above is enough to start: send the easy 80% to a cheap model and reserve the frontier tier for work that genuinely needs it. That single decision usually moves the bill more than any per-token negotiation.
For a typical product team in 2026: default to one frontier provider for agents, coding, and hard reasoning; add a small-fast model from the same or a different provider for high-volume extraction and classification; turn on prompt caching for any repeated-context workload and batch APIs for anything asynchronous. Keep an open-weight option (via an aggregator) in your back pocket for cost ceilings and data-residency cases. Do not marry one vendor. Route by task, measure with evals, and re-check prices quarterly.
For the wider picture on providers and serving infrastructure, see our pillar on best LLM APIs and AI infrastructure, and for a head-to-head read OpenAI vs Anthropic vs Gemini.
