> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apostra.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Reading your seller's setup checklist and go-live state

> How a seller account reads its setup checklist, go-live verdict, demand coverage, product count and source-health diagnoses in one call.

A seller account can read its whole setup picture in one call: the checklist it still has to finish,
whether it is live, how much demand its inventory covers, how many wholesale products it has, and what is
wrong with its sources. It is opt-in. A `get` of the seller that does not ask for it returns exactly what it
returned before.

## Read it

Call `get` with `kind: "seller"`, no `id`, and `include: ["readiness"]`:

```json theme={null}
{
  "readiness": {
    "checks": [
      {
        "id": "operator_domain",
        "name": "Seller Account domain",
        "description": "Verify the domain buyers see for your seller account.",
        "status": "missing",
        "isBlocker": true,
        "details": null,
        "actionLabel": "Set up your Seller Account domain",
        "action": { "page": "seller_setup" }
      }
    ],
    "goLive": {
      "state": "setup",
      "reasonCode": "setup_incomplete",
      "progress": {
        "required": 5,
        "completed": 3,
        "inProgress": 1,
        "nextStepId": "operator_domain",
        "issues": { "attention": 0, "critical": 0 }
      }
    },
    "demandCoverage": {
      "eligibleCombinations": 12,
      "coveredCombinations": 5,
      "sampleBriefs": [],
      "useCasesOffered": 3,
      "useCasesCounted": 8,
      "computedAt": "2026-11-17T11:02:00Z",
      "stale": false,
      "useCases": []
    },
    "wholesaleProductCount": 7,
    "sources": [],
    "sourcesOmitted": 0,
    "diagnoses": []
  }
}
```

The include belongs to the seller account that is reading itself. It is refused on any other kind, on a
seller read that names an `id`, and for a buyer account. It is the largest seller include, so ask for it only
when you need the checklist. To see only what is blocking the account, call the status tool.

## Checks

Each entry in `checks` is one setup step.

| Field | Meaning |
| - | - |
| `id` | Stable id of the step, for example `operator_domain`. |
| `name`, `description` | What the step is, in words. |
| `status` | `complete`, `partial`, `missing` or `optional`. `optional` means the step is not required before going live. |
| `isBlocker` | `true` when the step must be complete before the seller can go live. |
| `details` | Evidence for the current status, or `null` when there is none. |
| `actionLabel` | The name of the step in the words the status tool uses for it, or `null` when the check is complete. |
| `action` | Where to resolve the step, or `null` when the step is complete or has no destination. |

`action` has the same shape as an entry in the status tool's `nextActions`: a `tool` to call, a `page` to open
for a step a model must not drive (a credential or an access grant), a `url`, and the `arguments` to pass.

## What some checks mean

These are the checks sellers most often ask about. `isBlocker` says whether a check stops the seller going
live.

