Using the OpenAI Decisions API for Marketing Workflows

The OpenAI Decisions API is for workflows that need a bounded judgement, such as classifying a lead or choosing a route, rather than a generated paragraph. You send it shared input and one or more questions, then your application uses the answers to take the next step.

For growth teams, that can make a useful branch in a marketing workflow quicker and simpler than asking a conversational API to write a response you do not need. It is not automatically cheaper or a replacement for the Responses API: the result depends on your inputs, output needs and whether another call follows. If you are applying decisions to AI-search content work, SearchFIT’s free AEO tools can help with related content checks; they are separate tools, not a Decisions API integration.

What the OpenAI Decisions API does

The Decisions API is a separate endpoint for answers with a defined shape. Instead of asking a model to write an open-ended reply, you ask it to assess a condition, select from choices you provide, or rate something against an ordered rubric. OpenAI documents three answer types: predicate, choice and score in its Decisions API guide.

That distinction matters in marketing automation. A workflow may need to know whether a message is a shipping complaint, whether a lead belongs in a sales queue, or how closely a page matches a brief. If it only needs that decision, generating a paragraph and then extracting a label from it adds work without necessarily improving the outcome.

The model does not execute your workflow. It returns a judgement. Your own application must apply deterministic rules, check permissions and consent, and decide whether to route, suppress, notify or ask a person to review the case.

A choice or score response also includes probability information and confidence, according to OpenAI’s documentation. Treat those signals as evidence to evaluate, not as proof that a decision is correct. The right threshold depends on the error you are willing to accept and the cost of getting a case wrong.

When to use it, and when not to

Use the Decisions API when the task has a limited set of acceptable answers and a clear next action. Typical marketing uses include lead classification, support-message triage, campaign mention categorisation and prioritising content for human review.

Use the Responses API when the workflow needs an explanation, a written customer reply, extracted fields in a custom schema, or other generated content. OpenAI recommends Structured Outputs with the Responses API for custom JSON schemas and extracted fields. Decisions is designed for bounded answers, not arbitrary response generation.

A practical test is to finish this sentence: “Once I have the answer, my system will…” If the rest of the sentence is a rule-based action, such as queueing a record or flagging it for review, Decisions may fit. If the rest is “write a thoughtful response explaining why”, you likely need a generation step as well.

Do not assume fewer tokens means a lower total workflow cost. A Decisions request followed by a Responses request can mean another round trip and sending some of the same context again. Compare complete workflows, not isolated calls.

What you need before you start

Before changing a live workflow, assemble the basics:

• A single decision to make. Start with one existing branch where a human or model already labels, scores or routes an item.
• A clear input. Decide which form fields, CRM properties or message text the model genuinely needs. Leave out unrelated customer data.
• A small set of outcomes. Write down valid labels and what each one means. Include a review option for incomplete, conflicting or unusual cases.
• An action owned by your application. Decide what code, automation or person will do with each label. Keep eligibility, consent, suppression and access checks outside the model judgement.
• Historical examples. Collect cases with outcomes agreed by a person or by the existing process. These let you test the new decision against something more useful than intuition.
• An evaluation plan. Choose how you will measure agreement, review rate, time to route and cost per processed record. Keep business outcomes distinct from API usage.

The API is generally available. OpenAI’s changelog records its beta release on 6 October 2026, and OpenAI announced general availability on 22 October 2026. The documented endpoint is POST /v1/decisions, and the documented model is gpt-6-luna. Check the API reference for creating a decision before implementation, as request and response details belong to the current API documentation.

Step 1: Choose one workflow with a bounded decision

Pick a workflow that is already understandable to the team and has a narrow decision point. Avoid starting with a broad instruction such as “improve our marketing operations”. That is not one decision. It may combine research, drafting, prioritisation and execution, each with different risks.

A useful first candidate is B2B lead routing. A form submission arrives with a job role, company details and a message. The workflow needs to choose sales_ready, nurture or review. A human or an existing rules engine can then apply the next action.

Other reasonable pilots include:

