How Much To Run AI
Open weights

Perplexity Decider: v1.2, Flash and Input Costs

Perplexity Decider turns text and images into classification, routing and scoring probabilities. The current native API offers v1.2 at $0.02 per million input tokens and Flash v1.2 at $0.01, with free output. Related questions can share state processing within a billing group. The historical v1.1 Apache 2.0 checkpoint remains a separate self-hosting option.

Content reviewed:

Open Perplexity Decisions quickstart ↗

Use this model

Official model repository

Use cases

  • Route support tickets to defined teams and hold ambiguous cases for triage.
  • Flag a visible defect in a supplied photo using a written yes/no criterion.
  • Score reports against ordered rubric levels, keeping the distribution for review.

Choose current v1.2 or Flash, then define the answers

Use pplx-decider-v1.2 for the 27B API or pplx-decider-flash-v1.2 for the 4B Flash API. The rolling aliases are pplx-decider-latest and pplx-decider-flash-latest. Legacy native IDs such as pplx-decider-v1.1-27b now serve v1.2 at the current rate; that does not rename or update the downloaded v1.1 checkpoint. The response model field can echo your requested alias, so it is not an independent version check.

A noul question returns the probability of yes. Choice gives each supplied option a probability and selects the highest. Score returns a distribution over ordered levels and their expected index, which can fall between levels. Choice and score also return confidence; this certainty estimate is distinct from the top option’s probability.

Use a text generator such as general GPT-6 Luna when a customer needs a written explanation. Decider supplies structured decisions, so your application defines the labels, validates thresholds and decides what happens next.

Perplexity Decider reads a fictional ticket and named questions, returns probability distributions, then application thresholds route or send the case to review.
Question-design illustration using a fictional ticket. No API output or measured probability is depicted.
Question typeSupport exampleApplication use
noulDoes the ticket report damaged hardware?Flag likely damage for inspection
choiceWhich team owns the main problem?Choose account, billing or triage
scoreHow severe is the interruption?Order work using named severity levels

Try one named routing question

Create a Perplexity API key, keep it on your server as PERPLEXITY_API_KEY, and POST to /v1/decisions. The questions field is a named object: the answer appears under the same name in answers. This fictional ticket asks for the team responsible for the main problem.

Inspect answers.queue.choice, its probabilities and confidence, together with the HTTP status and usage.input_tokens. Check whether account wins, but also retain alternatives for cases that mention both invoices and login trouble. Agree labels on a small set before choosing the threshold for automatic routing.

Illustrative direct API routing request
curl https://api.perplexity.ai/v1/decisions \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model":"pplx-decider-v1.2",
    "state":"After changing my password I cannot sign in. My invoice looks correct.",
    "questions":{"queue":{
      "type":"choice",
      "instructions":"Choose the team responsible for resolving the main problem.",
      "criteria":{
        "account":"Sign-in and account access problems",
        "billing":"Incorrect charges or invoices",
        "triage":"Unclear requests or problems outside these teams"
      }
    }}
  }'

Size the complete state and questions

A request supports 1 to 128 non-empty question names. Keep total input under 262,144 tokens, counting state, images and every question. Choice allows up to 255 options; score allows up to 10 levels. Keep labels distinct and ordered rubrics explicit so the probabilities remain useful.

State accepts text, JSON and images. For the direct API, use PNG, JPEG or WebP Base64 data URLs in image_url parts; it does not fetch remote HTTP image URLs. Each image must fit 2,048 tiles of 32 by 32 pixels. Resize before sending, and include image tokens in the input budget. The native documentation allows up to eight images per question.

Respect your organization’s rate limits and Retry-After on 429 responses, and use bounded backoff for service errors. Native and gateway model IDs, billing and limits can differ; the current native v1.2 behavior should not be inferred from an older OpenRouter route.

How grouped questions change Decider input billing

The native v1.2 rate is $0.02 per million input tokens; Flash v1.2 is $0.01. Output is free and there is no native per-request fee. Use returned usage.input_tokens for billing, including state, image and question tokens.

Questions assigned to a group read the shared state once for that group. If questions overflow into another group, that group processes the state again. Questions in the same group also see one another, so grouping can change scores as well as cost. Do not calculate a multi-group request as a single state read.

Flash normally uses one question per group; related select-all and routing questions are the cases for grouping. Compare grouped and separate questions on labeled examples before choosing the cheaper arrangement. Add retried requests and downstream text generation to the task total.

If 10,000 requests each report 2,000 billed input tokens, the token charge is $0.40 on v1.2 or $0.20 on Flash. At 20,000 billed tokens per request, it is $4.00 or $2.00. These examples use returned totals rather than guessing how many state reads occurred.

Returned input across workloadv1.2 at $0.02/MFlash at $0.01/M
20M billed tokens$0.40$0.20
200M billed tokens$4.00$2.00

Compare decision quality on the same cases

For the historical v1.1 checkpoint, Perplexity’s model card reports Decision Index 61.56 versus 56.4 for v1 and 57.9 for Jev. Its Tools score is 78.88 versus v1’s 79.3. These are vendor checkpoint results, not a new evaluation of the current v1.2 API or Flash.

For a hosted comparison, OpenAI Decisions uses GPT-6 Luna with a $0.10/M base input rate and its applicable long-context and regional multipliers. The nominal base input rate is five times Decider’s, but a task decision needs comparable labels, error checks and billed usage. OpenAI uses an input field and an array of questions; Perplexity uses state and a named questions object. Translate the rubric deliberately rather than swapping the model name.

The existing OpenAI guide contains a Classmethod ticket example with three questions and five repeated calls. It measures that endpoint’s small latency example, not a Decider head-to-head. Liquid d1 and Jev offer other decision-model workflows. Give every candidate the same labeled content, compare missed cases and false alarms at a chosen threshold, and record retries and downstream review. A high returned probability needs validation on your task distribution.

Self-host the historical v1.1 checkpoint separately

The Hugging Face model card lists Apache 2.0 and a Qwen3.8-27B backbone. Its usage instructions require Python 3.12+, authenticated Hugging Face access and a CUDA GPU with room for roughly 49 GiB of weights plus working memory. Treat this as a weight footprint, not a complete serving allocation.

Use the repository’s pinned dependencies and included DecisionModel implementation. The checkpoint has a separate decision readout rather than an ordinary full-vocabulary generation head. Its evaluated behavior depends on noncausal full-attention layers and the saved calibration temperature. A standard causal chat-serving configuration can change its probabilities.

Download the exact v1.1 repository, retain the release manifest and compare its answers on your labeled cases before sizing concurrency. Self-hosting adds working memory, input processing, serving and operations costs. The hosted $0.02/M quote is a service tariff, not a GPU throughput measurement.

Before you use it

  • Keep unclear content on a review path and validate probabilities before using a threshold to trigger actions.
  • The 262,144-token context covers state, images and all question text; the native request must stay below that limit.

How to get started

Start with the named routing question, save usage and distributions, then compare a labeled batch with your current router. Use the repository’s included implementation for a separate self-hosting trial.

Sources

Sources (3)

Calculators