* **`currency_confirmed`** blocks. It stays `missing` until the seller confirms the currency it settles in.
  Apostra never picks one. A currency Apostra cannot settle also leaves it `missing`, and `details` lists the
  currencies it can. When it is `complete`, `details` reads `Primary: USD` and, if the seller is also paid in
  other currencies, `Additional: EUR, GBP` on a second line. Set `defaultCurrency` and `paymentCurrencies` on
  `save_seller`, as [the first booking guide](https://docs.apostra.com/v3/seller-first-booking.md#step-3-set-your-payout-currency-and-your-markets)
  describes. A seller whose sales run on a direct sales adapter that Apostra operates, such as Meta or Google,
  does not get this check.
* **`supported_billing_declared`** blocks when the sales agents behind the seller declare billing models and
  none of them is one a buyer can activate on. A buyer can activate on `agent` (consolidated billing) or
  `operator` (direct billing, where the seller bills the buyer). A sales agent that sets
  `account.require_operator_auth` does not change this when Apostra calls it with your connected credential,
  because the storefront is the operator: its declared billing is read like any agent's. Only a pass-through
  storefront, where the buyer connects their own credential, needs `operator` for it. When several sales agents declare billing, a model counts only if every one
  of them includes it. `details` names what was declared. Fix the declaration on the agent, then refresh its
  capabilities.
* **`sales_agent_principal_missing`** is listed as a blocker (`isBlocker: true`), but it does not stop buyers
  finding or buying from the seller. Buyer discovery, activation and booking ignore it. The connected ad
  server's managed sales agent has not finished setup, so creative sync for linked buyer accounts is refused
  until it does. `details` says to contact support. It clears on its own once the setup is done.
* **`business_profile`**, named **Public profile**, checks the seller's description, channels and countries.
  For most sellers an incomplete profile does not block going live (`isBlocker: false`). For sellers in the
  cohort where the profile is a go-live requirement, it blocks. Read `isBlocker` on the seller's own check
  rather than assuming either state.
* **`publisher_domains`** blocks until the seller has declared at least one publisher domain, so buyers know
  what is being sold. The brand domain is not a publisher domain unless the seller declares it as one.
  **`publisher_authorization`** reports how many declared domains have authorized the seller in
  `adagents.json`, and **`product_publisher_domains`** reports products that carry no declared publisher
  domain. Neither blocks going live or booking.
* **`source_products_traffickable`** says whether the products synced from the seller's sources declare what
  the ad server needs to traffic them, such as a video duration or display dimensions. It blocks only when
  every synced product is untraffickable. When only some are, it is `partial` and the rest can still sell.
  `details` names the affected sources.

## Two checks Apostra completes

Two checks are steps Apostra takes, not steps you take. Neither asks you to do anything in the checklist.

### Marketplace listing

`marketplace_listing` says whether other buyers can find your storefront. Apostra reviews every new listing
before buyers outside your organization can find it, so a new storefront starts with this check open. It
completes when Apostra lists the storefront.

While it is open:

* Buyers in your own organization can already find and use the storefront, and book with it once the rest of
  your checklist allows.
* Buyers in other organizations cannot find it in discovery.
* The check never blocks going live or booking, and it does not count in `goLive.progress`.

Apostra does not publish a review time. The check reads `Apostra review is open` until the review is done, and it
completes as `Listed in the marketplace`.

| What you see | What it means |
| - | - |
| `partial`, `Apostra review is open` | Apostra has not finished reviewing the listing. |
| `complete`, `Listed in the marketplace` | Other buyers can find the storefront. |
| `missing`, `Hidden from the marketplace by Apostra` | Apostra has taken the storefront out of discovery. Buyers in your own organization can still use it. Contact [Apostra Support](https://docs.apostra.com/v3/support.md) if you did not expect this. |
| `optional`, `Marketplace participation is turned off` | You turned off marketplace participation, so other buyers cannot find the storefront whatever the review says. Buyers in your own organization can still use it. Turn it back on when you want to be found. |

### Listed without waiting, when a buyer asked for you

When a buyer has asked Apostra for inventory you sell, Apostra lists you itself instead of waiting for the
review. A buyer's request counts when at least one of your active, priced products is on the channel the buyer
asked for, names the publisher domain the buyer asked for in its publisher properties, and your markets reach
the countries the buyer named, if it named any. This is the same whether you are the publisher's own seller or a
reseller.

Apostra lists you when all of these are also true:

1. Your brand domain is verified (`operator_domain` is complete).
2. An inventory source is connected (`inventory_sources` is complete) and has no open source-health problem.
3. At least one product is active with a price (`products_available` is complete).
4. Your account is active and is not being closed.

Apostra checks every storefront that waits on its first review on a schedule, at least once a day, and lists you
on the first check after a buyer's request covers you and all four are true. Apostra can still review the listing
afterwards and take you out of the marketplace.

While a buyer's request covers you, the `marketplace_listing` description says which of the four you still
need, and `details` reads `Automatic listing waits on N checks: ...`, or `Automatic listing is due` once all
four pass. It never says which buyer asked.

The publisher's `adagents.json` does not have to authorize you for this. When a publisher you were asked for has
not authorized you, or Apostra could not read its file, the description names the domain and the entry to ask
the publisher to add. Buyers can see whether a publisher authorizes you, so ask for it. See
[Publisher adagents.json entry](https://docs.apostra.com/v3/seller-publisher-adagents.md).

A storefront Apostra has already reviewed, one you have taken out of the marketplace, and an organization's test
storefront are never listed this way.

### Ad-server go-live certification

On a managed ad server, Apostra runs a no-spend certification before the first booking. For Google Ad Manager it
is the write canary, and for FreeWheel it is the booking certification. You do not run it.
`esa_go_live_certification` stays open until it passes.

While it is open, buyers can still find your storefront, see its products and plan with them. A booking is
refused with a message saying the storefront has not finished going live. This check does block booking.

When the certification passes, the check completes and booking opens. You do not need to do anything to open
it.

## Ad-server execution currency

`esa_execution_currency` is open when Apostra cannot confirm that an ad-server source books in a currency your
storefront settles in. A price and an ad-server order must never be in different currencies, so this check
blocks. The source's card says **Not buyable**, and buyer requests do not reach that source until the check
passes.

The currency checked is the one your ad server reports booking in, not your storefront's default currency. If
your storefront settles in several currencies, an ad server that books in any one of them passes. An ad server
that reports no booking currency does not pass. Apostra never converts an order from one currency to another.

Apostra fixes this itself when the currency is already proven, for example a GAM network that books in a
currency your storefront settles in. Otherwise, what to do depends on the ad server:

* **Google Ad Manager.** Run **Test connection** on the source. Apostra reads the network's currency from GAM
  and keeps it when your storefront settles in it. If GAM and your storefront have no currency in common,
  change your payout currency or use a GAM network that books in one you settle in.
* **FreeWheel.** Check that the source's execution currency is the one FreeWheel puts on your insertion orders,
  and that your storefront settles in it. To change it, open the source's configuration and choose **Save
  execution currency**. You do not need to re-enter your credentials. If FreeWheel's existing orders book a
  different currency, change the source's currency to match. If the credentials connect but cannot read
  insertion orders, reissue them with read access to insertion orders.
* **AdsWizz.** Apostra reads your agency's currency from AdsWizz. Run **Test connection** to read it now. If
  the test passes but no currency is recorded, ask AdsWizz to give your API key read access to the agency. If
  the agency books in a currency your storefront does not settle in, change your payout currency or use an
  agency that books in one you do.
* **SpringServe.** SpringServe has no account currency to read, so the currency you declare on the source is
  the one Apostra uses. Declare one your storefront settles in with the source's execution currency action.
  You do not need to re-enter your credentials.

If the check says the currency contract is unavailable, run **Test connection** again. If it stays unavailable,
contact [Apostra Support](https://docs.apostra.com/v3/support.md).

A currency problem is not a credentials problem. Do not reconnect or replace your credentials to fix it.

## Buyer demand for your domains

Buyers can ask Apostra for inventory they cannot find yet. When buyers have asked for inventory on a domain
that is yours, your checklist shows one item, `buyer_demand`, named **Buyer demand**. It tells you the demand
exists before you have set anything up. It is information, not a step.

The item counts a request as open until it is met or dropped. A request stops counting when it goes live, when
it is canceled, or when the buyer withdraws it or says it is resolved. A request you made yourself is not
counted.

The item matches the domain of your seller account and each publisher domain you declare. It ignores case and
a leading `www.`, so a request for `www.example.com` counts for `example.com`.

It tells you three things and no more:

* How many different buyers asked. A buyer who asked for several channels counts once.
* Which channels they asked for, as the channel codes you save in your markets, such as `display` or `olv`.
  A request that names something that is not a channel code is counted but not listed.
* Which of your domains they asked about.

It never says who asked, and it does not show what a buyer wrote. It names no countries yet.

For example: `3 buyers have asked for display and olv on example.com.` To make sure their requests reach you,
check that the channels you sell in include theirs. [Seller markets](https://docs.apostra.com/v3/seller-markets.md) explains how your
markets decide which requests reach you.

| Field | Value |
| - | - |
| `status` | Always `optional`. It is information, so it is never your next step. |
| `isBlocker` | Always `false`. It never blocks going live or booking, and it does not count in `goLive.progress`. |
| `action` | None. There is nothing to run or fix in the checklist. |

When no buyer has an open request for your domains, the checklist has no `buyer_demand` item. A missing item
does not mean something is wrong. If Apostra cannot read the requests when it builds your checklist, the item
is left out and the rest of the checklist is unchanged.

## Buyers switch you on

A buyer outside your organization sees your products only after it switches you on for its advertisers. It
does that one advertiser at a time, or for every advertiser in its account. Apostra does not switch a new seller
on for buyers, even when your markets and channels match theirs; it does that only for market makers. Buyers in
your own organization can use your storefront without switching it on.

So your checklist has one item, `buyer_switch_on`, named **Buyers switch you on**. It says how many buyer
accounts outside your organization have switched you on, and for how many of their advertisers, for example
`So far 2 buyer accounts have switched you on, for 3 advertisers.` When none has, it says so. The count goes up
as buyers switch you on, and down when they switch you off.

It counts an advertiser when its buyer switched you on for that advertiser, or for its whole account with
**Always include**. A buyer account that turned you off with **Always exclude** is not counted, whatever it chose
for its advertisers. An advertiser the buyer has deactivated is not counted. It never says which buyers or
advertisers they are.

| Field | Value |
| - | - |
| `status` | Always `optional`. It is information, so it is never your next step. |
| `isBlocker` | Always `false`. It never blocks going live or booking, and it does not count in `goLive.progress`. |
| `action` | None. A buyer switches you on; you cannot do it for them. |

A market maker's item says that Apostra switches it on for buyers within the markets and channels of its market
maker agreement, and counts the buyers that switched it on themselves. An organization's test storefront has no
`buyer_switch_on` item. If Apostra cannot read the count when it builds your checklist, the item is left
out and the rest of the checklist is unchanged.

## Publish the audiences buyers can target

When you sell through Google Ad Manager or SpringServe, your checklist asks you to publish the audiences buyers
can target. The item is `audience_signals`. A signal is an audience, or other targeting data, that buyer agents
can find and add to a buy. Buyers can only target audiences you publish.

To publish one, open **Signals** under **Storefront agent** in the Apostra app, pick an audience from your ad
server, and select **Create signal**. You can set a CPM price on the signal before you create it. An agent can do
the same with `save_signal` (see [Signals](https://docs.apostra.com/v3/tool-reference.md#signals)).

* **Google Ad Manager.** Pick an audience segment, or a custom targeting value under a key.
* **SpringServe.** Pick a key-value list that describes an audience.

FreeWheel, AdsWizz and Broadsign have no `audience_signals` item, because the Signals page cannot map audiences
from them yet.

The item is complete once you have published at least one signal on one of these ad servers. Property signals
do not count. Apostra creates them to target the sites a buy runs on, and buyers never see them. If you have
only property signals, the item says so and asks you to publish an audience.

### Third-party data in Google Ad Manager

If you license third-party data in Google Ad Manager, ask [Apostra Support](https://docs.apostra.com/v3/support.md) to enable those data
providers. You cannot turn this on yourself yet. In your request, give each data provider and segment name
exactly as Google Ad Manager shows them. For data you license directly from a provider, also give the data CPM you
pay that provider and its currency: Google Ad Manager doesn't report it, and the line item's rate depends on it
(see below). Only segments that are approved and active in Google Ad Manager sync. Their segments then appear on
the Signals page, and you publish them as you publish your own.

Google bills you each segment's data CPM on delivered impressions. Price each third-party signal above its
segment's data CPM, and don't publish one without a price: a signal with no price is free to the buyer, so you
would pay the data cost on every impression it serves.

When a buy on Google Ad Manager uses third-party data:

* **The line item carries your net.** Its rate is the media rate plus the signal prices the buyer pays, less what
  the third-party data the line item targets costs you. Google Ad Manager's revenue and auction then count only
  what you keep. The buyer pays the full price, and delivery reports the full price and spend. The line item's
  notes state the gross rate and the data cost taken off, so reconcile Google Ad Manager revenue from the gross in
  the notes. For example, on a $10 CPM package with a $2 CPM signal whose data costs you $0.75, the buyer pays
  $12 and the line item books at \$11.25.
* **The data cost follows how Google bills.** It counts every third-party segment the line item targets, paid or
  free, including the ones it excludes. First-party segments and key-values cost nothing. Google bills every
  excluded segment on every impression, but only the cheapest segment a user is in from a group of alternatives
  (an `any` group) ([How audience segment billing works](https://support.google.com/admanager/answer/2423361)).
  The sales agent can't know in advance which alternative a user will match, so it takes off the dearest one. The
  line item can then sit a little below what you actually keep.
* **The signals a buy pays for must cover their own data cost.** Their combined price (the highest in each child
  group, added up across groups) must be at least the data cost of those same signals' segments (the dearest in
  each `any` group, plus every segment in a `none` group), or the buy is refused. Data the buy doesn't pay for,
  such as a free exclusion, never refuses it: it lowers your net, below the media rate if need be.
* **Signals included in a product are paid signals.** When a storefront builds a product that includes one of
  your priced signals, the product's price covers that signal, and the storefront sends it to you with the price
  it charged. Your line item bills its data like any signal a buyer pays for, under the same rule. On an auction
  package the data price comes out of the buyer's bid, and a bid that would leave less than your floor for media
  is not sent to you.
* **A net of zero or less is always refused.** Google Ad Manager can't book a line item at that rate, so a buy
  whose data cost would use up its whole rate is refused, whether or not it pays for a signal.
* **A paid signal's data cost must be known.** A buy that pays for a signal is refused when the signal's segment
  hasn't synced or has no data CPM, when it's directly licensed and you haven't given its data CPM, or when its
  data CPM is in a different currency from the buy. In those cases, data the buy uses for free counts as costing
  nothing, which leaves the line item above your true net.
* **Only line items priced by CPM are netted.** A line item priced another way, such as by CPC, keeps its full
  rate.
* **No note means no netting.** A line item whose notes state no gross rate carries its full rate. That includes
  line items booked before this netting started, which are netted the first time an update changes the signals
  the buy pays for or targets.

| Field | Value |
| - | - |
| `status` | `missing` until you have published a signal, then `complete`. |
| `isBlocker` | Always `false`. It never blocks going live or booking, and it does not count in `goLive.progress`. |
| `action` | Opens the Signals page. |

If Apostra cannot read your ad server's signals when it builds your checklist, the item is left out and the rest
of the checklist is unchanged.

## When a wholesale pricing feed matches no products

Your uploaded rows can be valid while none of their exact `selector_type` and
selector-id pairs match a product on the source. In that case the feed prices
no products, even when it was uploaded recently.

Download the affected source's pre-filled wholesale pricing template. It
contains the selector types and ids its products reference. Move your pricing
values onto those rows, preview the file, and confirm that the preview reports
matched selectors before you commit the corrected feed. Uploading the same
selectors again will not fix the mismatch.

## When measured delivery replaces an uploaded availability figure

Availability in an uploaded wholesale pricing feed is a claim about traffic, and
Apostra measures the traffic. For each country where a product has current
delivery measured from your ad server in the last 48 hours, buyers see the
measured availability, on the same monthly horizon, in place of the figure you
uploaded. A country with no
measured delivery keeps your uploaded availability, and your uploaded prices
still apply. The measured figure is a lower bound, because an ad server does not
report the impressions it could have delivered but did not fill, and buyers
receive it as the forecast's conservative value with no optimistic value, which
reads as "at least this much".

The wholesale pricing readiness check names each country where this happened,
with the uploaded figure and the measured one, for example `NG: 1,000,000
uploaded, 25,141 measured`. If a figure you uploaded does not appear to take
effect, look there first. Uploading again does not change a measured figure; the
measurement updates as the ad server reports more delivery.

## Pricing guidance is not a condition for listing

What an ad server or an uploaded wholesale pricing feed supplies is guidance for
an auction product, not a condition for selling it. A missing, expired or
mismatched feed raises a warning on the seller's readiness and notifies the
seller, and it does not block going live. Products that carry an auction pricing
option stay listed to buyers whether or not that guidance is current. With no
guidance, buyers see the auction option with no floor and no price guidance, and
decide whether to bid. A product with no pricing option at all stays hidden, and
so does a product whose only price is a fixed price outside the seller's
settlement currency.

A managed ad-server source set to manual wholesale pricing upload that has no
current pricing is this same condition. It shows as one diagnosis, owned by the
seller: `failureMode: "wholesale_pricing_stale"`, `severity: "attention"`, with
the action **Upload wholesale pricing**. The source reads as degraded, not
unhealthy, and no other diagnosis for it says Apostra owns the problem or that
no action is needed. A seller that is otherwise selling stays live and reads as
needing attention. If no product has a fixed price or a floor, the **Products
available** check blocks going live instead, as described below.

One thing does need a price. Buyers who ask with a brief get products composed
for them, and composition builds on a fixed price or a floor. An auction product
with no floor and no price is offered in the seller's wholesale catalog but is
not composed into an answer to a brief. So the **Products available** check
counts only products that have a fixed price or a floor, and a seller whose
every product lacks both does not go live until one of them has one. A floor from
the seller's rate card counts, as described next.

## Where wholesale prices come from

A wholesale product's price has two parts, and they come from different places.

* **A fixed price comes from the seller.** It is a buy-it-now price. Today the
  seller sets it by hand on the product in the sales agent. A price list in the
  seller's media kit is planned and not available yet. An ad server never supplies
  a fixed price, and neither does the rate card.
* **An auction floor is the higher of two.** One is the floor in the seller's
  live rate card in the Library. The other is the product's existing floor: the
  floor the ad server reports or, for a product the ad server can't price, the
  floor from an uploaded wholesale pricing feed. The higher one is the floor buyers
  see, so a seller can never price an auction product below the floor the ad
  server enforces. An uploaded feed fills in for products the ad server can't
  price; it doesn't override a product the ad server prices. A rate-card floor applies to the products it
  matches by channel, publisher domain and the other scope on its row, and only
  when it is a `hard_floor` or `default` row with a floor price in the product's
  currency. It never becomes a fixed price. A row's channel is an AdCP channel
  code such as `olv` or `ctv`. A video product that doesn't name its channel
  counts as online video (`olv`), so an `olv` row applies to it; a product that
  names its channel, such as `ctv`, keeps that channel.

What an ad server or an uploaded feed supplies beyond the floor, such as the
percentile prices, stays price guidance on the auction option.

Committing a rate card, or changing its rows in settings, refreshes the seller's
wholesale catalog straight away, so a new floor reaches buyers without waiting
for the next ad-server sync. If that refresh fails, the rate card is still saved
and the catalog picks up the floor at its next sync.

## Go-live

`goLive.state` is one of `setup`, `live`, `live_attention` or `live_critical`. `reasonCode` says why it
landed there.

| State | Meaning |
| - | - |
| `setup` | Not live yet, and that is expected. |
| `live` | Live and healthy. |
| `live_attention` | Live, with something worth acting on. Buyers are not stopped. |
| `live_critical` | Live, or paused after going live, and buyers cannot be served as promised. |

A seller has gone live once a buyer's order went through its Storefront, or once it could transact.
Apostra's [certification buys](https://docs.apostra.com/v3/certification.md) and no-spend sandbox tests do not count, so a seller that has
only been through certification reads `setup`, with the next step toward going live.

`progress` counts the go-live steps: `required` steps the seller is held to, how many are `completed`, how many
open ones are `inProgress`, and the `nextStepId` (a check `id`) to take next. `nextStepId` is `null` once the
seller is live or nothing is left. `issues` counts the open problems behind the live states. Both are `0`
while the state is `setup`.

The Seller Dashboard shows the same next step above its analytics, with the check's action label and
description, and a button that opens the Seller Setup checklist. It disappears once `nextStepId` is `null`.

This is not the same answer as whether buyers can use the seller right now, which the status tool reports as
`state`. The go-live state adds setup progress and post-live health to it.

## Demand coverage and products

### Your plan with Apostra

After you go live, your plan shows the kinds of buyer demand you are working on
and the next steps for each. The seller and Apostra can mark a kind of buy as
`pursuing` or `not_for_us`, and either can change or clear that choice later.
Buyers cannot see these choices. If your catalogue offers a kind of buy, its
stance is `offered` while it is available; your saved choice returns if it
stops being offered. `offered` is worked out by Apostra and cannot be saved.

Save a choice with `save_seller({"useCases": [{"useCaseId": "audience_or_signal_targeting", "stance": "pursuing"}]})`.
Send `useCases` in its own `save_seller` call. Use `null` to clear a choice.
The result reports whether each choice changed. The plan's steps name the side
responsible: you, Apostra, or your agent's provider.

Suggestions are based on the channels you sell and open buyer requests. After
those requests, the order is audiences, video or audio with our trackers,
completed-view pricing, conversion tracking and display. Conversion tracking is
not suggested for a managed sales agent. Suggestions pause while a critical
live issue needs attention.

When discussing a suggestion, ask one question and record a choice only after
the seller confirms. For example: “Do you have audiences you sell?” for
audiences, “Do you sell video or audio with impression tracking?” for video or
audio, “Would you like to offer pricing per completed view?” for completed-view
pricing, “Would you like to support conversion tracking?” for conversions,
“Do you sell display inventory?” for display, “Would you like to offer TMP?”
for TMP, and “Do you sell inventory that relies on your own delivery reporting?”
for seller-reported buys.

`demandCoverage` says which buyer demand the seller can serve today. It answers in two ways: the starter
briefs its inventory covers, and the kinds of buy its products offer. Neither is a grade, and neither counts
toward going live.

`eligibleCombinations` is how many category, market and channel combinations the seller's profile makes it
eligible for, and `coveredCombinations` is how many of them its products cover. `sampleBriefs` shows up to four
of them, each with a `category`, `market`, `channel`, a `status` of `covered` or `needs_inventory`, and a
`rationale`. They are derived from the seller's own profile and inventory. They carry no buyer data.

### Kinds of demand you serve

`useCases` has one row for each kind of buy a buyer can make: the [certification use cases](https://docs.apostra.com/v3/certification.md#use-cases)
that depend on what a storefront sells, such as display with Apostra's tag, VAST video or audio, cost per
completed view or audience targeting. Each row says whether the seller's products offer it, read the same way
a [certification run](https://docs.apostra.com/v3/certification.md) reads them, so the two never disagree about a product.
`useCasesOffered` counts the rows that are offered, out of `useCasesCounted`. The use cases certification judges
on the agent whatever it sells, such as the compact lifecycle, are not on the list: they are not kinds of
demand.

```json theme={null}
{
  "useCaseId": "cost_per_completed_view_video",
  "name": "Cost-per-completed-view video",
  "offer": "not_offered",
  "reason": null,
  "owner": null,
  "evidence": { "basis": "stored_catalogue", "productCount": 0, "products": [] },
  "certification": [],
  "actionLabel": "Price a video product on completed views",
  "action": { "url": "https://app.apostra.com/inventory-sources" },
  "docsUrl": "https://docs.apostra.com/v3/certification#use-cases"
}
```

| Field | Meaning |
| - | - |
| `useCaseId`, `name` | The use case, named as the [use case table](https://docs.apostra.com/v3/certification.md#use-cases) names it. |
| `offer` | `offered`, `not_offered`, or `not_decided_from_catalogue` when the seller's products cannot settle it. |
| `reason` | Why the products cannot settle it, or `null`. See below. |
| `owner` | `scope3` when only Apostra can make the row offered, such as conversions on a managed sales agent today. Otherwise `null`. |
| `evidence` | Where the answer comes from: `basis`, `productCount` and up to three `products`, each with a `productId` and the `name` you gave it. |
| `certification` | One entry for each sales agent behind the seller with a result for this use case: `agentId`, `agentName`, its latest result for each kind of product counted as `passed`, `failed` and `inconclusive`, and `evaluatedAt`. Empty when no agent has a result yet, and `null` when the results could not be read. |
| `actionLabel`, `action`, `docsUrl` | What to do to offer it, for a row that is not offered. All three are `null` on an offered row. |

`reason` is one of:

* `capabilities_not_stored`: the use case depends on something your sales agent declares, such as conversion
  tracking or audience targeting, and Apostra has not stored what it declares.
* `catalogue_not_stored`: Apostra keeps no copy of the products. A linked storefront serves its inventory live,
  and an agent that builds products for each brief keeps none. For that agent, `offered` comes from the last
  live answer Apostra kept, and `evidence.basis` is `last_live_response`.
* `catalogue_unreadable`: Apostra cannot read the products it stored for a source.

An undecided row can still carry an action. A managed sales agent that has not declared audience targeting
leaves that row undecided, but publishing audiences makes it offered.

What to do depends on how the seller builds its products. A seller that builds products on Apostra is sent to
**Build products** or **Publish audiences**. A seller whose sources are all its own sales agents changes what its
agent offers, so it is sent to the [use case table](https://docs.apostra.com/v3/certification.md#use-cases), which says what a product must
declare for each one. Audiences are the exception: every seller can publish them.

Offered and certified are separate answers, shown side by side and never combined. A row can be offered while
its agent has not passed the use case yet, or the other way round. How real buys went is on the seller's own
scores (`include: ["scores"]`).

Apostra works the list out from the stored products and keeps it until they change. `computedAt` says when it
was worked out. After your stored products change, your sales agent declares something new or a stored price
expires, the next read works it out again. If that fails, the read returns the last list with `stale: true`. If there is no list at
all, `useCasesOffered`, `useCasesCounted`, `computedAt` and `useCases` are `null` and `stale` is `false`. The
rest of the readiness still returns.

`wholesaleProductCount` is the number of wholesale products the seller has authored across its inventory
sources. It is `null` when no source reports a count, which is different from `0`.

## Sources

`sources` has one card for each inventory source the seller has connected, in the order a seller should look at them: `critical` first, then `attention`, `paused` and `live`, and by name within each. It carries at most 20 cards, and `sourcesOmitted` counts the sources left out. To read a source that is not in the list, call `get` for that source with `kind: "inventory_source"`.

| Field | Meaning |
| - | - |
| `sourceId`, `name` | The source. |
| `setupKind` | How the source is set up: `ad_server`, `modular`, `external_agent` or `linked_storefront`. |
| `sourceStatus` | `PENDING`, `ACTIVE` or `DISABLED`. |
| `auth` | Whether the source needs credentials (`required`) and has them (`configured`). |
| `cardPosture` | Whether the source is connected, needs setup or needs attention: a `state`, a `reasonCode` and a one-sentence `explanation`. |
| `liveness` | Where the source stands: `paused`, `live`, `attention` or `critical`. It is never `null`. |
| `requestRouting` | Whether buyer requests reach the source and why, or `null`: `selectedForRequest`, `setupComplete`, `setupRequirementIds`, `eligible`, `eligibilityReasonCodes`, `compatible`, `compatibilityReasonCodes`, `agentMapping`, `sourceHealth`, `sourceHealthCondition`, `sourceHealthObservationBudgetMs`, `sourceHealthLastSuccessAt` and `agentHealth`. |
| `inventoryHealth`, `reportingHealth` | `healthy`, `degraded` or `unhealthy`, or `null` when nothing has been checked yet. |
| `adServerReadiness` | For an ad-server source, whether read access and booking are confirmed (`adServerType`, `statusAvailable`, `readAccess`, `bookingReadiness`), or `null`. A failed booking check carries the failure `message` and what to correct. |
| `productBuilder` | The source's products, or `null`: `mode` (`composition`, `passthrough` or `null`), `wholesaleProductCount`, `buyerVisibleProductCount` and `catalogCacheCold`. |
| `catalogMappingReadiness` | How far catalog mapping has got, or `null`: `verificationMode`, `progress` (`ready`, `applicable`, `percent`) and a `nextAction`. |
| `detailAction` | Where to open the source, or `null`. It has the same shape as a check's `action`. |

`liveness` is `paused` while setup is incomplete, the source is ineligible or it is not buyer-compatible. Otherwise it is `critical` when the source or its agent is unhealthy, `attention` when the source timed out or either is degraded, and `live`. A source with no `requestRouting` is placed from its `cardPosture` and its inventory and reporting health.

## Diagnoses

`diagnoses` lists what is wrong with the seller's inventory sources. Each entry has a `diagnosisId`,
`sourceName`, `failureMode`, `owner`, `severity`, a one-sentence `summary`, optional `detail` and `docsAnchor`,
and the `action` that fixes it. Only an entry with `owner: "seller"` is something the seller has to do. Its
`severity` is `blocking` when it stops selling, `attention` when it degrades selling, and `advisory` when it
will only matter later.

The list is capped at 10 entries, most severe first (`blocking`, then `attention`, then `advisory`, and in the
order Apostra found them within a severity). A seller with more than 10 problems sees the 10 that matter most.
Read the full per-source list with `get` for `kind: "inventory_source"` and `include: ["diagnostics"]`, or open
the [source diagnostics page](https://docs.apostra.com/v3/seller-source-diagnostics-page.md).

## Deprecated: `phase`

`readiness.phase` on this read, and `phase` on the `get_status` result, are deprecated. Both are still
returned with the same values, and both will be removed on or after 14 December 2026. To tell how far setup
has got, read `goLive.progress` (`required`, `completed`, `nextStepId`) and `goLive.state`, and
`checks` for each step. They say what is done and what is next.

## When a read fails

There is no "unknown" value. If Apostra cannot work out any part of the readiness, the call still succeeds. It
leaves `readiness` out entirely and names it in `unavailableIncludes` with a one-sentence reason, so you never act
on a partial checklist. The one exception is the list of kinds of demand you serve, which is advice rather than
part of the checklist: when it cannot be read, its fields are `null`, as
[Kinds of demand you serve](https://docs.apostra.com/v3/seller-readiness.md#kinds-of-demand-you-serve) explains. The seller and every other include you asked for come back in full. Ask again for
`readiness`. See
[Sellers on the V3 tool surface](https://docs.apostra.com/v3/tool-reference.md).

`operating` comes from the same read. When it fails and you asked for `operating`, it is left out and listed too.

## Related

* [Sellers on the V3 tool surface](https://docs.apostra.com/v3/tool-reference.md) lists every `get` kind and include a seller account reads.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.