OpenAI vs Anthropic vs Google Fine-Tuning (2026): The Honest API Comparison

These three offerings start from very different problem definitions, and the API surface flows from those starting points. Understanding the underlying philosophy is the fastest way to know which vendor fits your situation before you spend a dollar.

**OpenAI fine-tuning** (https://platform.openai.com/docs/guides/fine-tuning) is the most mature hosted fine-tuning API in the market. It supports three different training algorithms: supervised fine-tuning (SFT) for the standard "here are input-output pairs, learn the pattern" workflow; direct preference optimization (DPO) for offline preference learning where you provide chosen-vs-rejected response pairs; and reinforcement fine-tuning (RFT) where you provide a programmatic grader function and the model is trained against that reward signal. RFT is the differentiator no one else matches in 2026 — for tasks like code completion, math problem solving, or any case where you can score outputs cheaply, RFT can extract quality gains that SFT cannot. The API surface is the standard OpenAI REST pattern: upload a jsonl file, create a fine-tune job, monitor status, then call the resulting fine-tuned model by its ID. The result is auto-deployed — no separate provisioning step.

**Anthropic fine-tuning** (https://docs.anthropic.com/en/docs/build-with-claude/fine-tuning) takes the opposite philosophy: there is no direct Anthropic API for fine-tuning. Claude fine-tuning is exclusively available through Amazon Bedrock and Google Vertex AI partner channels. The reasoning Anthropic has given publicly is that fine-tuning Claude requires custom infrastructure, data isolation, and serving guarantees that Anthropic prefers to delegate to cloud partners with mature enterprise security postures. Practically, this means your fine-tuning workflow looks like a Bedrock or Vertex job — you authenticate against the cloud provider, upload jsonl in Anthropic's chat schema, and the fine-tuned model lives on provisioned Bedrock throughput or a Vertex endpoint. The cost of that provisioned throughput is significant and not negligible compared to the training itself.

**Google Vertex AI fine-tuning** (https://cloud.google.com/vertex-ai/generative-ai/docs/models/tune-gemini-overview) is the most generous offering on the free-tier dimension, and the deepest in terms of eval/deployment tooling. Gemini 2.5 Flash supervised fine-tuning includes a substantial monthly free training token allowance — enough that small experiments can run at zero training cost — and the integration with Vertex AI's evaluation pipelines (BLEU, ROUGE, custom metrics) means you can run automated quality checks against held-out sets without writing infrastructure. The catch is that Vertex AI is locked to Google Cloud — you cannot serve a Gemini fine-tune outside Vertex, and the per-hour endpoint deployment cost is a recurring spend even when traffic is low.

**The positioning in one sentence:** OpenAI is for teams who want the deepest method surface (SFT + DPO + RFT) and the lowest serving friction. Anthropic is for teams already on Bedrock/Vertex who specifically need Claude's reasoning quality on their domain data. Google is for teams who want to experiment at zero or near-zero cost on Vertex and use Gemini for production.

Per-token training pricing is the single most-cited number in fine-tuning decisions, and the three vendors are not directly comparable without normalizing for what "training tokens" means in each ecosystem.

**OpenAI charges by total training tokens processed**, which is (tokens per example) × (number of examples) × (number of epochs). For GPT-5 mini supervised fine-tuning, the published rate as of June 2026 docs is approximately $25 per 1M training tokens. A typical fine-tune run with 5,000 examples averaging 1,500 tokens each, run for 3 epochs, would cost: 5,000 × 1,500 × 3 = 22.5M tokens × $25 = approximately $562. GPT-5 (full) training costs roughly 4-5x that rate, while GPT-5 nano is cheaper by half. RFT is priced as a higher-tier per-token rate plus per-grading-call overhead — budget 2-3x SFT cost for equivalent compute.

**Anthropic (via Bedrock) charges per training token at higher rates** — approximately $45 per 1M tokens for Claude Haiku 4.5 SFT and roughly 2x that for Sonnet 4.6 SFT. The same 22.5M-token job that costs $562 on GPT-5 mini would cost approximately $1,012 on Claude Haiku 4.5 via Bedrock. Additionally, Anthropic fine-tunes incur **provisioned throughput cost** on Bedrock — you pay for model serving capacity per hour whether or not you use it, with a typical Sonnet 4.6 provisioned throughput unit running ~$15-25 per hour depending on region and commitment. For low-volume production, this serving floor often exceeds the training cost.

**Google (via Vertex AI) charges per training token on the paid tier** — approximately $8 per 1M training tokens for Gemini 2.5 Flash SFT, the cheapest of the three by a wide margin. Crucially, Vertex includes a substantial free quota each month, so small-to-medium fine-tune jobs may train at zero cost. The same 22.5M-token job that costs $562 on OpenAI and $1,012 on Anthropic would cost approximately $180 on Gemini 2.5 Flash on the paid tier — and could be free entirely if it fits within the monthly free allowance. The deployment cost is comparable to Bedrock provisioned throughput: a Gemini 2.5 Flash endpoint runs per-hour at the published Vertex AI prediction rate, so always-on serving adds material cost.

**The honest summary on training-only cost:** Google is cheapest, OpenAI is in the middle and has the deepest method surface, Anthropic is the most expensive but the only path to a fine-tuned Claude. For total cost of ownership including serving, run the math at projected QPS — OpenAI's auto-deployed fine-tunes have no per-hour serving floor, which can dominate the calculation for low-traffic production deployments.

What you can fine-tune is at least as important as what it costs, and the three vendors restrict different things.

**OpenAI** supports SFT on the full GPT-5 family (GPT-5, GPT-5 mini, GPT-5 nano), the GPT-4o family (GPT-4o, GPT-4o-mini), and select older models like babbage-002 and davinci-002 for legacy workloads. DPO is supported on the same GPT-5 family. RFT is restricted to a smaller subset — o4-mini and select models — with explicit allowlist requirements (you typically need to apply for RFT access through the OpenAI dashboard). The pattern is that newer, more capable base models tend to get all three methods, while older models support only SFT.

**Anthropic** supports SFT on Claude Haiku 4.5 (via both Bedrock and Vertex) and Claude Sonnet 4.6 (via Bedrock only as of June 2026). Claude Opus 4.7 is not currently available for fine-tuning anywhere. There is no public DPO or RLHF offering from Anthropic. The constraint set is the smallest of the three vendors and the most likely to change as Anthropic expands its cloud-partner program.

**Google** supports SFT on Gemini 2.5 Flash with the cleanest path and the most generous free quota; SFT on Gemini 2.5 Pro is in limited preview as of June 2026 and requires Vertex AI allowlisting. Legacy Gemini 1.5 family (Flash and Pro) is still tunable for backward compatibility. DPO on Gemini 2.5 Flash is in preview — you can apply via the Vertex AI console — but is not yet GA. The method matrix is narrower than OpenAI's but the free tier on Gemini 2.5 Flash SFT compensates for many experimentation use cases.

All three vendors accept jsonl files, but the schema inside differs and you cannot directly port a training file between vendors without a translation step.

**OpenAI's chat format** uses the standard `messages` array with `role` and `content`, identical to the Chat Completions API: `{"messages":[{"role":"system","content":"..."},{"role":"user","content":"..."},{"role":"assistant","content":"..."}]}`. For DPO, the schema adds `preferred_completion` and `non_preferred_completion` fields. For RFT, you provide prompts and a grader specification — the grader is either a JSON schema-based comparison or a Python grader function for arbitrary scoring logic.

**Anthropic's format** uses the Anthropic chat schema with explicit `system` field and `messages` array: `{"system":"...","messages":[{"role":"user","content":"..."},{"role":"assistant","content":"..."}]}`. Tool-use examples include `tool_use` blocks if you are training for tool-calling behavior. Bedrock and Vertex both accept the same schema with slight wrapper differences for the job submission API itself.

**Google's format** uses the Gemini `contents` parts schema with `role` (`user` or `model`) and `parts` array: `{"contents":[{"role":"user","parts":[{"text":"..."}]},{"role":"model","parts":[{"text":"..."}]}]}`. System instructions are passed as a separate field (`systemInstruction`) at the top level. Vision examples can include image parts directly in the parts array, and Gemini 2.5 Flash fine-tuning supports multimodal training out of the box.

A common pattern teams use: maintain training data in a neutral internal format (typed Python dataclasses or Pydantic models), then run a per-vendor translation step at fine-tune job submission. This lets you re-train on a different vendor without a one-off cleanup — important because vendor choices shift over a 12-24 month horizon.

Quota differences can disqualify a vendor before pricing even enters the conversation. The three vendors have published different ceiling structures.

**OpenAI** does not publish a hard maximum on training examples — practical maxima for the GPT-5 mini and GPT-5 family are in the tens of thousands of examples, with reasonable batch processing. Per-example context is capped at 32K tokens for GPT-5 mini training (matching the base model's context). Concurrent fine-tune jobs are limited per organization with a default of 3 active jobs simultaneously; this can be raised on request. Deployed fine-tuned models are not separately quota'd — calls to them count against your normal token-per-minute and request-per-minute rate limits for the base model tier.

**Anthropic (via Bedrock)** recommends 50 minimum and ~10,000 example soft cap for typical jobs, with Claude Sonnet 4.6 training supporting up to 200,000 input tokens per example — the largest per-example context window of any frontier vendor's fine-tuning offering. Concurrent fine-tune jobs are limited by Bedrock service quotas (configurable per AWS account, default ~2-3 concurrent jobs). The provisioned throughput required to serve a fine-tuned Claude is the binding deployment quota — each provisioned throughput unit is a separate AWS service quota item.

**Google Vertex** caps Gemini 2.5 Flash training at approximately 10,000 examples and 32K tokens per example, with concurrent job limits of approximately 5 per project (raisable). The free-tier monthly token allowance is the cap most teams hit first — it is published in the Vertex AI Gemini pricing page and is renewed monthly. Endpoint quota is separate: each Vertex endpoint deployment counts against the project's compute quota.

See OpenAI fine-tuning rate limits, Anthropic fine-tune quotas, and Replicate training quotas for granular per-vendor quota deep-dives including how to request increases.

Training a model is one workflow; knowing whether it actually improved on your task is another. The three vendors invest in eval/monitoring tooling at very different levels of depth.

**OpenAI** reports training and validation loss plus token-level accuracy through the fine-tune job dashboard and API. Checkpoints are saved at configurable intervals (default: epoch end) and can be inspected and deployed individually. For evaluation against custom metrics post-training, you write your own eval harness against the OpenAI Evals framework (https://github.com/openai/evals) or a third-party tool. The OpenAI ecosystem itself does not bundle eval pipelines into the fine-tuning workflow — you connect them manually.

**Anthropic via Bedrock** reports training loss and held-out validation metrics through CloudWatch. For evaluation against custom metrics, you typically use Amazon Bedrock Evaluations or build a custom pipeline in SageMaker. Bedrock's eval offering covers standard LLM benchmarks plus custom rubric-based judging via an LLM-as-judge approach. Anthropic via Vertex inherits the Vertex evaluation pipeline tooling.

**Google Vertex AI** has the deepest bundled eval tooling of the three: BLEU, ROUGE, METEOR, and custom evaluation metrics are first-class in the Vertex evaluation pipeline, and you can run an evaluation job against a held-out set immediately after a fine-tune job completes with a single API call. For continuous monitoring of deployed Vertex endpoints, the integrated Vertex AI Model Monitoring service provides drift detection, latency tracking, and quality regression alerts — none of which require custom infrastructure.

If evaluation depth matters more than model selection, Vertex AI's tooling has a clear edge. If you can write your own eval harness and want the deepest method surface, OpenAI is the better fit. If you must use Claude, Bedrock evaluations are sufficient for most use cases but require more glue code.

Trade-offs are easier to navigate against a decision matrix. The following maps common production scenarios to the right vendor pick.

**Task is code completion, math, or anything programmatically gradable** → OpenAI with RFT. The reinforcement fine-tuning offering is the only path to extract quality gains from a reward signal in a hosted API, and OpenAI's o4-mini and select GPT-5 variants are the only models that support it. Budget 2-3x SFT cost but expect 10-30% quality lift over SFT on these tasks.

**You need a fine-tuned Claude for legal, regulatory, or alignment reasons** → Anthropic via Bedrock (or Vertex). There is no other option. Plan for the higher per-token training cost and the Bedrock provisioned throughput floor. Run a small SFT job first to confirm the workflow before committing budget.

**You are experimenting and budget is a hard ceiling** → Google Vertex with Gemini 2.5 Flash SFT. The free monthly training quota means you can run iteration cycles at zero training cost; you only start paying once you go to production and deploy an endpoint.

**You want the lowest serving cost for a production fine-tune** → OpenAI. Auto-deployed fine-tunes have no per-hour serving floor; you pay only per inference token. For low- and medium-traffic production deployments, this is the lowest TCO option.

**Your team is already deep in AWS or GCP** → Match the cloud. Bedrock-based Claude fine-tuning has IAM, KMS, CloudWatch, and SageMaker integrations available out of the box. Vertex AI fine-tuning has the deepest GCP IAM, audit logging, and Cloud Build integration. Cross-cloud workflows add real glue cost.

**You need preference learning (DPO) on a hosted API** → OpenAI for general availability; Google for Gemini 2.5 Flash if you are willing to use a preview API. Anthropic does not offer DPO.

Three failure modes show up repeatedly across teams running their first hosted fine-tune in 2026.

**Pitfall 1: Ignoring the deployment cost floor on Bedrock or Vertex.** Provisioned throughput on Bedrock and Vertex endpoint hours are charged whether or not you are sending traffic. A team that runs a $500 Claude fine-tune and then leaves a provisioned throughput unit running idle for a month can easily spend $10,000-15,000 on serving — far more than the training itself. Either commit to high traffic, use the on-demand inference path where supported (limited for fine-tunes), or batch your deployment windows.

**Pitfall 2: Treating fine-tuning as a substitute for prompt engineering or RAG.** Fine-tuning shifts a model's behavior distribution; it does not give it new facts (RAG does that better), and it cannot fully replace a well-structured prompt (you still need the system prompt to set scope, voice, and constraints). The typical sequence: ship the best prompt you can, ship RAG for any factual or up-to-date knowledge needs, and only fine-tune when prompt engineering plateaus on a specific behavior pattern that examples can teach better than instructions.

**Pitfall 3: Overfitting on too few examples or too many epochs.** All three vendors expose epoch counts and learning rate multipliers as tunable hyperparameters. The default settings are reasonable, but teams who increase epochs from 3 to 10 in pursuit of a quality lift often see worse generalization on held-out data. Start with the vendor defaults, watch the validation loss curve, and only tune hyperparameters once you can see overfitting in the data.

OpenAI, Anthropic, and Google are the frontier-model fine-tune offerings in 2026, but they are not the only options. For open-weight models, hosted fine-tuning is also available from Together AI (https://together.ai/), Fireworks AI (https://fireworks.ai/), Replicate (https://replicate.com/), and Modal (https://modal.com/). Open-weight fine-tuning brings different trade-offs — full control over weights, lower per-token cost, but you own the serving infrastructure or use the platform's serving endpoints.

See our companion comparison Together fine-tuning vs Fireworks vs Replicate for the open-weight side of this decision, and the LoRA vs QLoRA vs full fine-tuning cost breakdown for choosing the right training method on open weights.

The honest summary: if you want a frontier model fine-tuned on your data, your vendor choice is one of OpenAI, Anthropic, or Google. If you want maximum control and lowest per-token cost, fine-tune an open-weight model (Llama 4, Mistral, Qwen) on a platform like Together, Fireworks, or Replicate. Most production deployments end up using both — frontier fine-tune for the highest-quality user-facing path, open-weight fine-tune for cost-sensitive bulk operations.