OpenAI's Decisions API and Perplexity's Decisions API both evaluate text and images for classification, scoring, and yes/no questions. Their main differences are the models you can use, how you send questions and read answers, and deployment options. OpenAI provides a hosted public beta; Perplexity offers a hosted API and downloadable decision-model weights.
Copy link to headingHow do the two APIs compare?
Both APIs let an application ask several questions about shared evidence. Each question returns a defined answer type, following the standard decision models approach. Their native JSON formats the two APIs offer differs:
OpenAI's native Decisions endpoint uses gpt-6-luna. Perplexity supports pplx-decider-v1.1-27b and the earlier pplx-decider-v1-27b; the examples below use v1.1. Both requests go directly to the provider with its own API key.
Copy link to headingDo their question types mean the same thing?
The three question types express the same kinds of judgments, despite differences in naming and encoding. OpenAI's predicate and Perplexity's noul return the estimated probability that a condition is true. Your application determines how that probability affects the workflow.
For category selection, both use choice. One detail to preserve during migration is that OpenAI accepts string or Boolean choice values. The string "true" and the Boolean true are distinct values. Perplexity's options are JSON object keys, so use string category names if you want a shared definition across providers.
Both APIs use score for an ordered rubric. The result is a probability-weighted average of the levels' zero-based indices, so it can fall between levels. Suppose an event description is rated as missing essential details, partially complete, or complete. The returned score summarizes the distribution over those levels; use choice when the application needs one named category.
Copy link to headingWhat does the same request look like on each API?
Consider an events directory that needs to identify listings requiring advance registration. The distinction is between mandatory booking and optional registration, so both requests state that rule explicitly and use the same invented listing.
Run these commands in a terminal with curl installed and the corresponding OPENAI_API_KEY or PERPLEXITY_API_KEY environment variable set. Each command prints the provider's response.
Copy link to headingOpenAI: ask a predicate question
curl --fail-with-body https://api.openai.com/v1/decisions \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-6-luna", "input": "Evening at the observatory: reserve a place before arrival. Entry is free, but visitors without a booking cannot join the telescope session.", "questions": [{ "name": "registration_required", "type": "predicate", "instructions": "Does attending the telescope session require advance registration? Optional or recommended registration does not count." }] }'Find the answer named registration_required in the answers array. If its type is predicate, read probability; OpenAI can instead return a refusal for an individual question, which needs a separate handling path.
Copy link to headingPerplexity: ask a noul question
curl --fail-with-body https://api.perplexity.ai/v1/decisions \ -H "Authorization: Bearer $PERPLEXITY_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "pplx-decider-v1.1-27b", "state": "Evening at the observatory: reserve a place before arrival. Entry is free, but visitors without a booking cannot join the telescope session.", "questions": { "registration_required": { "type": "noul", "instructions": "Does attending the telescope session require advance registration? Optional or recommended registration does not count." } } }'In Perplexity's response, look up registration_required in answers and read its noul value. The native API reference defines this as the yes/no probability.
These requests ask the same question, but the models may assign different probabilities. Before using either result to label a listing, test cases such as “booking recommended,” “walk-ins welcome,” and “reserve equipment in advance, admission needs no booking.” Those examples distinguish the attendance requirement from nearby conditions that could otherwise trigger the label.
Copy link to headingHow do text and image inputs differ?
OpenAI accepts a text string or user messages containing text and image parts. Perplexity's state can hold a string, object, or array, which lets you send a structured record directly. To compare a record across both APIs, serialize it into the same text representation so each model receives equivalent evidence.
Both accept inline images encoded as base64 data URLs. OpenAI places an input_image part inside a user message; Perplexity uses an image_url part in state. Neither native endpoint fetches hosted HTTP or HTTPS image URLs. Your application must obtain and encode the image before sending it.
For the events directory, a poster could contain a registration condition missing from the description. Include the same poster and text in both requests when evaluating that workflow. Perplexity's image input requirements also specify image sizing constraints, so check those before reusing an existing image pipeline.
Copy link to headingCan you run a decision model yourself?
Perplexity publishes pplx-decider-v1.1-27b weights under Apache 2.0, giving you a local deployment option alongside its hosted API. The checkpoint uses a dedicated decision head and includes an inference implementation that preserves its attention settings and applies saved calibration.
Follow that implementation when deploying the model. Loading the weights through a standard causal text-generation setup changes the computation, and the decision head is not a full-vocabulary language-model output head. You also need to operate the GPU infrastructure and any HTTP service your application calls. The published setup calls for Python 3.12 or later and approximately 49 GiB for weights, plus working memory.
OpenAI's integration here uses its hosted Decisions API. If local model operation is a requirement, Perplexity provides a checkpoint to evaluate; if you plan to use a managed API, compare the hosted services using the same application examples.
Copy link to headingWhat needs to change when switching providers?
When switching providers, convert the evidence and question containers along with the endpoint and model ID, then adapt the response reader. For Choice and Score answers, OpenAI returns probability entries in arrays, while Perplexity uses objects keyed by option name or score index. Keep the model ID with stored results so you can trace a decision to the version that produced it.
Recheck thresholds after that conversion. Both APIs expose answer probabilities and separate confidence values for Choice and Score, but matching field names do not establish that a cutoff transfers between models. Review false positives and false negatives on labeled examples, alongside how many cases your application leaves for review.
For the registration example, a low yes probability should not automatically produce a “walk-ins welcome” label. The listing may omit the condition entirely. If the interface needs to distinguish optional booking, mandatory booking, and missing information, define those as separate choices and evaluate that question instead.
Handle refused answers and failed requests separately from valid predictions. In particular, an OpenAI refusal has no predicate probability to compare with a threshold. Preserve the original listing for review when the application cannot obtain a usable answer.
Copy link to headingWhat can't these decision endpoints do?
These endpoints evaluate the evidence you supply. Asking whether registration is required doesn't retrieve an event's booking policy or reserve a place for the user. Your application handles retrieval and any subsequent operation, including its authorization requirements.
Their answer types also constrain what you can request. If a workflow needs extracted event dates or a written explanation alongside a label, use an extraction or generation step with an appropriate output schema. Keep the decision question focused on the judgment your application needs.
Copy link to headingFrequently asked questions
Copy link to headingCan I switch between OpenAI and Perplexity by changing the base URL?
No. OpenAI and Perplexity use different evidence fields, question containers, and answer structures. Switching requires translating the request and response formats as well as updating the model ID and credentials.
Copy link to headingDoes image support distinguish these two Decisions APIs?
Both native APIs accept text and inline images. The difference is how those images are packaged and which input limits apply, so an existing image request needs adapting before it can be sent to the other provider.
Copy link to headingCan I reuse the same confidence threshold across providers?
Treat an existing threshold as a candidate to test, not an established rule for another model. Validate it against labeled examples and the consequences of incorrect decisions before using it to automate actions.
Copy link to headingIs Perplexity's downloadable model the same thing as its hosted API?
Perplexity publishes a v1.1 decision checkpoint as well as serving a v1.1 model through its API. Running the checkpoint requires its inference implementation and suitable hardware; the hosted API additionally provides the HTTP interface and managed infrastructure.