• Sorting incoming product feedback into a small set of categories.
• Flagging campaign mentions that appear to describe a serious product issue.
• Prioritising pages for editorial review against an agreed brief.
• Routing a message to the right support or marketing queue.

Write down the current process first. What information does it consider? What happens when information is missing? Which cases go to a person? How long does routing take? Without a baseline, it is difficult to tell whether the new branch is useful.

Avoid choosing a high-consequence decision as the first pilot. A model label should not independently decide whether a customer is eligible for a benefit, whether a legally sensitive message can be ignored, or whether an important account is excluded from human attention. Begin with recommendations or reversible routing, then expand only after evaluation.

Step 2: Define labels and observable criteria

Good labels are distinct, limited and grounded in evidence. For a lead-routing task, sales_ready might mean the supplied information contains explicit buying intent, a purchasing timeline or a pricing request. nurture might mean the prospect is relevant but no near-term buying intent is visible. review covers missing or conflicting evidence.

Avoid labels whose meanings overlap. For instance, if high_intent and sales_ready mean almost the same thing, the model has no reliable basis for choosing between them. Keep the definition tied to what is present in the input. Do not ask the model to infer a prospect’s budget or authority from a job title unless the available evidence supports that judgement and you have tested the rule.

Turn each label into a short, observable description. Include examples of evidence that qualifies, and clarify what should happen when evidence is absent. The description should define the decision, not suggest an action that belongs in your own software.

For a content-quality score, write an ordered rubric. For example, the lowest level might mean the page does not address the brief, a middle level might mean it addresses the main topic but misses important requirements, and a higher level might mean it covers the brief’s stated requirements. Describe each level so that a reviewer can tell them apart. Do not treat a model score as a validated performance metric until you compare it with labelled examples.

OpenAI recommends basing questions on observable criteria, making choice descriptions meaningfully distinct, and using labelled examples to set thresholds according to the cost of false positives and false negatives. Put that advice into practice before connecting a decision to an automated action.

Step 3: Prepare the input and questions

Send only the context needed to decide. For a lead, that could be the form message and relevant fields such as company and role. For a product review, it could be the review text and the product category. Avoid passing a full CRM record just because it is available. Unneeded fields can add cost, create privacy concerns and distract from the criteria.

Ask questions that your application can use directly. A choice question is often a good fit when the next step depends on one label. A predicate question is suitable for a yes-or-no condition where probability matters. A score question fits an ordered rubric.

The Decisions API allows one request to include between 1 and 400 questions about shared input. Use batching when questions are independent and can be answered from the same material. For example, a product message could be assessed for whether it mentions a shipping issue and whether it expresses dissatisfaction. If the second question depends on the answer to the first, make separate requests instead. OpenAI’s create-decision reference documents the request shape and batching limits.

A small lead-routing request can look like this:

curl https://api.openai.com/v1/decisions \\
  -H "Authorization: Bearer $OPENAI_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-6-luna",
    "input": "Company: Acme. Role: VP of Operations. Message: We need pricing for 200 seats before our December rollout.",
    "questions": [{
      "type": "choice",
      "name": "lead_route",
      "instructions": "Choose the best next route based only on the supplied lead details.",
      "choices": [
        {"value": "sales_ready", "description": "Explicit buying intent, purchasing timeline, or pricing request."},
        {"value": "nurture", "description": "Relevant prospect, but no near-term buying intent."},
        {"value": "review", "description": "Insufficient or conflicting information; send to a person."}
      ]
    }]
  }'

This is an illustrative request, not a result from a real company. In production, handle the returned decision according to the current API reference, and keep the route action in your application code. Do not let an output label write to a CRM or trigger a campaign before your system has checked the relevant rules.

Step 4: Build the branch in your application

The safe pattern is simple: send the decision request, validate that a usable answer came back, then apply your own branch. For example, sales_ready could send a record to the sales queue, nurture could leave it in a marketing workflow, and review could create a task for a person.

