Choose the least costly OpenAI model that passes an evaluation built around your actual business task. Start with the required output, the cost of an error, and representative examples. Compare a stronger candidate on the same cases, then promote it only when the measured improvement changes an operational outcome.
For example, test GPT-6 Luna first for a fixed-label support-ticket classifier. If tickets contain images or require more visual interpretation, evaluate GPT-6.1 Terra. For difficult, multi-step analysis, compare GPT-6.1 Sol with GPT-6 Astra. These are starting hypotheses based on OpenAI’s current positioning, not a universal performance ranking.
This guide focuses on API model selection and operational workflow design. ChatGPT, the OpenAI API, realtime sessions, open-weight deployments, and automation products are separate surfaces with different capabilities. Model details and example prices below were checked against OpenAI’s model documentation on November 12, 2026. Confirm live documentation before implementation.
Which OpenAI model should you choose for a business workflow?
Define what the workflow must produce and what happens when it is wrong. Test a lower-cost candidate against routine, ambiguous, and exception cases. Compare a stronger candidate on identical inputs and acceptance criteria. Keep the stronger model only if it reduces a meaningful failure, review burden, or operational delay enough to justify its cost.
OpenAI positions Astra for demanding reasoning, coding, research, computer use, and document work; Sol for complex coding, computer use, and professional work at lower standard rates; Terra for efficient visual reasoning and computer-use tasks; and Luna for focused, high-volume work. Those descriptions are vendor positioning. Endpoint, tool support, reasoning settings, modality, and structured-output behavior can differ by model.
Choose the least costly model that passes your real task’s acceptance test. Escalate only when evaluation shows that more capability changes the result.
Match the model to the task, not just the model name
Use the comparison below to choose candidates for testing, not to skip testing. Confirm the current model ID and supported features on the relevant OpenAI model page before building around a tool, modality, or output format.
| Model | Useful starting tasks | Key tradeoff |
|---|---|---|
| GPT-6 Luna | Focused classification, short summaries, and high-volume bounded tasks | Efficient candidate for routine work; test it before escalating. |
| GPT-6.1 Terra | Visual reasoning and computer-use tasks | A distinct visual and computer-use option, not simply a midpoint between other models. |
| GPT-6.1 Sol | Complex coding, computer use, and professional work | Lower standard token rates than Astra; validate the quality tradeoff. |
| GPT-6 Astra | Complex reasoning, coding, research, computer use, and document creation | OpenAI positions it as its most capable option; standard rates are higher than Sol’s. |
For fixed ticket categories, start with Luna. For image or document interpretation requiring more judgment, include Terra in the test. For complex analysis, compare Sol and Astra using the same cases. Do not assume that every model supports the same tools, input types, endpoint behavior, or structured-output constraints.
Start with Luna; test Terra for visual input
Use a fixed schema and allowed values. Add Terra when visual reasoning or computer use is central, then compare valid-output and review rates on identical cases.
Compare Sol with Astra
Use difficult, representative cases and measure whether Astra reduces a material failure or review burden enough to justify its higher cost.
Estimate the real cost: tokens, context, and processing mode
Input and output token rates are only a starting point. On November 12, 2026, the listed standard rates were $10 per million input tokens and $50 per million output tokens for Astra; $2 and $10 for Sol; and $0.10 and $0.50 for Luna. Rates and terms can change, so use the live OpenAI pricing page for current planning.
Astra and Sol document a 1,050,000-token context window. Requests above 272,000 input tokens receive higher long-context pricing for the full request. That is a cost condition, not a recommendation to send oversized prompts. Check cached input, cache writes, Batch or Flex processing, Fast mode, regional processing, and tool charges for the selected model and project.
For an invoice-extraction pilot, measure input and output tokens per document, retries, invalid responses, and the percentage sent for review. Estimate monthly spend from the actual request mix and compare it with manual handling and exception-review costs. Sending only relevant document text can reduce cost and unnecessary data exposure.
Choose the right model family for audio, images, open weights, or cybersecurity
Audio: batch processing or realtime interaction
GPT-Audio-1.5’s documented Chat Completions pattern supports audio input and output. Realtime models are designed for low-latency interactive sessions and use model-specific transports and constraints. For example, GPT-Realtime-2.1 Mini supports function calling but does not support structured outputs.
Choose batch audio when transcript auditability, retries, and field validation matter more than conversational speed. Choose realtime when turn-taking and low latency are essential. GPT-Live sessions have separate per-second session charges, with backend model and tool usage billed separately. Check current pricing and availability. Preserve consent, retention, session, and turn identifiers for either pattern.
Images: create assets or inspect them
Use an image-generation tool when the workflow needs a new or edited creative asset. Use a vision-capable text model when it needs a structured finding from an existing image, such as a document field or defect label. OpenAI’s image-generation guide covers the generation tool. Image usage depends on text tokens, image tokens, dimensions, quality, cache status, and processing mode, so reference token rates are not universal per-image prices.
Open-weight models and cybersecurity access
gpt-oss-120b and gpt-oss-20b are Apache 2.0 open-weight models, not models served through the OpenAI API or ChatGPT. They run on infrastructure controlled by the user or through a hosting provider. OpenAI reports that gpt-oss-120b can fit within 80 GB of memory under its stated quantization setup. That is not a guarantee for every hardware or deployment configuration.
OpenAI’s Daybreak guide describes approval and project setup for cybersecurity model use. Cybersecurity models require approved access, with model-specific project permissions and request settings. Confirm organization approval, safeguards, and access before designing around them.
Turn model selection into a controlled workflow
A model should perform a bounded task inside a workflow, not become the system of record or final authority by default. Put stable, explicit conditions in deterministic rules first. Use AI for ambiguity, language interpretation, or extraction that is difficult to express reliably as fixed rules.
A structured response is a contract to validate, not evidence that the answer is correct. An illustrative invoice output might look like this:
{
"source_record_id": "invoice_1908",
"invoice_date": "2026-11-10",
"currency": "USD",
"total_due": 1240.50,
"missing_fields": [],
"needs_review": false
}This JSON is an illustrative field contract, not a vendor response guarantee. Validate the date using workflow timezone rules, confirm the currency and amount, and verify every required field against the source. Store extracted values as derived fields with the source reference, model ID, prompt version, timestamp, and validation status.
For repeated or concurrent events, separate row grains. A source-event record represents one event. A model-run record represents one attempt and can use source_event_id + model_id + prompt_version + run_type as a proposed unique key. A citation record represents one extracted citation. An aggregate uses an explicit period key. Enforce uniqueness in the database or use a transactional upsert. A search-then-create sequence alone is not race-safe.
Zapier documents ChatGPT (OpenAI) actions including Analyze Text and Extract Structured Data, while AI by Zapier is a separate product layer. Zapier MCP connects compatible AI clients to connected app actions. These products provide different configuration and permission surfaces; none should be treated as a business-policy validator by default. Teams designing bounded connected-app workflows can explore Zapier automation consulting or AI agent consulting.
Three practical model-selection patterns
The designs below are hypothetical implementation patterns, not ready-made integrations. The exact trigger and available actions depend on the connected app and configuration. Zapier’s ChatGPT integration directory documents available actions, while its AI by Zapier guide describes configurable AI steps and returned fields. The validation and ownership controls below are workflow recommendations.
| Trigger and AI job | Validation and action | Fallback and record grain |
|---|---|---|
| Support ticket: classify into an approved category and return a short reason. Apply outage-code and other explicit filters first. | Reject categories outside the enum. Route the validated category to the matching queue or ticket update. | Unknown or ambiguous results go to a support review queue. Use the ticket event ID plus action version to prevent duplicate updates. |
| Invoice or business document: extract date, currency, total, missing fields, and source reference. Use a vision-capable model only when image interpretation is required. | Validate date, currency, amount range, required fields, and source ID before writing designated accounting fields. | Quarantine missing or inconsistent values for accounts-payable review. Keep the document as the authoritative source and use a database-enforced unique key for concurrent runs. |
| CRM activity event: summarize supplied activity without inferring a stage change, forecast, ownership change, or commitment. | Re-fetch a delayed record where appropriate. Write only to a dedicated AI-summary field or related record, preserving human notes. | Stale records and consequential changes go to the deal owner or CRM operations. The CRM event and model run remain separate records. |
Use task-specific measures: correct routing and review rate for tickets; valid extraction and quarantine rate for invoices; and source-grounded summaries without overwriting human-authored data for CRM. Require approval before changing ownership, stage, revenue, contract terms, or customer-facing status.
Evaluate candidates and manage older model IDs
Build an evaluation set containing routine, ambiguous, and exception cases. Run candidates on the same inputs and score task outcomes such as classification correctness, extraction validity, review rate, latency, retries, and cost. Set pass thresholds before testing. A stronger model is worth deploying only when it improves an outcome the operation values.
Record the source event ID, exact model ID, prompt version, run ID, validation result, and operational outcome. If a response contains multiple citations, store one citation record per citation rather than combining them into an ambiguous field. If reporting daily or monthly performance, include an aggregation-period key so summaries cannot collide across grains.
Use a staged rollout: offline evaluation, limited production traffic with human review, comparison with the existing process, then broader deployment only after quality and cost meet defined thresholds. Check the live OpenAI deprecation page for exact IDs, snapshots, shutdown dates, and replacements. Deprecation applies to specific IDs and snapshots, not automatically to every model with a related family name. OpenAI’s current documentation identifies the visual model as GPT-6.1 Terra, not GPT-5.6 Terra.
- Test routine, ambiguous, and exception cases against the same acceptance criteria.
- Record quality, review rate, latency, retries, invalid-output rate, and cost.
- Confirm the exact model ID, endpoint, supported inputs and outputs, and prompt version.
- Validate enums, required fields, dates, currencies, identifiers, and unknown keys where applicable.
- Keep source records authoritative and write derived data only to designated fields.
- Use a database uniqueness constraint or transactional upsert when concurrent runs can create duplicates.
- Name the person or queue responsible for failed validation and consequential decisions.
- Check current pricing and the exact model ID’s deprecation status before expanding traffic.
OpenAI model selection is an operational decision, not a permanent winner-takes-all ranking. Test a candidate against the work, make invalid output stop before a write, and keep a person accountable for exceptions and consequential actions.