Keep hard requirements deterministic. Your application should check that the person has consented to the relevant communication, that the record is not suppressed, and that the next action is allowed. The model can help interpret unstructured text. It should not replace those checks or override them.

Make the decision traceable. Store the input fields that were used where appropriate, the question and label version, the returned answer and confidence information, the action taken, and whether a person changed the result. Follow your organisation’s data retention and privacy rules when deciding what to log. Avoid retaining full message text if a smaller, permitted record is enough for evaluation.

Also decide what happens when the request fails, times out or returns a result your application does not recognise. A sensible fallback is to hold the record or send it for review, rather than silently choosing the most convenient branch. Test those failure paths before launch.

Step 5: Evaluate against labelled examples

Create a test set from historical cases, then have a suitable reviewer confirm the expected label. Include straightforward cases and difficult ones: missing information, mixed intent, vague wording, conflicting fields and messages that do not fit any normal category.

Run the decisions on those examples and compare the outputs with the agreed labels. Look at more than overall agreement. For lead routing, a false sales_ready label may waste sales time, while a false nurture label may delay a real opportunity. For complaint triage, missing a serious issue may be more costly than sending an ordinary message to human review. Those costs should shape thresholds and fallback rules.

Do not copy a confidence threshold from an unrelated workflow. Start with a review band for borderline cases. Then examine examples near the boundary and decide what level of uncertainty your team can accept. A score or probability is not automatically calibrated to your business outcomes. Calibration means checking whether the model’s confidence corresponds to observed correctness on your own data.

Track errors by category, not only as one total. If the model regularly confuses two labels, revise the criteria or combine labels that do not lead to different actions. If it is wrong because the input omits an important field, fix the input rather than adding more elaborate wording to the question.

Keep a set of examples aside for later checks. Use it after changing the labels, instructions, input fields or model. Otherwise, a prompt change that appears to help on the examples used to design it may simply be overfitting to those examples.

Step 6: Set thresholds and human review

Choose how the application responds to high-confidence, uncertain and malformed results. A confidence signal can inform a route, but use your labelled set to check how it behaves. If confidence is low, the label is unexpected, or the input is incomplete, a human review branch is usually safer than forced automation.

There is no universal threshold that suits every marketing task. A low-risk editorial prioritisation can tolerate a different level of error from routing a sensitive complaint. Set the review policy with the people who own the downstream process. Record why a case was sent to a person so you can see whether the review branch is catching genuinely hard decisions or simply too many routine ones.

Where a person corrects a label, capture that outcome for later evaluation. Do not automatically treat every correction as ground truth without review. People can disagree, and the original instruction may not reflect the business rule. Use feedback to improve the process deliberately rather than changing the live criteria after every individual case.

Step 7: Check cost and latency in the full workflow

OpenAI says the Decisions API can be up to 10 times faster than GPT-6 Luna through the Responses API. That is OpenAI’s product claim, not a guaranteed latency for every prompt, region or production setup. Measure your own end-to-end time, including network, application processing, retries and any follow-up call.

The Decisions guide lists uncached input at $0.10 per 1 million tokens and says output tokens are not charged. Here is a transparent token-cost illustration:

• Assume one uncached decision request contains 1,000 input tokens.
• The Decisions input charge is 1,000 × $0.10 / 1,000,000, or $0.0001.
• For comparison, a Responses API call at GPT-6 Luna’s standard rates, with the same 1,000 input tokens and 100 output tokens, costs $0.0001 for input plus $0.00005 for output, or $0.00015.
• Under those assumptions, the Decisions call is one-third less for that model call.

These figures are from OpenAI’s Decisions documentation and pricing information and are an illustration, not a promise of workflow savings. They exclude caching, long-context or regional-processing premiums, and any follow-up call. If a decision is followed by a generated response, count both calls and any repeated input. If your current process already produces very little output, savings may be modest.

Measure cost per processed record and cost per correctly routed record, not just cost per API call. Also track the review rate, error rate, time to route and the downstream outcome that matters to the team. A cheap classification that creates extra manual work may not be a better workflow.

Step 8: Consider caching and usage monitoring

Prompt caching may help when you repeatedly send an identical shared input prefix. OpenAI says that prefix must be at least 1,024 tokens to qualify, and the questions content does not count towards that threshold. Keep the shared prefix identical across requests if you want it to be eligible. Do not pad prompts with irrelevant material just to reach a caching threshold; the added context must still be useful.

The Decisions guide lists uncached input at $0.10 per million tokens. It says cache reads and writes use GPT-6 Luna’s standard caching rates. OpenAI’s pricing page lists standard GPT-6 Luna cached input at $0.01 per million tokens, with cache writes at $0.125 per million for 30-minute writes and $0.25 per million for 12-hour writes. Regional-processing premiums and long-context multipliers may also apply. Check the current OpenAI pricing page for the rates and conditions that apply to your account.

For usage monitoring, OpenAI provides GET /v1/organization/usage/decisions. The endpoint requires an admin API key with the api.usage.read permission. Its request count represents API requests, not each question inside a batched request. That distinction matters if you compare request volume with the number of records processed. Combine usage data with your own application logs to understand questions per request and outcomes per record.

A practical rollout plan

A measured launch reduces the chance that a fast branch becomes an unexamined source of mistakes.

1. Run in shadow mode. Generate a decision but do not let it control the live route. Compare the output with the existing process.
2. Review disagreements. Look for unclear labels, missing fields and cases where the old process was itself inconsistent.
3. Automate a narrow case. Start with an action that is reversible and low risk. Keep ambiguous cases with a person.
4. Monitor weekly at first. Review disagreement patterns, review volume, latency, cost and downstream results. Increase the review sample if the workflow changes or performance is unclear.
5. Expand only with evidence. Add another label or action only when the existing branch has stable criteria and a workable fallback.

For an agency, keep a separate evaluation set for each client or materially different workflow. Labels that make sense for one client’s sales process may not mean the same thing for another. For a SaaS or e-commerce team, version your rules so that a product, policy or campaign change does not silently alter what a label means.

If the decision supports content or AI-search planning, keep the operational classification separate from your visibility measurement. SearchFIT’s guide to AI visibility versus organic search visibility explains the distinction between those measurement areas. A content score from a Decisions workflow is not, by itself, evidence that a page will earn citations or improve search performance.

Tips and mistakes to avoid

Keep the question narrower than the workflow

Ask for one label or score at a time. Do not combine lead qualification, account research, email drafting and CRM updates into one request. Clear boundaries make it easier to test each part and decide which system owns it.

Give every choice a useful description

A list of labels without definitions invites overlap. Describe what observable evidence belongs in each category and what should happen when the evidence is missing. Include a review route if your business process allows it.

Do not use a model judgement as a hard rule

The model can interpret text, but your application should enforce consent, suppression, eligibility and permissions. Keep the action layer predictable and auditable.

Do not treat a score as a KPI without validation

A rubric score can help order work for review. It is not automatically a measure of quality, conversion potential or future search visibility. Compare it with labelled examples and real outcomes before using it to set targets.

Do not assume batching removes dependencies

Batch independent questions that use the same input. If one question relies on the answer to another, make separate requests. Otherwise, the second answer is not based on the first result in the way a sequential workflow requires.

Do not claim savings from one token comparison

The cost illustration is for a particular input and output assumption. Include retries, caching, repeated context, follow-up generation and application costs in your own comparison. Report the assumptions alongside any internal savings claim.

Wrap-up: make one branch useful before scaling it

The OpenAI Decisions API is most useful when a marketing workflow needs a well-defined judgement and your software already knows what to do with the result. Start with one narrow branch, write distinct criteria, test against labelled examples and send uncertain cases to people. Keep business rules and actions in your application, then monitor both API usage and the results of the workflow.

The next step is to map one current routing or triage task and gather examples before building. If you are also planning the wider AI-search work around that workflow, browse SearchFIT’s resources and pricing. SearchFIT is a separate platform; these links do not imply a Decisions API integration. For a broader comparison of platform and agency options, see SearchFIT’s comparison.