> ## 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.

# What is certification?

> What Apostra's certification is: a live-traffic test of a sales agent, use case by use case. What is checked, how an agent earns and keeps it, what it unlocks, what it costs and which agents can be certified.

Certification is how Apostra decides that a sales agent can take buys. Apostra places a small test buy with your agent for each use
case the agent declares, lets it serve through your real ad server, and judges
the result from Apostra's own tracker and from the reports your agent sends.

Certification is per use case. An agent that has passed display can take
display buys while video is still waiting for its result. Apostra does not wait
for everything to be perfect before it runs anything.

## The short answers

* **What is checked.** Whether the buy goes live, whether your agent hands
  back the `context` Apostra sends, whether Apostra's macros are replaced when
  the ad serves, whether clicks and video quartiles arrive, whether your
  reports arrive on time, and whether your numbers agree with Apostra's
  tracker and your ad server. See
  [What each check judges](https://docs.apostra.com/v3/certification.md#what-each-check-judges).
* **How an agent earns it.** You allow certification buys, and Apostra starts a
  run on its own. An agent is certified for a use case when its test buy passes.
  See [How a developer starts](https://docs.apostra.com/v3/certification.md#how-a-developer-starts).
* **How it keeps it.** It stays certified while live traffic for that use case
  keeps passing. Real buys count as evidence, and Apostra runs a synthetic buy
  when none is live. See [How certification is kept](https://docs.apostra.com/v3/certification.md#how-certification-is-kept).
* **What it unlocks.** A passed use case lets publishers in other
  organizations go live on your agent, which is what the agent marketplace
  offers: your agent, used by other organizations.
  See [What a pass unlocks](https://docs.apostra.com/v3/certification.md#what-a-pass-unlocks).
* **What it costs.** Apostra charges no fee to certify your own agent. Test
  buys are capped at USD 10 each and USD 50 per run (converted to your
  currency when you price in another), and they run on your
  sandbox account, which serves through your own ad server. Your sandbox decides
  whether any money moves, and Apostra does not pay for test impressions. See
  [Test buy size](https://docs.apostra.com/v3/certification.md#test-buy-size).
* **Which agents.** Sales agents can be certified today. Creative agents and
  buyer agents cannot be certified yet. Creative agents are tested but stop
  there, and a buyer agent has no certification path yet.
* **The deadline.** Apostra sends new buys to a sales agent only for the use
  cases it has passed, unless Apostra has exempted the agent from
  certification. Apostra has exempted existing sales agents until 1 February
  2027, and the agent's page shows the date. Buys already running are not
  affected. It applies to sales agents because only sales agents can be
  certified. To be ready, turn on **Allow certification buys** on the agent's
  page now. See
  [The certification deadline](https://docs.apostra.com/v3/certification.md#the-certification-deadline).

Not building with Apostra yet? See
[Building on Apostra or on AdCP directly](https://docs.apostra.com/v3/apostra-vs-adcp.md) for what
certification adds on top of the protocol.

> [!NOTE]
>
> Turn on **Allow certification buys** on the agent's page, or send it with
> `save_agent`. Once it is on, Apostra starts certification on its own. If no
> run starts for your agent within a day and the Agent page
> shows no setup step to fix, ask Apostra support. The rest of this page
> describes how certification works once a run starts.

> [!NOTE]
>
> Certification is for sales agents. It is not available for buyer agents or
> creative agents yet, so a buyer agent's status stops at the last stage
> Apostra can prove and says that certification isn't available.

## Which Source certification buys through

Apostra's certification buyer buys through a Source that uses your agent. Two
kinds of Source qualify:

* A Source that is active.
* A Source that is still pending, in your own organization, whose health is
  healthy or degraded. Failing health, or no health reading in the last seven
  days, holds it out until the health recovers. For this, a creative your agent
  refused with `VALIDATION_ERROR`, `INVALID_REQUEST` or `POLICY_VIOLATION` does
  not count against the Source: certification tests your agent's creative
  handling itself, family by family, and a pending Source takes no buyer buys.
  A creative sync that failed any other way, such as a timeout, an
  authentication failure or a server error, still counts.

A certification buy spends nothing. It is capped, and it runs on your sandbox
account (see [Test buy size](https://docs.apostra.com/v3/certification.md#test-buy-size)). So a new agent
does not have to be live before Apostra can test it. The seller whose Storefront
it runs on sees it among their media buys, with a next action that starts
"Certification buy from Apostra, not a buyer's order." It never counts as that
Storefront having gone live. A Source you connect
starts pending. Turn on **Allow certification buys** on the agent's page, and
Apostra certifies through your pending Source. When the agent passes, the
Source goes live under the rules in
[What a pass unlocks](https://docs.apostra.com/v3/certification.md#what-a-pass-unlocks).

Only Apostra's certification buys use a pending Source. A buyer's buy through a
pending Source is refused, and setting the Source to `ACTIVE` yourself is
refused until the agent has passed or Apostra has exempted it. A pending Source
of another organization is not certified through: it keeps the partner
connection path described under
[What a pass unlocks](https://docs.apostra.com/v3/certification.md#what-a-pass-unlocks).

## What a pass unlocks

Once its exemption ends, Apostra sends new buys to a sales agent only for the
use cases it has passed. Buys already running are not affected. See
[The certification deadline](https://docs.apostra.com/v3/certification.md#the-certification-deadline).

One passed use case completes the **Successful transaction** go-live step for
every Source that uses your agent. While Apostra has exempted your agent from
certification, the exemption completes the step the same way, and the step
says the agent is exempt, not certified. That is the step a seller's
Storefront needs before it can go live with a sales agent. A Source whose
agent is not registered with Apostra cannot complete it: the step asks you to
register the agent in your organization's Agents account and connect it to
the Source, because Apostra certifies a registered agent. See
[Connect an agent from its URL](https://docs.apostra.com/v3/connect-an-agent.md#connect-an-agent-from-its-url)
and [Seller readiness](https://docs.apostra.com/v3/seller-readiness.md).

A pass is also what lets a Source go live on your agent. Apostra certifies
through a pending Source in your own organization, so a new agent needs no
exemption to get its Source live.

* A Source in your own organization, or one that was already live before its
  connection to your agent was recorded and has not since been activated
  through the partner connection, goes live and stays live while your agent
  has passed or Apostra has exempted it from certification, and the Source's
  own health is not failing. Degraded health is fine; failing health, or no
  health reading in the last seven days, holds the Source in pending. A Source
  held this way cannot be set live, and Apostra rechecks live Sources about
  once a minute and sets one back to pending when its health starts failing
  or its readings stop. A seller's agent refusing a buyer's creative, for
  example with `CREATIVE_REJECTED`, `FORMAT_NOT_SUPPORTED` or `CREATIVE_SIZE_MISMATCH`,
  does not make the Source's health fail: the agent answered, so the refusal
  shows as degraded, which keeps it visible without taking the Source out of
  service. A creative sync that fails for any
  other reason still does, including a timeout, an authentication failure, a
  server error, or a `VALIDATION_ERROR`, which can mean the whole request was
  invalid rather than one creative refused. The exception is a certification
  run: when your agent refuses one of certification's own test creatives with
  `VALIDATION_ERROR`, `INVALID_REQUEST` or `POLICY_VIOLATION`, the refusal shows
  as degraded, because it is about Apostra's test creative, not your Source.
  The run reports the refusal on that format's result instead. Any other
  failure, including rate limiting, still counts.

* Any other Source of a publisher in another organization goes through the
  partner connection instead. It activates only once your agent has passed or
  Apostra has exempted it from certification, and then goes through
  authorization, validation, health and commercial checks, which keep applying
  while it is live.

* A pass counts for the agent a Source was using when the run happened. It does
  not follow a Source that is later moved to a different agent.

* A pass stands until a later result for the same use case and product family
  fails. Apostra judges a run's use case again every hour while its evidence
  is open, and the latest judgement of that run decides: if it ends
  inconclusive after a pass, for example because a check could not be judged
  on that buy, the pass no longer counts until a run passes again. A newer run
  that is still inconclusive never removes an earlier run's pass.

* A compact lifecycle result never counts toward a pass or a failure of the
  use cases it is shown beside. See [Use cases](https://docs.apostra.com/v3/certification.md#use-cases).
  From 1 February 2027 an agent that has not passed it does not count as
  certified, as the item below says.

* From a capability's date, a pass does not count while the agent lacks it
  (1 February 2027 for all four dated capabilities): its
  [AdCP 4.0 readiness](https://docs.apostra.com/v3/adcp-4-readiness.md) lists it under `datedGaps`. That
  includes an agent that passed earlier, and a capability we have not yet
  proved, such as the compact lifecycle. It counts again once the agent has the
  capability and the Agent page no longer lists it. Nothing changes before the
  date. A connection that is already live stays live.

* A pass does not count while the agent's behaviour baseline shows a current
  **Blocker** on any active Source that uses the agent, on one of the
  [checks that can stop new buys](https://docs.apostra.com/v3/certification.md#behaviour-on-live-traffic).
  A Blocker on any other check shows on the Agent page and leaves the pass
  alone. The pass counts again once the baseline no longer shows a Blocker on
  one of those checks; the baseline is re-evaluated over the last seven days of
  traffic. A connection that is already live stays live.

* Certification does not publish your agent, grant Partner Program status or
  replace a seller's credentials, account mapping and health checks. Those stay
  separate.

* [Partner Program](https://docs.apostra.com/v3/partner-program.md) readiness uses this certification. An organization can
  operate agents for other organizations' clients only when it owns, through a
  claimed provider, at least one active sales agent that has passed here, as
  counted by the rules above, or that Apostra has exempted from certification
  and that has no current Blocker on one of the checks above. Passing does not
  grant the right: registration,
  the commercial agreement and payment standing are separate. If readiness
  says certification is missing, turn on **Allow certification buys** on the
  agent's page and Apostra starts certification automatically. Publishers
  see your agent in their list of partner agents, and can connect to it
  without an invitation, only while your organization holds this right and
  the agent has a published connection setup.

## The certification deadline

Without a certification exemption, Apostra sends new buys to a sales agent only
for the base use cases it has passed. Apostra has exempted the sales agents that
existed on 22 October 2026 until 1 February 2027, so for them the rule starts
when that exemption ends. The date was 1 December 2026 until 15 November 2026,
when Apostra moved it to give sellers more time to complete certification. A
sales agent created after 22 October 2026 has no exemption, so the rule applies
to it from the start. It does not need an exemption to get started: turn on **Allow
certification buys** and Apostra certifies through your pending Source (see
[Which Source certification buys through](https://docs.apostra.com/v3/certification.md#which-source-certification-buys-through)).
To ask for an exemption, contact Apostra support. The agent's page
shows its exemption date, and so does `certificationExemption` on the V3 `get`
read of the agent. See
[See whether Apostra exempted an agent from certification](https://docs.apostra.com/v3/connect-an-agent.md#see-whether-apostra-exempted-an-agent-from-certification).

The rule applies to every sales agent, including one that only your own
organization uses, and to sales agents only. Creative agents and buyer agents
cannot be certified. Once it applies to your agent:

* **It is per base use case.** A pass on one product family of a base use case lets your
  agent take new buys for every product in that use case. A product that falls
  in two use cases, such as one sold as both display and linear TV, needs a pass
  in each. A base use case with no pass takes no new buys. See
  [Use cases](https://docs.apostra.com/v3/certification.md#use-cases).
* **A refused buy never reaches your agent.** A new buy for a product whose base use
  case your agent has not passed is refused with `PRODUCT_UNAVAILABLE`, and the
  buyer is asked to choose a different product. A product Apostra cannot place
  in a certification use case, or one no longer in your catalog, is refused the
  same way.
* **Running buys continue.** Buys already running, and changes to them, are not
  affected.
* **Some buys are not held.** Apostra's own certification buys, which are how
  your agent passes, and sandbox buys, which spend nothing, go through as
  before.
* **A pass can stop counting.** The conditions in
  [What a pass unlocks](https://docs.apostra.com/v3/certification.md#what-a-pass-unlocks) apply here too,
  such as a current **Blocker** on a check that can stop new buys.

Do these now, so a pass is in place well before your exemption ends:

1. Make sure the agent has a Source and a sandbox account that serves. See
   [How a developer starts](https://docs.apostra.com/v3/certification.md#how-a-developer-starts) and
   [A sandbox account that serves](https://docs.apostra.com/v3/certification.md#a-sandbox-account-that-serves).
2. Turn on **Allow certification buys** on the agent's page.
3. Read the result under **Live certification** and fix what a failed or
   inconclusive use case names. A certification buy serves for about three days,
   plus the reports due after it, so start early. See
   [How long it takes](https://docs.apostra.com/v3/certification.md#how-long-it-takes).

## How a developer starts

Every agent lives in your organization's Agents account. See
[Connect an agent in an Agents account](https://docs.apostra.com/v3/connect-an-agent.md).

Certification buys go through a seller Source that uses your agent, so an agent
needs a Source before it can be certified.

* From your Agents account, connect the agent to your organization's test
  storefront: a free storefront Apostra creates for you, never listed, that
  holds only your organization's own agents. See
  [Test and certify your agent](https://docs.apostra.com/v3/connect-an-agent.md#test-and-certify-your-agent).
* If your organization runs its own storefront, you can connect the agent to it
  as a Source instead. See [Connect your own sales agent](https://docs.apostra.com/v3/seller-partner-connection-form.md#connect-your-own-sales-agent).
* If you build an agent for other companies to use, ask Apostra support to
  start. Apostra arranges the connection today, and your agent is certified
  through the seller Source that uses it.

Then allow Apostra to send certification buys. You do not need to
[prove control of the agent's URL](https://docs.apostra.com/v3/connect-an-agent.md#prove-your-agent-is-yours)
first to certify an agent through your own organization's storefront: the agent
is reached only through Apostra there, so nothing is exposed. Proof is needed for
a marketplace listing, Partner standing and use by another organization.

1. Turn on **Allow certification buys**. Use the agent's page, or send
   `certificationRequested: true` with V3 `save_agent`. See
   [Allow certification buys](https://docs.apostra.com/v3/connect-an-agent.md#allow-certification-buys).
   An Operator or Admin of the Agents account that owns the agent can set it,
   signed in as themselves, and only a sales agent can be requested. An
   Operator is enough because a certification buy spends nothing. See
   [Who can do what with an agent](https://docs.apostra.com/v3/connect-an-agent.md#who-can-do-what-with-an-agent). Turn it off, or send
   `certificationRequested: false`, and Apostra sends no new certification
   buys; buys already running continue. With it off, only your real traffic can
   show your agent working. Read
   [The deadline](https://docs.apostra.com/v3/certification.md#the-certification-deadline) for what
   that means once buys depend on a pass.
2. Apostra starts a run on its own, with no one at Apostra acting. It runs on
   each active Source that uses your agent, usually within the hour. It checks the
   agent-wide baseline, then runs a certification buy for each use case the
   agent declares, on each matching product family.
3. Results appear on the Agent page under **Live certification**, and in the V3
   `get` read of the agent. Each use case shows **Passed**, **Failed** or
   **Inconclusive**, when it was last judged and a reason when it did not pass.

## Channels not yet covered

If your storefront sells only channels that certification's standard briefs do
not cover, the agent page names the channels and no certification run starts.
You do not need to change your storefront's channels. Apostra retries
automatically; a run can start when certification covers a channel your
storefront serves and the other certification requirements are met.

## What makes an agent ready

An agent is ready for certification when two things are true. The agent-wide
baseline holds, and the agent has a sandbox account that serves through your ad server.

### The agent-wide baseline

Apostra reads these from your `get_adcp_capabilities` response and the products
your agent returns. They apply to the whole agent, not to one use case.

* **AdCP 3.** `adcp.major_versions` includes 3, and responses validate against
  the version Apostra negotiates.
* **A billing model Apostra supports.** `supported_billing` includes `agent` or
  `operator`, or both.
* **The buying modes it serves.** `media_buy.buying_modes` lists `brief`,
  `wholesale`, or both, with exactly the paths the agent serves. Certification
  tests every path in the agent's product mode. Apostra takes the product mode
  from this declaration. Every Source the agent serves runs each declared
  path. A Source whose agent has no usable declaration has no product mode. See
  [Declare your buying modes](https://docs.apostra.com/v3/agent-requirements.md#declare-your-buying-modes).
* **A way to receive audiences, if it declares audience targeting.** An agent
  that declares `audience_include` or `audience_exclude` in
  `media_buy.execution.targeting` also lists `sync_audiences` or declares
  `media_buy.audience_targeting`, the AdCP declaration for it. This is reported
  only: it stops neither certification nor buying. See
  [Declare how audiences reach you](https://docs.apostra.com/v3/agent-requirements.md#declare-how-audiences-reach-you).
* **A creative kind Apostra supplies.** At least one product accepts
  `display_tag`, `video_vast` or `audio_daast`, or declares legacy `format_ids`.

[Agent requirements](https://docs.apostra.com/v3/agent-requirements.md)
covers the baseline and the seven-day behaviour thresholds in full.
[What we need from reporting](https://docs.apostra.com/v3/what-we-need-from-reporting.md) lists the thirteen
things Apostra asks a seller's reporting to carry. They are judged as report-only
findings: none stops a buy or a certification pass.

### Behaviour on live traffic

Apostra also measures how the agent behaves on its own traffic over the last
seven days, such as whether it answers in time, completes async tasks, and
returns the same account for a repeat `sync_accounts`. Every agent owner sees
this behaviour baseline on the Agent page, under **Agent-wide behaviour**. Each
check shows **Pass**, **Flag** or **Blocker**, with what Apostra saw and how to
fix it. When a check is a **Blocker**, fixing it is the agent's next step, and
the page links the check's section of the requirements page. A missing
declaration from the list above still comes first.

A check can also read **Not read this run**. That means Apostra could not read
the check's evidence in the latest refresh because the read took too long. It
tries again on the next refresh, and you have nothing to do. A check that was
not read is never counted as a pass: an Agent-wide check does not pass while
any Source's read of it is missing, although a flag or Blocker that another
Source showed still stands. A Blocker found earlier stays a Blocker until a
refresh reads the check again, so a slow read never lifts a block on new buys.

The baseline also covers a pending Source of your own organization whose
health is not failing, the Source certification runs through, so you see these
checks while the agent is being certified.

A blocker shows on the Agent page. A blocker on one of these checks, on an
active Source, stops the agent's certification pass counting, and an agent
without a current certification exemption takes no new buys while its pass
does not count. A blocker on a pending Source stops nothing until that Source
is active. Running buys continue. Only these checks can stop new buys:

* [Responsiveness](https://docs.apostra.com/v3/agent-requirements.md#responsiveness-finding)
* [Async completion](https://docs.apostra.com/v3/agent-requirements.md#async-completion-finding)
* [Call success rate](https://docs.apostra.com/v3/agent-requirements.md#call-success-rate-finding)
* [Honours what we send](https://docs.apostra.com/v3/agent-requirements.md#honours-request-finding)
* [Account references resolve to one account](https://docs.apostra.com/v3/agent-requirements.md#account-references-resolve-to-one-account-finding)
* [Lifecycle agreement](https://docs.apostra.com/v3/certification.md#lifecycle-agreement-finding)
* [Changes are announced](https://docs.apostra.com/v3/certification.md#changes-announced-finding), for an agent that declares `account.change_feed`
* [Ended buys are not reported active](https://docs.apostra.com/v3/certification.md#ended-buys-not-active-finding)
* [Stays reachable](https://docs.apostra.com/v3/certification.md#reachability-finding)
* [Delivery reports use the AdCP envelope](https://docs.apostra.com/v3/certification.md#delivery-report-format-finding), from 1 December 2026, for reports refused with `400`

Lifecycle agreement checks that your agent tells one story about each buy:
`get_media_buys` and `get_media_buy_delivery` report the same status, and a buy
never reads `active` while every package that can still serve is paused. It
applies from the day it ships, with no report-only period, and to
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
A disagreement that lasts more than 15 minutes
is a flag, and a second one within seven days is a blocker.

Changes are announced checks that an agent that declares the change feed puts
every lifecycle change on it, within five minutes, under the right account. It
applies from the day it ships, with no report-only period, and to
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
One miss is a flag, and a second one within seven
days is a blocker.

Ended buys are not reported active checks that your agent stops reporting a buy
`active` once the buy's end has passed. It is new from 26 October 2026 and
applies to every agent, including
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
One buy
reported active more than 24 hours after its end is a flag, and a second within
seven days is a blocker. From that day a flag or a blocker shows on the Agent
page, and nothing stops new buys because of it before 1 February 2027: an agent
that existed on 22 October 2026 holds a certification exemption until then, so a
blocker cannot take its new buys, and stopping new buys on blockers is switched
on for no account.

[Rejected buys are not reported active](https://docs.apostra.com/v3/certification.md#rejected-buys-not-active-finding)
is a finding today. It shows as a flag on the Agent page when your agent reports
a buy `active` for more than 15 minutes while every package that can still serve
has had all of its creatives rejected, and it stops nothing. Whether it becomes
required is a later decision, and this page will say so, with the date, before it
changes.

[A buy keeps one status](https://docs.apostra.com/v3/certification.md#status-not-flapping-finding) is a
finding today. It shows as a flag on the Agent page when a buy your agent reports
goes back and forth between the same two statuses, and it stops nothing. Whether
it becomes required is a later decision, and this page will say so, with the date,
before it changes.

[A live buy has a serving ad](https://docs.apostra.com/v3/certification.md#live-buys-serving-finding) is a
finding today. It shows as a flag on the Agent page when your agent reports a buy
`active` inside its flight for more than 15 minutes while no package that can
still serve holds a creative, or while a package is paused, beside one that still
serves, that Apostra never asked it to pause, and it stops nothing. Whether it becomes required is a later
decision, and this page will say so, with the date, before it changes.

[A synced creative shows in creative approvals](https://docs.apostra.com/v3/certification.md#creative-approvals-after-sync-finding)
is a finding today. It shows as a flag on the Agent page when your agent answers a
creative sync for a buy with success and then never lists a creative the sync
carried in `creative_approvals`, on any read made more than an hour later, and it
stops nothing. Whether it becomes required is a later decision, and this page will say
so, with the date, before it changes.

[Creative changes declared](https://docs.apostra.com/v3/certification.md#creative-changes-declared-finding)
is a finding today. It shows as a flag on the Agent page when your agent does not
say which creative changes it takes on a live buy, and it stops nothing: no new
buy is held back and no certification pass stops counting because of it. Whether
it becomes required is a later decision, and this page will say so before it
changes.

[Delivery reports use the AdCP envelope](https://docs.apostra.com/v3/certification.md#delivery-report-format-finding)
shows as a flag on the Agent page when a source sends the AdCP 3.0 bare delivery
report, or sends delivery reports that fail the schema. From 1 December 2026 it
can also be a blocker: two delivery reports from one source refused with `400`
within seven days, both received on or after that date. A 3.0 report Apostra
accepts stays a flag. Before that date it stops nothing. An agent that existed
on 22 October 2026 holds a certification exemption until 1 February 2027, so
until then a blocker cannot take its new buys.

[Package assignments are answered as AdCP allows](https://docs.apostra.com/v3/certification.md#creative-assignments-answered-finding)
is a finding today. It shows as a flag on the Agent page when your agent refuses
package assignments on a creative sync in any way other than a correctable
`UNSUPPORTED_FEATURE` that names `assignments`, and it stops nothing. Whether it
becomes required is a later decision, and this page will say so, with the date,
before it changes.

[Creative assignments on buys are answered as AdCP allows](https://docs.apostra.com/v3/certification.md#creative-assignments-on-buys-answered-finding)
is a finding today. It shows as a flag on the Agent page when your agent refuses
package `creative_assignments` on `create_media_buy` or `update_media_buy` in a
way AdCP does not define, and it stops nothing. Whether it becomes required is a
later decision, and this page will say so, with the date, before it changes.

[Creative approvals use buyer ids](https://docs.apostra.com/v3/certification.md#creative-approvals-use-buyer-ids-finding)
is a finding today. It shows as a flag on the Agent page when your agent lists,
in a package's `creative_approvals` on `get_media_buys`, a `creative_id` that is
not a creative Apostra sent it, and it stops nothing. Whether it becomes required
is a later decision, and this page will say so, with the date, before it changes.

[An identical retry replays its first answer](https://docs.apostra.com/v3/agent-requirements.md#idempotent-retries-replay-finding)
is a finding today. It shows as a flag on the Agent page when your agent answers
`IDEMPOTENCY_CONFLICT` to a request Apostra sends again, unchanged and under the
same `idempotency_key`, after it answered the first send, and it stops nothing.
Whether it becomes required is a later decision, and this page will say so, with
the date, before it changes.

[Creative errors carry a recovery](https://docs.apostra.com/v3/agent-requirements.md#creative-error-recovery-finding)
is a finding today. It shows as a flag on the Agent page when an error in your
agent's answer to a creative sync carries a `recovery` that is not `transient`,
`correctable` or `terminal`, or, in an answer served as AdCP 3.2 or later, carries
none, and it stops nothing. Whether it becomes required is a later decision, and
this page will say so, with the date, before it changes.

[Creative review verdicts can be read](https://docs.apostra.com/v3/agent-requirements.md#creative-review-verdict-finding)
is a finding today. It shows as a flag on the Agent page when your agent takes a
creative into review without a task and its verdict never reaches Apostra before
the delivery's deadline, through a callback or `list_creatives`, and it stops
nothing. Whether it becomes required is a later decision, and this page will say
so, with the date, before it changes.

[Delivery names only booked packages](https://docs.apostra.com/v3/agent-requirements.md#delivery-names-only-booked-packages-finding)
is a finding today. It shows as a flag on the Agent page when a delivery report
from your agent, for a buy that has delivered, names a package the buy never
booked, and it stops nothing. A buy that has delivered nothing yet is not judged.
Whether it becomes required is a later decision, and this page will say so, with
the date, before it changes.

[Discovery brief accepted](https://docs.apostra.com/v3/agent-requirements.md#discovery-brief-accepted-finding)
is a finding today. It shows as a flag on the Agent page when your agent refuses a
`get_products` brief that passes the AdCP request schema, again and again, with
`INVALID_REQUEST` or `VALIDATION_ERROR`, and answers none, and it stops nothing.
AdCP gives a seller that needs more from a brief the `input-required` task status,
and one that declines it the `rejected` outcome. Whether it becomes required is a
later decision, and this page will say so, with the date, before it changes.

[Delivery by creative is its own and adds up](https://docs.apostra.com/v3/agent-requirements.md#delivery-by-creative-finding)
is a finding today. It shows as a flag on the Agent page when a delivery report
from your agent carries `by_creative` rows that are equal shares of the package
total, or that do not add up to the package's impressions or spend, and it
stops nothing. A report with no creative rows is not judged. Whether it becomes
required is a later decision, and this page will say so, with the date, before it
changes. It is requirement `WNR-2`, `WNR-3` and `WNR-4` on
[What we need from reporting](https://docs.apostra.com/v3/what-we-need-from-reporting.md).

Stays reachable checks that your agent keeps answering the calls Apostra makes
to it. It is new from 29 October 2026 and applies to every agent, including
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
A stretch of more than 15 minutes in which
Apostra called your agent and got no response is a flag, and a second stretch
within seven days, or one that lasts six hours, is a blocker. From that day a
flag or a blocker shows on the Agent page, and nothing stops new buys because of
it before 1 February 2027: an agent that existed on 22 October 2026 holds a
certification exemption until then, so a blocker cannot take its new buys, and
stopping new buys on blockers is switched on for no account. An agent whose
deploys or restarts leave it unanswering for a few minutes is not affected.

[Payment terms](https://docs.apostra.com/v3/agent-requirements.md#payment-terms-finding),
[account sync is idempotent](https://docs.apostra.com/v3/agent-requirements.md#account-sync-is-idempotent-finding) and
[declarations match behaviour](https://docs.apostra.com/v3/agent-requirements.md#declarations-match-behaviour-finding) show a
flag or a blocker but do not stop buys. This page will say so before that
changes. [Valid responses](https://docs.apostra.com/v3/agent-requirements.md#valid-responses-finding) shows a
flag when Apostra refuses a reply your agent sent as not valid AdCP, and it never
stops a buy. [Machine-readable errors](https://docs.apostra.com/v3/agent-requirements.md#machine-readable-errors-finding) is a
best practice and never stops a buy.

See [What a pass unlocks](https://docs.apostra.com/v3/certification.md#what-a-pass-unlocks) for how a
Blocker affects the pass.

#### The embedded sales agent Apostra runs

The embedded sales agent Apostra runs for sellers is judged by the same checks as
your agent, over the same seven days of live traffic and with the same
thresholds. Each ad server it runs (Google Ad Manager, FreeWheel, SpringServe,
AdsWizz and Broadsign) is its own Agent, so a finding on one ad server never
marks another down. A source the embedded sales agent serves counts towards the
Agent for its ad server, and that Agent's page shows its findings to Apostra's
team.

Apostra never places a certification buy on a seller's own ad server through the
embedded sales agent. Its certification evidence comes from live traffic only.

A blocker on the embedded sales agent does not stop new buys or a certification
pass yet. This page will say so, with the date, before that changes.

### Lifecycle agreement finding

**Threshold.** For each Source, over seven days, Apostra checks two things each
time it reads a buy:

* **The two status answers agree.** `get_media_buys` and `get_media_buy_delivery`
  report the same `status`. Apostra sets each delivery answer against the
  `get_media_buys` answer it read within five minutes of it.
* **The buy agrees with its packages.** A buy that reads `active` while every
  package that can still serve is paused is a disagreement. A package can still
  serve when it is not paused and not finished. It is finished when `canceled` is
  true or its `end_time` has passed. When every package is paused or finished and
  at least one is paused, AdCP reads the buy as `paused`.

A disagreement counts once it has lasted more than 15 minutes: Apostra read it
twice, more than 15 minutes apart, with no agreeing read between. One that clears
within 15 minutes counts for nothing, so your agent has that long to reflect a
change. One disagreement is a **flag**. Two within the seven days are a
**blocker**, and two buys that disagree count as two. When Apostra has no pair of
reads to compare and no `get_media_buys` answer that carries its packages, the
check is not evaluated. Each of the two parts is judged on its own: a
`get_media_buys` answer without packages still has its status set against the
delivery answer, and only the package part is skipped.

The check applies from the day it ships, with no report-only period, and to
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
A blocker stops the agent's
certification pass counting, as for the other checks that can stop new buys,
and running buys continue.

**Usual causes.**

* The agent updates its own record of a buy only when it makes a change itself, so
  a change made directly in the ad server never reaches `get_media_buys`.
* A pause reaches the packages that can still serve, but the agent reports the
  whole pause as failed because a finished package refused it. The ad server is
  changed, the agent's record is not, and the buy keeps reading `active`.
* `get_media_buy_delivery` derives its status from flight dates, while
  `get_media_buys` reads the agent's record.

**Next step.** Answer both reads from one record, and bring that record in line
with your ad server within 15 minutes of any change, including one made directly
there. Treat a package whose flight has ended as finished: it is never a reason a
pause fails. Report the buy `paused` once every package that can still serve is
paused. The finding clears as the seven-day window moves on.

### Changes announced finding

**Applies when** your agent declares `account.change_feed` in
`get_adcp_capabilities`. An agent that does not declare it is read by polling and
is not judged here.

**Threshold.** For each Source, over seven days, Apostra counts two kinds of miss:

* **A change the feed did not announce.** Apostra's scheduled read of a buy found
  its lifecycle status changed, and your `list_account_changes` feed carried no
  record, on the feed for the account the buy is in, naming that buy (a media buy,
  one of its packages, one of its creative assignments, or a creative record that names the buy as its parent) recorded between the earlier read and five minutes after the read
  that found the change, and that Apostra received within 15 minutes after that.
  Apostra reads every feed at least every 15 minutes, so a record your feed
  exposes later than that does not count, whatever time it carries. A record
  whose account does not resolve never counts as the announcement; it is counted once, as the record below, and the change it names is not counted a second time. A record announces one
  change, so two changes need two records. A change
  Apostra read because the feed announced it is announced by definition. Apostra
  judges a change only once that account's feed has been read successfully after
  that window, so a feed it could not read is never counted as a missing record. Apostra
  judges only changes whose earlier read came after it began keeping your feed's
  records, so a change from before the check shipped is never counted against you.
* **A record that does not resolve to an account.** A record names an account
  other than the one the feed was read for. Each record counts once, by its
  `change_id`, however often it is read again, and it stops counting once your
  agent returns it under the right `account_id`.

One miss is a **flag**. Two within the seven days are a **blocker**. When the feed
has shown Apostra nothing to check, the check is not evaluated. It applies from
the day it ships, with no report-only period, and to
[the embedded sales agent Apostra runs](https://docs.apostra.com/v3/certification.md#the-embedded-sales-agent-apostra-runs).
A blocker stops the agent's certification pass counting, as for
the other checks that can stop new buys, and running buys continue.

**What Apostra keeps.** For each record your feed announces, Apostra keeps the
`change_id`, the time your agent gave, the buy the record names, the action, the
resource type and whether the record's account resolves. It keeps no other seller
text. A record is kept for 14 days after Apostra received it. A cleanup that
runs every 15 minutes then deletes it, removing up to 100,000 records a run, so a
very large backlog can take longer. A record is deleted sooner when the Source or
its feed is removed. One exception: a record that does not resolve to an
account is kept past 14 days until your feed has been read again without it, or
your agent returns it under the right `account_id`. A feed that is still
registered but never answers again keeps those records until the feed is removed.

**Usual causes.**

* The agent records a change in its own store without writing it to the feed, so
  a change made directly in the ad server never reaches the feed.
* The feed returns records under a placeholder account id such as `default`
  instead of the `account_id` the feed is read for. Apostra then cannot use the
  page at all.
* Package changes are written to the feed with no `parent_ids.media_buy_id`, so
  they do not name the buy they belong to.

**Next step.** Write every change to a buy or a package, whoever made it, to the
`account.change_recorded` feed within five minutes of recording it, with
`resource.account_id` set to the account the feed is read for and, for a package,
`parent_ids.media_buy_id`. If your agent cannot, stop declaring
`account.change_feed`; Apostra then reads your buys by polling. The finding clears
as the seven-day window moves on.

### Ended buys not active finding

**Applies when** Apostra read a buy from your agent more than 24 hours after the
buy's end. A Source with no such read is not judged.

**Threshold.** For each Source, over seven days, Apostra counts each buy it read
as `active` through `get_media_buys` more than 24 hours after the buy's end. The
end is the `end_time` your agent sent for the buy on that read, read as the
moment it names, so an offset such as `+02:00` is fine. When your agent sent none,
it is the end Apostra booked for the buy. When it sent one Apostra cannot read as
an RFC 3339 timestamp, Apostra does not judge that read. A buy that your agent reports `paused`, `completed`, `canceled` or in
any other status is not counted, so only a buy reported running after its end has
passed is a miss. A buy counts once, however often Apostra reads it, and it stays
in the window until it is seven days old.

One buy is a **flag**. Two within the seven days are a **blocker**. Apostra
does not complete a buy because its end date has passed: your agent owns the buy's
state, so a buy it still reports `active` stays active in Apostra's records, and
this check is how the disagreement reaches you.

**Usual causes.**

* The agent keeps reporting the status it held in its own store, and does not
  follow its ad server once the flight has ended.
* The agent reports the end Apostra booked, but the buy was extended or moved in
  the ad server, so the real end is later. Report the end it actually runs to.
* The agent reports `active` for a buy its ad server finished or removed.

**Next step.** When a buy's end passes, report it `completed` (or `canceled`) in
`get_media_buys`. If a buy runs past the end Apostra booked, report the later
`end_time` it runs to; Apostra judges a buy against the end your agent reports.
The finding clears as the seven-day window moves on.

### Rejected buys not active finding

**Applies when** Apostra read a buy from your agent through `get_media_buys`, and
a package in the answer listed the review state of its creatives in
`creative_approvals`. A Source whose packages list no creative approvals is not
judged.

**Threshold.** For each Source, over seven days, Apostra counts each buy that
reads `active` while every package that can still serve has all of its creatives
rejected. A package can still serve when it is not finished: it is finished when
`canceled` is true or its `end_time` has passed. A package has all of its
creatives rejected when `creative_approvals` lists at least one creative and
every entry has `approval_status` of `rejected`. A package that holds any
creative that is approved, partly approved or still in review is not wholly
rejected, so a buy with one such package is not counted. No package of such a buy
can deliver, and AdCP does not let it read `active`: it reads `pending_creatives`
while the buyer can replace the rejected creatives, or `rejected` when your agent
declines the buy.

A contradiction counts once it has lasted more than 15 minutes: Apostra read it
twice, more than 15 minutes apart, with no agreeing read between. One that clears
within 15 minutes counts for nothing, so your agent has that long to reflect a
review outcome. A buy counts once however often Apostra reads it. One buy is a
**flag**. The check is report-only today: it never becomes a blocker, it does not
stop certification, and it does not stop new buys. Whether it becomes required is
a later decision, and this page will say so, with the date, before it changes.

**Usual causes.**

* The agent reports the buy status it held when the buyer created the buy, and
  does not move it when the ad platform later rejects the ad set, ad group or
  creatives.
* The agent reads a package's own review outcome from the ad platform, but never
  carries it into the buy's status.
* The agent reports the buy's status from its flight dates, not from whether any
  package can deliver.

**Next step.** When your ad platform rejects what a package needs to deliver,
report the rejection on the package in `creative_approvals`, with
`approval_status` `rejected` and a `rejection_reason`, in AdCP's shape. Report a
media buy status that reflects it within 15 minutes: `pending_creatives` while the
buyer can replace the creatives, or `rejected` when your agent declines the buy.
Validate the answer with the pinned AdCP SDK schema. The finding clears as the
seven-day window moves on.

### Reconciliation not stuck finding

**Applies when** Apostra flagged one of your buys for reconciliation because it
could not confirm whether a targeting, budget/bid price, name, or flight-date
change you were sent actually applied -- a transient sync failure, for example.
A Source with no such flagged buy is not judged.

**Threshold.** For each Source, over seven days, Apostra counts each buy that
carries the flag. A buy counts as a miss once the flag has stood for more than
24 hours without being confirmed or refused. One buy is a **flag**. The check
is report-only today: it never becomes a blocker, it does not stop
certification, and it does not stop new buys. Whether it becomes required is a
later decision, and this page will say so, with the date, before it changes.

**Usual causes.**

* The agent's next status read repeats the value it held before the change,
  instead of the value the change actually produced.
* The agent's read answers with an ambiguous or missing value for the changed
  field, so Apostra cannot tell whether the change applied.
* A transient failure on the agent's side during the change leaves it unable to
  say, on its next read, whether the change took effect.

**Next step.** When you cannot confirm whether a change applied, make sure your
next `get_media_buys`/`get_media_buy_delivery` read answers with a clear,
consistent value for the changed field, so Apostra is not left guessing.
Nothing automatically re-checks a flagged buy today, so the finding itself
stays until the buy is canceled or Apostra ships the automated re-verification
this finding is meant to motivate; a clear answer is exactly what that
re-verification will act on once it exists.

### Status not flapping finding

**Applies when** your agent reported a change to the status of a buy Apostra
placed with it, through a status read (`get_media_buys`) or a webhook. A Source
whose buys had no such change in the last seven days is not judged.

**Threshold.** For each Source, over seven days, Apostra counts each buy whose
status your agent changed back and forth between the same two statuses three
times in a row, each change within two hours of the last. A change reverses the
one before it when it puts the buy back to the status it had just left, so the
status goes `active`, `pending_start`, `active`, `pending_start`, `active`. A
status the buyer asked for, such as a pause, is never counted, and a buy your
agent pauses and resumes once is not counted. A buy counts once however often it
flaps. One buy is a **flag**. The check is report-only today: it never becomes a
blocker, it does not stop certification, and it does not stop new buys. Whether
it becomes required is a later decision, and this page will say so, with the
date, before it changes.

**Usual causes.**

* `get_media_buys` and `get_media_buy_delivery` name different statuses for the
  same buy. The most common case is a buy booked and enabled before its flight
  starts: the status read says `pending_start` and the delivery read says
  `active`, so each read undoes the other. This is the case that first showed the
  problem, on an OpenAI Ads buy that changed state more than 20 times in eight
  hours.
* A status derived from one field, such as the platform's enabled flag, in one
  read and from the flight dates in another.
* A webhook and a status read that describe the buy at different moments.

**Next step.** Report one status for a buy at any moment, in every read. Before a
buy's `start_time`, report `pending_start` in `get_media_buys`, in
`get_media_buy_delivery` and in every webhook, even when the buy is enabled at
your platform, and move to `active` when the flight starts. See
[Report pending start until the flight starts](https://docs.apostra.com/v3/agent-requirements.md#report-pending-start-until-the-flight-starts).
The finding clears as the seven-day window moves on.

### Live buys serving finding

**Applies when** your agent reports a buy Apostra placed with it `active` in
`get_media_buys`, with the buy's packages listed, once the buy's flight has run
for an hour. The flight is the `start_time` and `end_time` your agent reports for
the buy, or the ones Apostra booked when it reports none. A Source with no such
read in the last seven days is not judged.

**Threshold.** For each Source, over seven days, Apostra counts each buy that
reads `active` inside its flight for more than 15 minutes, in consecutive reads
with no agreeing read between them, while either of these holds:

* **No ad.** At least one package can still serve (it is not paused, canceled
  or ended), every such package lists the creatives it holds in
  `creative_approvals`, and none of them holds a creative, whether approved,
  pending or rejected.
* **Paused with no pause request.** A package that is not finished is paused
  while another package of the buy can still serve, and Apostra never asked your
  agent to pause the buy or that package. A pause the buyer asked for is never
  counted, and a request to pause one package does not excuse the pause of
  another.

A buy with every package paused is judged by the
[lifecycle agreement](https://docs.apostra.com/v3/certification.md#lifecycle-agreement-finding) check, and a
buy with every creative rejected by
[rejected buys not active](https://docs.apostra.com/v3/certification.md#rejected-buys-not-active-finding), so
neither counts here. A seller that leaves `creative_approvals` off a package that
can still serve is not judged for the first condition.

A buy counts once however often it contradicts. One buy is a **flag**. The check
is report-only today: it never becomes a blocker, it does not stop certification,
and it does not stop new buys. Whether it becomes required is a later decision,
and this page will say so, with the date, before it changes.

**Usual causes.**

* An ad platform creates a campaign, an ad group or an ad paused, and nothing
  switches it on once the creative is in. This is the case that first showed the
  problem, on an OpenAI Ads buy whose only ad group stayed paused for ten hours
  while the buy read `active`. With every package paused the lifecycle agreement
  finding catches it, and with one of several paused this one does.
* A buy reported `active` from the platform's campaign status alone, without
  looking at whether the buy holds an ad.
* A creative that never reached the platform, or was removed, while the package
  still reads as live.

**Next step.** Report a buy `active` only when it can serve. List the creatives
each package holds in `creative_approvals` on `get_media_buys`. When none of the
packages that can still serve holds one, report `pending_creatives`, as AdCP has a
buy without creatives read. Report a package as `paused` only when Apostra asked
you to pause it, and switch on a package your platform created paused once its
creative is live. The finding clears as the seven-day window moves on.

### Creative approvals after sync finding

`creative_approvals` on `get_media_buys` is how your agent tells Apostra what
review each creative on a buy has reached. When your agent takes a creative for a
buy and never lists it there, the buyer cannot see whether the creative was
approved or rejected: it stays unreviewed, and a rejection never arrives. Apostra
matches each creative by the `creative_id` it sent on `sync_creatives`, so a buy
that lists one creative does not excuse another that your agent accepted and
left out.

**Applies when** Apostra sent your agent a `sync_creatives` request for a buy it
placed with it, that carried at least one creative, your agent answered with
success, and an hour has passed since that answer. It also needs your agent to
list `creative_approvals` on at least one package of the buy that can still serve
(not paused, canceled or ended), on a read that keeps the buy's packages. A
Source with no such buy in the last seven days is not judged, and neither is a
seller that leaves `creative_approvals` off those packages: an omitted list says
nothing about what the package holds.

**Threshold.** For each Source, over seven days, Apostra counts each such buy
where a creative the sync carried is named by `creative_id` in no package's
`creative_approvals`, whether approved, pending or rejected, on any read made more
than an hour after your agent answered the sync, over more than 15 minutes between
the first read and the last. The creative on any later read stops it counting. A
buy counts once however many of its creatives or reads miss. One buy is a
**flag**. The check is report-only today: it never becomes a blocker, it does not
stop certification, and it does not stop new buys. Whether it becomes required is
a later decision, and this page will say so, with the date, before it changes.

This is different from the
[package assignments check](https://docs.apostra.com/v3/certification.md#creative-assignments-answered-finding),
which asks whether each creative a sync assigned to a package appears there. This
check asks it of the whole buy and does not need the sync to carry `assignments`.

**Usual causes.**

* The review status is read from one place when the buy is created and from
  another when it is polled, so the poll finds no record of the creative. This is
  the case that first showed the problem, on an OpenAI Ads buy whose ad was live
  and whose `creative_approvals` stayed empty for days.
* A creative that your platform holds under its own id, and that your agent
  cannot map back to the `creative_id` Apostra sent.
* `creative_approvals` filled in only for a package your platform created from
  the creative, and left empty when the creative is on the buy another way.

**Next step.** List each creative your agent holds for the buy in
`creative_approvals` on its package, under the `creative_id` Apostra sent on
`sync_creatives`, with the review status it holds: `pending_review` while it is
being reviewed, then `approved` or `rejected`. The finding clears as the
seven-day window moves on.

### Creative changes declared finding

Apostra checks what your agent declares in `available_actions` (or the older
`valid_actions`) before it changes a live buy, and refuses a change your agent
does not take. Adding a creative to a package, taking one off and swapping one in
place on a live buy (`update_creative_assignments`, `remove_creative` and
`replace_creative`) are the exception today: when your agent declares no action
list at all, Apostra lets the change through to it, because many sales agents do
not declare yet. This check reports that gap so you can close it.

**Applies when** Apostra read a live buy (`active` or `paused`) from your agent
through `get_media_buys` in the last seven days. A Source with no such read is
not judged.

**Threshold.** For each Source, over seven days, Apostra takes the latest read of
each live buy and checks whether your agent sent an action list on it, either
`available_actions` or a non-empty `valid_actions`. A buy read with no action list
is a miss. A buy counts once, however often Apostra reads it. An agent that sends
a list is not judged on what is in it: leaving a creative action out of a list
that is present is a valid way to say the agent does not take that change.

While this is a finding, one or more misses show as a **flag** on the Agent page.
It is never a blocker today, so it stops nothing: no buy is held back, no
certification pass stops counting, and no action is needed to keep selling.
Whether a missing declaration becomes required is a later decision, which the
changelog and this page will announce before it takes effect.

The check also shows, for the buys that did declare a list, how many take each of
the three creative changes, in any mode (`self_serve`, `conditional_self_serve`,
`requires_approval` or `seller_managed`).

**Usual causes.**

* The agent declares `available_actions` on some responses and not on
  `get_media_buys`, which is where Apostra reads it.
* The agent sends no action list at all, because it predates AdCP 3.
* The agent sends a list, but the creative actions are missing from it. That is
  not a miss for this check: it tells Apostra the agent does not take the change.

**Next step.** Declare the live creative changes you take in `available_actions`
on every media-buy response (`get_media_buys`, `create_media_buy` and
`update_media_buy`): `update_creative_assignments` to add a creative to a package,
`remove_creative` to take one off and `replace_creative` to swap one in place,
each with its mode. A product that should not take a live creative change leaves
that action out of a list that is present: an absent action means not supported,
an absent list means you have not said. Declaring support is what lets a buyer
change creatives on a live buy from Apostra's tools, so it is the outcome to
aim for. The finding clears as the seven-day window moves on. Certification also
tries the changes you declare, and the ones you leave out, on a live test buy: see
[Live creative changes](https://docs.apostra.com/v3/certification.md#live-creative-changes-finding).

### Delivery report format finding

A source that pushes delivery reports sends each one to Apostra's delivery
webhook as a `media_buy_delivery` callback. Apostra records every callback it
receives from an authenticated sender, and this check reads those records. Each
refused report is also in the agent's [webhook results](https://docs.apostra.com/v3/agent-webhook-deliveries.md#delivery-reports),
with the first failing field.

**Applies when** a source sent a delivery report to Apostra in the last seven
days. A source that sent none is not judged, for example because Apostra reads
its delivery by polling.

**Threshold.** For each Source, over seven days, Apostra counts the delivery
reports it answered `200` or `400`:

* A report refused with `400` is a miss. The message and the webhook results name
  the first failing field, whichever field failed.
* A report in the AdCP 3.0 shape, with `media_buy_deliveries` at the top level
  and no envelope, is a miss even though Apostra accepts it. From AdCP 3.1 the
  report is the `result` of an MCP webhook envelope.
* A report sent as a valid AdCP 3.1+ envelope is not a miss.

A report refused with `413` (more than 250 media buys) or `503` (Apostra could
not record it) says nothing about the format and is not counted.

One or more misses show as a **flag** on the Agent page. From 1 December 2026,
two reports refused with `400` that Apostra received on or after that date,
within seven days, make the Source a **blocker**, which stops the agent's
certification pass counting until the window moves past them (see
[Behaviour on live traffic](https://docs.apostra.com/v3/certification.md#behaviour-on-live-traffic) for
what that stops). Retries count, because each one is refused. A report in the
AdCP 3.0 shape that Apostra accepts stays a flag however many arrive. Before
1 December 2026 the finding is never a blocker and stops nothing. The finding
shows the counts, the first failing field, and `refusedRetries`. For a Source the
field is the one most refused reports failed on first. For the whole agent it is
the field of the Source with the most misses.

**Retried refusals.** AdCP says a sender does not retry a refused report, because
the same body gets the same answer. `refusedRetries` counts the refused reports
that repeat an earlier refusal from the same source, with the same first failing
field and the same media buys, within 15 minutes. A source that keeps sending the
same refused report shows a high count, which is a second problem to fix besides
the report itself.

**Usual causes.**

* The envelope leaves out a field AdCP requires, such as `operation_id`, or a
  delivery row leaves out `by_package`. Extra fields never stand in for a
  required one.
* The agent still sends the AdCP 3.0 body, with no envelope.
* The agent retries a `400` in a loop, instead of fixing the report.

**Next step.** Send every delivery report as an AdCP 3.1+ envelope with
`task_type: "media_buy_delivery"` and the report under `result`, fix the field the
finding names, and send the corrected report rather than retrying the refused
one. The finding clears as the seven-day window moves on. See
[Deliver reporting to Apostra](https://docs.apostra.com/v3/seller-reporting-delivery.md#send-the-adcp-envelope)
for the full shape of a report.

### Creative assignments answered finding

When Apostra sends a campaign's creatives to a media buy it can ask your agent to
assign them to packages in the same `sync_creatives` call, by sending
`assignments`. AdCP lets a seller refuse that, and have the buyer assign through
`update_media_buy` instead, but only when the refusal says so in a form a buyer
can act on. This check reads how your agent answers.

**Applies when** Apostra sent your agent a `sync_creatives` request that carried a
non-empty `assignments` list and your agent answered it, in the last seven days. A
source that was sent none is not judged.

**Threshold.** For each Source, over seven days, Apostra counts the answered
requests that carried `assignments`:

* A request your agent accepted is not a miss.
* A request refused with an error whose code is `UNSUPPORTED_FEATURE`, whose
  field is `assignments` and whose recovery is `correctable` is not a miss. That
  is the answer AdCP allows. Apostra sends the creatives again without the
  assignments and assigns them through `update_media_buy`.
* A request refused with an error that names the field `assignments` any other
  way is a miss: another code, or a recovery that is not `correctable`.

A failed sync whose error does not name `assignments` says nothing about this
check and is not counted. Apostra compares the error's code, field and recovery as
your agent sent them, and does not read or store its message.

While this is a finding, one or more misses show as a **flag** on the Agent page.
It is never a blocker today, so it stops nothing: no buy is held back and no
certification pass stops counting. The finding shows the counts of requests
checked, accepted, refused as AdCP allows, and refused any other way.

A seller that accepts the request and silently drops the assignments is a
different problem, judged by its own finding: **Package assignments are kept on
the buy**, described below.

**Usual causes.**

* The agent refuses `assignments` with `INVALID_REQUEST` or another code instead
  of `UNSUPPORTED_FEATURE`.
* The agent refuses with `UNSUPPORTED_FEATURE` but names no field, or marks the
  refusal `terminal`, so a buyer cannot tell it can assign another way.

**Next step.** Take package assignments on `sync_creatives`, or refuse them with
`UNSUPPORTED_FEATURE`, recovery `correctable`, and the field `assignments`, with a
suggestion that the buyer assign through `update_media_buy`
`packages[].creative_assignments`. The finding clears as the seven-day window
moves on. See
[Answer package assignments on a creative sync](https://docs.apostra.com/v3/agent-requirements.md#answer-package-assignments-on-a-creative-sync).

#### Package assignments are kept on the buy

A seller can accept a `sync_creatives` request that carries `assignments` and
ignore the field, leaving each creative unassigned with no error. Only a read of
the buy shows that, so this finding pairs two records of the same Source.

**Applies when** Apostra sent your agent a `sync_creatives` request with a
non-empty `assignments` list, your agent accepted it, and Apostra then read the
buy back with `get_media_buys` at least 30 minutes after the answer. The first
such read is the one judged, so an agent that assigns after answering has half an
hour to do so.

**Threshold.** For each Source, over seven days, Apostra counts the accepted
requests it could read back. A request is read back when that read lists
packages. It is a **miss** when a creative the request assigned to a package is
not held there: the read does not list that package at all, or it lists the
package and the package says which creatives it holds in `creative_approvals`
and the creative is not among them.

Only intact evidence counts. A request whose stored copy was cut at the ledger's
size limit is not judged. A read that did not keep your packages (more than 50,
or over the size limit) is not judged, and neither is a read that lists no
packages. A listed package that does not list its creatives is not judged,
because an agent that does not report them has not said it dropped them.

While this is a finding, one or more misses show as a **flag** on the Agent page.
It is never a blocker today, so it stops nothing. The finding shows how many
requests were read back and how many missed. Apostra compares creative and
package ids only, and does not read or store your agent's text.

**Usual causes.**

* The agent accepts `assignments` on `sync_creatives` and ignores them.
* The agent assigns the creatives later than the 30 minute grace.
* The agent holds the assignments but does not list them in `creative_approvals`
  on `get_media_buys`.

**Next step.** When you accept a request that carries `assignments`, put each
creative in its package, and list the creatives a package holds in
`creative_approvals`. If you do not take assignments on this call, refuse them
with `UNSUPPORTED_FEATURE`, recovery `correctable`, and the field `assignments`
instead of accepting and ignoring them. The finding clears as the seven-day
window moves on.

### Creative approvals use buyer ids finding

`get_media_buys` can list, on each package, the review state of the creatives it
holds, in `creative_approvals`. AdCP names the creative in each item by
`creative_id`, and that is the buyer's id: the `creative_id` on the buyer's
`sync_creatives` request or in its `creative_assignments`. Your agent's own id
for the creative is `platform_id` on the `sync_creatives` answer, and a buyer
never sends it back. A package that lists your own id in `creative_approvals`
reports a review result the buyer cannot match to any creative it holds, so an
approval or a rejection never reaches the buyer's creative. This check reads
both sides of the exchange: the creative ids Apostra sent your agent, and the ids
your agent lists back.

It is the reverse of
[Package assignments are kept on the buy](https://docs.apostra.com/v3/certification.md#creative-assignments-answered-finding),
which asks whether a creative Apostra assigned shows up in `creative_approvals`.
This one asks whether an id in `creative_approvals` is one Apostra sent.

**Applies when** Apostra placed a buy with your agent in the last 60 days, and
read it back with `get_media_buys` in the last seven days, and the buy's packages
list `creative_approvals`. A Source with no such buy is not judged.

**Threshold.** For each Source, over seven days, Apostra judges each buy on its
latest read that kept its packages. A buy is a **miss** when a `creative_id`
that its packages list in `creative_approvals` is not a creative Apostra sent
your agent. Apostra counts a creative as sent when it appears in:

* a `sync_creatives` request, in `creatives` or in `assignments`; or
* a `create_media_buy` or `update_media_buy` request, in the `creative_assignments`
  or the inline `creatives` of a package in `packages` or `new_packages`.

A request counts however your agent answered it, because your agent received the
id. A buy counts once, however many approvals or reads disagree. Only the latest
read is judged, so an agent that fixes its ids stops being counted as soon as
Apostra next reads the buy.

Only intact evidence is judged. These do not count:

* A read that did not keep your packages (more than 50, or over the size limit),
  a read that lists no packages, and a package that lists no
  `creative_approvals`. An approval with no `creative_id` is not judged either.
* A buy older than 60 days, and a buy Apostra did not place, such as a buy found
  on your side. Apostra keeps the body of what it sent for 90 days, so an older
  buy may carry a creative sent before that, and a buy Apostra did not place may
  carry creatives it never sent.
* Any buy of a buyer whose requests to your agent include one whose stored copy
  was cut at the ledger's size limit, or has aged out, because that request may
  have carried the creative.

Apostra matches creative ids for the buyer and your Source, and does not tie an
approval to the account a creative was sent under, so a creative sent under
another account of the same buyer counts as sent. Apostra compares ids only, and
does not read or store your agent's text.

While this is a finding, one or more misses show as a **flag** on the Agent
page. It is never a blocker today, so it stops nothing: no buy is held back and
no certification pass stops counting. The finding shows how many buys were judged
and how many missed.

**Usual causes.**

* The agent lists its own id for the creative, the one its ad server or creative
  library assigned, in `creative_approvals` instead of the buyer's `creative_id`.
* The agent lists an id it builds from the buyer's, for example with a prefix, a
  suffix or a different case.

**Next step.** In `creative_approvals`, set `creative_id` to the id the buyer
sent. Keep your own id in `platform_id` on the `sync_creatives` answer, or in
`ext` on the approval. The finding clears as soon as Apostra reads the buy and
its latest read lists the buyer's ids. See
[Return the buyer creative id in creative approvals](https://docs.apostra.com/v3/agent-requirements.md#return-the-buyer-creative-id-in-creative-approvals).

### Creative assignments on buys answered finding

A buyer can say which of its creatives run on each package of a buy. Apostra
sends that as AdCP's package `creative_assignments` on `create_media_buy` and
`update_media_buy`, one whole list per package, on `packages` or on the packages
an update adds in `new_packages`. Each item names a `creative_id`,
and may also carry `weight`, `rotation_mode`, `group_id`, `sequence_position`,
`placement_refs`, `placement_ids`, `landing_page_url` and `trackers`. AdCP says
how a seller refuses an item it cannot take, so that the buyer knows what to
change. This check reads how your agent answers.

**Applies when** Apostra sent your agent a `create_media_buy` or
`update_media_buy` whose packages, on `packages` or `new_packages`, carried a
non-empty `creative_assignments` list, and your agent answered it, in the last
seven days. A Source that was sent
none is not judged.

An `update_media_buy` is judged against the newest action list your agent
returned for the buy on `get_media_buys` at or before the update. It is not
judged when that list does not take `update_creative_assignments` (a coarse
`sync_creatives` action covers it): your agent had said it does not take
creative assignment changes on that buy. An older list that took the change does
not count once a newer one leaves it out. Apostra reads the action list the way
it does before it changes a live buy, so this check and that gate agree. An
update with no action list read by then is judged.

**Threshold.** For each Source, over seven days, Apostra counts the answered
requests that carried `creative_assignments`. A refusal is read from its error's
`field`, which names one item and one of its fields as a path into the request,
such as `packages[0].creative_assignments[1].weight`, or
`new_packages[0].creative_assignments[0].weight` for a package the update adds:

* A request your agent accepted is not a miss.
* A request refused with `VALIDATION_ERROR` whose field is the path of an item
  the request sent is not a miss, when that item carried more than a
  `creative_id`. That is AdCP's answer to an item that asks for something your
  platform cannot honour, such as a weight, a rotation or a placement.
* A request refused with `UNSUPPORTED_FEATURE` whose field is the path of an
  item's `landing_page_url` or `trackers` is not a miss, when that item carried
  more than a `creative_id`. That is AdCP's answer from an agent that does not
  declare `creative.supports_assignment_landing_page` or
  `creative.supports_assignment_trackers`.
* Any other refusal whose field names `creative_assignments` is a miss. That
  includes refusing an item that carries only `creative_id`, which asks for
  nothing an agent can decline, refusing with another code such as
  `INVALID_REQUEST`, a field that does not name one item the request sent,
  such as `packages[0].creative_assignments` for the whole list, and a recovery
  other than `correctable`.

Both refusals AdCP allows carry the recovery `correctable`, because the buyer
can change or drop the field. An error that leaves `recovery` out counts as
`correctable`, because that is AdCP's own recovery for both `VALIDATION_ERROR`
and `UNSUPPORTED_FEATURE`. An error that says `terminal` or `transient` is a
miss. The [declarations match behaviour finding](https://docs.apostra.com/v3/agent-requirements.md#declarations-match-behaviour-finding)
leaves out exactly the refusals this check judges and accepts, judged here
against the request your agent was sent, so a refusal that is not a miss here is
never counted against your agent there. A refusal that is a miss here, such as
one of an item that carried only `creative_id`, is not left out there. Nor is a
refusal of an update this check does not judge because your action list left
out `update_creative_assignments`: that list said your agent does not take the
change, so the declarations finding still reads the refusal.

Apostra matches each part of the path exactly: `packages` or `new_packages`, the
package's position, `creative_assignments` as a whole name, then the item's
position, then one of the item's AdCP fields. A path into `new_packages` names
an item of the packages the update adds, never one of `packages`. A field such
as `packages[0].not_creative_assignments` does not name `creative_assignments`.
A failed request whose error does not name `creative_assignments` says nothing
about this check and is not counted. Nor is a refusal with an AdCP code about
the creative, such as `CREATIVE_NOT_FOUND` for a creative your agent does not
hold or `CREATIVE_LIVE_UPDATE_UNSUPPORTED`, or about the buy's state
(`INVALID_STATE`), whatever field it names: those answers are about the creative
or the buy, not about how your agent takes the assignment. The finding still
shows how many there were. A request whose stored copy was cut at the ledger's
size limit is not judged. Apostra compares the error's code and field as your
agent sent them, and does not read or store its message.

While this is a finding, one or more misses show as a **flag** on the Agent page.
It is never a blocker today, so it stops nothing: no buy is held back and no
certification pass stops counting. The finding shows the counts of requests
checked, accepted, refused as AdCP allows, refused any other way, and refused
with a code about the creative or the buy. It applies to every sales agent on
the same terms, Apostra's own included.

Whether your agent keeps the item fields it accepts, such as a weight or a
landing page, needs a read of the buy and is not judged by this finding.

**Usual causes.**

* The agent checks a package against a fixed list of fields it handles, and
  refuses `creative_assignments` as an unknown field, often with
  `INVALID_REQUEST`.
* The agent refuses an item it cannot honour with `INVALID_REQUEST` or
  `UNSUPPORTED_FEATURE` instead of `VALIDATION_ERROR`.
* The agent names no field, or a field that does not say which item and which
  part of it it refused.

**Next step.** Take package `creative_assignments` on `create_media_buy` and
`update_media_buy`, on `packages` and `new_packages`. When an item asks for
something you cannot honour, refuse it with `VALIDATION_ERROR` and a field that
names it, such as `packages[0].creative_assignments[1].weight`. When you do not
take a landing page or trackers on an item, refuse them with
`UNSUPPORTED_FEATURE` and a field that
names `landing_page_url` or `trackers`. Never refuse an item that carries only a
`creative_id`, except with an AdCP code about the creative, such as
`CREATIVE_NOT_FOUND`. If you do not take creative changes on a live buy, leave
`update_creative_assignments`, and the `sync_creatives` action that covers it,
out of the action list you return on `get_media_buys`. The finding clears as the
seven-day window moves on. See
[Answer creative assignments on a media buy](https://docs.apostra.com/v3/agent-requirements.md#answer-creative-assignments-on-a-media-buy).

### Reachability finding

**Applies when** Apostra called your agent in the seven days and the call was
answered or failed with no response. A Source Apostra did not call is not judged,
and an idle agent is never unreachable.

**Threshold.** For each Source, over seven days, Apostra looks for stretches in
which it called your agent and got no response, and no call in between was
answered. A call gets no response when the connection is refused or reset before
any response, or when nothing answers before the response deadline. A call your
agent answered does not count, even when the answer was an error or the
connection dropped after your agent began to answer. A call that is still
pending, or that Apostra did not send, counts for nothing either way.

A stretch runs from the first call with no response to the last one before your
agent next answers. It ends early if more than an hour passes with no call at
all, because that time is idle, not downtime. It counts only the time Apostra was
calling, so a single failed call, or two failed calls with hours of no calls
between them, is a stretch of no length. A stretch that is still going when the
window ends counts as it stands.

A stretch of more than 15 minutes is an outage. One outage is a **flag**. Two
within the seven days are a **blocker**, and so is a single stretch of six hours,
so an agent that stays down does not rest at a flag. A rolling deploy or restart
that leaves your agent unanswering for a few minutes does not reach the line:
across every agent Apostra calls, in the 30 days to 28 October 2026, the longest
stretch was 2 minutes.

`call_success_rate` does not count these calls. It counts only calls your agent
answered, so a connection failure never moves it.

**Usual causes.**

* A deploy or restart that stops every instance before a new one accepts
  connections, or that shuts an instance down while calls are still arriving.
* An agent, ad server connection or host that was down, or a certificate or DNS
  record that expired.
* A firewall, rate limit or network rule that drops Apostra's connections.
* A request that hangs until the response deadline because the agent never
  answers it.

**Next step.** Bring the agent back, and check that it answers a
`get_adcp_capabilities` call. For deploys, keep at least one instance accepting
connections, stop sending new calls to an instance before it shuts down, and let
in-flight calls finish. The finding clears as the seven-day window moves on.

### A sandbox account that serves

Before each buy, Apostra calls your `sync_accounts` with its certification test
identity: for example brand `acmeoutdoor.example`, operator
`pinnacle-agency.example` and `sandbox: true`. Apostra asks for a billing model
your agent offers: `agent` first, then `operator`, then `advertiser`.

Your agent is ready when:

1. `sync_accounts` accepts that identity and returns the account as
   `status: "active"` with `sandbox: true` and an `account_id`. Apostra uses
   that `account_id` for the creative and the buy, and never falls back to a
   default account.
2. Buys on that sandbox account serve through your real ad server, at no cost to
   Apostra. The sandbox account that serves through your ad server is the test line. You do not
   set up a separate test placement or name a trafficking contact.

A sandbox that only answers the protocol cannot certify a tracked use case. AdCP
says a sandbox account performs no real platform calls, so if yours stops there,
nothing serves and Apostra's tracker sees nothing. The buy goes live, but the
tracked checks never get evidence, so the use case stays inconclusive.

Sellers that set `account.require_operator_auth: true` are certified like any
other: Apostra runs certification on the credential you connected, which is the
credential a storefront calls your agent with, so the storefront is the
operator. Certification used to skip these agents as
`seller_operator_auth_unsupported`, and runs from before 19 November 2026 still
show that reason.

The sandbox account above is for test buys, where your agent is the seller to
Apostra's test buyer. The request your agent receives when it runs behind a
publisher's own storefront is judged separately, as the
[accounts use case](https://docs.apostra.com/v3/certification.md#use-cases).

Channels Apostra's tracker cannot observe, such as linear TV, radio, print and
DOOH screens, certify on your reports instead. See
[Use cases](https://docs.apostra.com/v3/certification.md#use-cases).

### Certification-ready sandbox

Certification runs an actual campaign on your actual ad server. So your sandbox
needs real traffic for reporting and testing to work: a sandbox that serves
nothing gives Apostra no impressions to compare and no reports to read.

**Bring your own traffic.** Apostra does not send traffic to your inventory, and
cannot. A certification buy runs for three days, so it needs enough real
requests in that time to serve and fire Apostra's tracker. If your inventory
serves rarely, for example a placement that serves only when an AI agent opens
the page, drive traffic to it yourself while the test buy runs, and click the ad
at least once if the format takes clicks.

**Turn on automatic approval for certification creatives.** Apostra
recommends it so a run never waits on you. Your agent and ad server still apply
their own checks to the creative. Apostra skips only its own creative review.

**Manual approval works too, and the run waits for it.** When your agent holds
the certification creative for review, Apostra does not end the use case. It
shows a finding, "Your agent is holding our certification creatives for review,
so certification is waiting for you to approve them", on the Agent page and the
Overview page, and in the agent's `findings`. Its `whatWeSaw` names the use
cases that wait and the date the wait ends.

**An agent with no review step does not wait.** If your agent accepts the
certification creative on `sync_creatives` (`action` `created`, `updated` or
`unchanged`, with no errors) and gives no review `status`, Apostra creates the
test buy straight away. AdCP has an agent with no review lifecycle leave
`status` out, so Apostra reads that answer as "nothing to review". An agent that
does review creatives must say so: answer `pending_review` or `processing` while
it reviews.

How the wait works:

* **How Apostra checks.** Every four hours it reads the creative with
  `list_creatives`, filtered to that creative and the account the sync used,
  because AdCP makes `list_creatives` the authoritative review state. It does
  not send `sync_creatives` again just to ask: an agent that replays a repeated
  request returns its first answer, which would never change. The listed
  `status` decides: `approved` continues the run, `pending_review` or
  `processing` keeps waiting, and `rejected` ends the use case. If your agent
  cannot list creatives, does not list this one, or lists it with another
  status, Apostra sends `sync_creatives` again for the same creative and reads
  its answer as above.
* **How long.** Apostra waits up to five days from when the run created the
  use case. Five days reaches a creative submitted on a Friday evening and
  reviewed on Tuesday.
* **When you approve in time.** Apostra creates the test buy on its next check,
  within about four hours of your approval. The three-day flight and the
  [14-day collecting window](https://docs.apostra.com/v3/certification.md#when-apostra-starts-a-run) count
  from that moment, not from when the run began.
* **When you do not.** The use case ends inconclusive with
  `seller_creative_review_required`, and the finding goes away. Apostra then
  starts another run, which waits again.
* **When you reject it.** The use case ends at once with your agent's rejection
  reason, as `creative_sync_failed`.

While a run waits, the Source's earlier result keeps its seven-day evidence
window. A slow approval can let that earlier result expire before the new buy
has evidence. Automatic approval avoids the gap.

## Use cases

Apostra reads your products and capabilities to decide which use cases apply.
You do not maintain the list. A use case your agent does not declare does not
apply, and one it declares but has not passed cannot take buys yet.

| Use case | Applies when your agent declares | Judged on |
| - | - | - |
| Display with our tag | Display products that accept `display_tag`, or that accept `image` or `html5` in a format with a URL impression-tracker slot. A `display_tag` format is measured only when it takes inline markup, as [How Apostra measures a display tag](https://docs.apostra.com/v3/certification.md#how-apostra-measures-a-display-tag) explains. DOOH products qualify only where Apostra's tracker can fire, which is programmatic DOOH | The standard checks |
| VAST video or audio with our trackers | Video, audio, podcast or CTV products that accept `video_vast` or `audio_daast`, or that accept `video_hosted` or `audio_hosted` in a format with an impression-tracker slot or a playback-tracker slot | The standard checks, plus quartiles for `video_vast` and `audio_daast`. Podcasts differ, as explained below the table |
| Cost-per-completed-view video | A video or CTV product with CPCV pricing or a `completed_views` optimization goal | The standard checks, plus quartiles |
| CPA and conversion tracking | Conversion tracking on a product and in `media_buy.conversion_tracking` | The standard checks |
| Audience or signal targeting | `signal_targeting_allowed` on a product, or `media_buy.audience_targeting` | The standard checks |
| Priced signal targeting | A product allows signal targeting and offers a usable, priced third-party signal | A separate report-only buy checks whether your agent retains the selected signal, reports delivery and charges the signal once when the reported package spend can be compared with a known fixed price. The result does not decide certification. Each buy costs at most USD 10 including the maximum signal fee |
| TMP | A product with `trusted_match`, on a channel where the tracker fires | The standard checks, with `TMPX` also judged |
| Seller-reported sandbox buy | Products on linear TV, radio, print, cinema, out-of-home, influencer or product placement, DOOH products where Apostra's tracker cannot fire (any format, including `image` and `video_hosted`), video, audio, podcast or CTV products that accept `video_hosted` or `audio_hosted` in a format with no tracker slot, podcast ads the host reads (an `audio_hosted` format with `asset_source: "publisher_host_recorded"`, whatever slots it declares), or only legacy `format_ids` that Apostra cannot track | Buy goes live, echoes our context and reports on time |
| Compact lifecycle | AdCP 3.2 or later in `adcp.supported_versions`, and `list_products`, `control_media_buy` and `buy_products` or `accept_proposal` in `media_buy.lifecycle_tools` | Apostra does not run this one yet. It shows as inconclusive with the skip reason `compact_lifecycle_not_runnable` |
| Accounts for a seller's own storefront | Every agent, whatever it declares | Your agent's answer to the account request a publisher's storefront sends its own agent. No buy |
| Buyer's own audience | `media_buy.audience_targeting` in `get_adcp_capabilities` | Whether your agent accepts an audience a buyer brings, reports its status honestly, and keeps or refuses the audience in a buy. Report-only, as [Buyer's own audience](https://docs.apostra.com/v3/certification.md#buyers-own-audience) explains |

A seller's [demand coverage](https://docs.apostra.com/v3/seller-readiness.md#kinds-of-demand-you-serve) reads its products against
this same table, so it shows which of these use cases the seller's products offer before any run. The use
cases judged on the whole agent (priced signal targeting, the compact lifecycle and accounts for a seller's
own storefront) are not on it.

A podcast ad inserted at download time fires our tracker when the episode is
downloaded, not as it plays, and an episode downloaded before a stop or a change
can be played days later. So a podcast product is not judged on quartiles, on
stopping serving or on changes taking effect, and every other check applies.

The extra checks the spec lists for cost per completed view, conversions and
TMP are being added. Today a run for those use cases is judged on the standard
checks. Priced-signal targeting is reported separately and does not decide
certification. Where package impressions, spend and fixed prices are available, it also checks whether spend includes one signal charge. The comparison uses every ended reporting period since the buy went live, and rounds both reported and expected spend to the currency's minor unit. Missing, late or ambiguous figures leave that check inconclusive. The test selects a binary signal priced in the buy’s currency, preferring CPM and then percentage pricing on fixed-price media; flat-fee signals are not selected. It skips the extra buy when its maximum cost cannot be bounded. A priced-signal buy shares the run’s five-buy limit, so another family may wait for a later run.

The base use cases determine whether a product may take a new buy. Cost per
completed view, conversions, audience or signal targeting, and TMP are feature
use cases: a pass shows the agent was certified for that feature, but a missing
feature pass does not itself block buys. The agent's findings raise Attention
when a storefront offers a use case without a pass that counts, including when
it has never run or the result is inconclusive. Allow certification buys and
fix any failure to obtain a pass.

The compact lifecycle use case is different from the others in two ways. It
belongs to the whole agent, not to a product, so it is never split by family.
And it is reported beside the other use cases but does not decide certification:
a pass does not certify your agent and a failure does not fail it, so it has no
effect on Storefront readiness, on a publisher's connection to your agent, or on
any buy. The compact lifecycle becomes required for certification on 1 February
2027: from then, an agent that has not passed it does not count as certified,
whatever its other use cases show. The AdCP 4.0 readiness check for the compact lifecycle reads this use
case's result.

Apostra also uses this use case's result to decide how it buys from your agent.
Apostra calls your agent through the compact lifecycle, starting with
`request_proposals` for a proposal round, only once your agent passes this use
case. Advertising `request_proposals` in `media_buy.lifecycle_tools` does not
change how Apostra buys from you. Until the pass, Apostra keeps using
`get_products`. The pass applies while it is the latest decisive result on every
active Source that uses your agent, so a later failed run returns Apostra to
`get_products` until the next pass.

The accounts use case is for an agent that runs behind a publisher's own
storefront, as a publisher's ad server does. When the publisher approves a
buyer, Apostra asks that agent for the advertiser's account. Apostra judges every
agent on this, whether or not a publisher uses it that way today. Each run sends
your agent `sync_accounts` twice for the certification identity (sandbox), with
`billing: agent` and no payment terms, and with a different idempotency key each
time. [What Apostra asks your agent for](https://docs.apostra.com/v3/seller-buyer-account-mapping-page.md#what-apostra-asks-your-agent-for)
explains why `billing` is always `agent` on that request.

* **Pass:** both answers return the same active sandbox account with an
  `account_id`. The second answer's `action` is `unchanged` or `updated`.
* **Fail:** your agent refuses either request, for example with
  `BILLING_NOT_PERMITTED_FOR_AGENT`. It also fails if your agent returns an
  account that is not active, or no `account_id`, or a different account the
  second time. An agent that does not offer `sync_accounts` fails without being
  asked. Setting `account.require_operator_auth: true` does not fail it.
  Apostra never retries with another `billing` value, including the one a
  refusal suggests.
* **Inconclusive:** your agent holds the account for approval, or Apostra's
  request does not complete.

This use case does not decide certification. A pass does not certify your
agent, and a failure does not fail it or stop any buy. It runs on each inventory source with that source's
own credential, because accounts belong to the publisher, so each source has its
own result. Apostra also runs this check on its own, with no buy, on each
inventory source of a publisher's storefront that sells through its own sources
as well as your agent, including one still waiting to go live. It does this
whether or not you asked for certification: daily until the source passes, then
weekly. On such a storefront, a new inventory source for your agent does not go live
until it passes; a source that is already live keeps running. On a publisher's storefront that sells through its own sources as
well as your agent, a failed result shows on that inventory source's health and
as the `certification.storefront_accounts` finding on the Agent page.

### Buyer's own audience

A buyer can bring a first-party audience: a list of hashed identifiers sent with
`sync_audiences`, which the buyer then targets with `audience_include` in a
package's `targeting_overlay`. This use case checks that your agent takes that
audience and does what AdCP says with it. It belongs to the whole agent, so it
is never split by family. It applies when `get_adcp_capabilities` declares
`media_buy.audience_targeting`; AdCP says that block means your agent supports
`sync_audiences` and `audience_include` and `audience_exclude` in a targeting
overlay.

**It is report-only.** It shows beside the other use cases and does not decide
certification: a pass does not certify your agent, and a failure does not fail
it or stop any buy. Making it count toward certification is a separate decision
that Apostra will announce, with a date, before it takes effect.

**Apostra does not send these calls yet.** The use case and its three checks are defined, and your agent is told which of its declarations make it apply, but a run does not yet sync a test audience or create a buy that targets one. Until it does, the use case shows no result.

Three checks judge it, each against the AdCP schemas:

| Check | Passes when |
| - | - |
| Sync accepted | `sync_audiences` returns the audience with an AdCP audience status: `processing`, `ready`, `too_small` or `suspended`. A refused call, an answer that is not a valid `sync_audiences` response, or a status AdCP does not define fails |
| Status is honest | The status is never `ready` while `matched_count` is below `minimum_size`, and `minimum_size` is present when the status is `too_small`. AdCP says a seller MUST emit `too_small`, not `ready` with a low `matched_count`, in that case. Apostra compares the two figures only when you report them |
| Targeting kept | A `create_media_buy` whose package has `targeting_overlay.audience_include` is either accepted and read back with the audience still in `audience_include`, or refused with `AUDIENCE_TOO_SMALL` and the details AdCP recommends (`current_size` and `minimum_size`) while the audience is `too_small`. Dropping the include without saying so fails, and so does accepting the buy while ignoring it |

**Delivery is not judged yet, and is never shown as a pass.** AdCP has no test
audience that matches at a known size, and Apostra cannot use real personal
data in certification. A synthetic list matches nothing, so the audience stays
`too_small` on platforms that set a minimum audience size. The three checks
above can be proven through the `too_small` path. Apostra cannot yet prove a
`ready` audience, a buy that targets one, or its delivery, and records delivery
as not provable until AdCP defines a test audience.

**How this differs from audience or signal targeting.** The Audience or signal
targeting use case also applies when your agent declares
`media_buy.audience_targeting`, but a run judges it on the standard checks and,
for signals, the priced-signal buy. Nothing in it sends your agent a buyer's
audience. This use case does, and it leaves the existing use case's
applicability and results unchanged.

What your agent must do is in
[Take a buyer's audience, report it honestly and keep or refuse it](https://docs.apostra.com/v3/agent-requirements.md#take-a-buyers-audience-report-it-honestly-and-keep-or-refuse-it).

A use case is also split by product family. Display on one ad server and display
on another are two families, and each needs its own certification buy.
Programmatic and non-programmatic DOOH are always separate families. Each
format kind on a DOOH product is its own family and gets its own certification
buy.

Apostra places one certification buy for each family, and a family is one
format option: two options of the same kind that differ in size or parameters
are two families, each with its own buy. Options that differ only in their
`format_option_id`, with the same kind and parameters, share one family and one
buy. The buy names the option of the product it buys, so the result says the
shared format works for every product the family stands for, not that each
option id was tried. A format no use case names, such as
`agent_placement`, is a family too. A family buys the first of its products in
the order your agent lists them, and its result stands for every product that
offers the same option on the same terms. A use case that Apostra
judges with its own tracker, such as conversion tracking or audience targeting,
never claims a path where the tracker cannot fire. A DOOH-only agent that sells
`image` and `video_hosted` therefore gets two buys, even if it also declares
those capabilities. Conversion tracking, audience targeting and the other
capabilities you declare add their checks to the buy of the family they apply
to; they never place a buy of their own.

### How many buys a run places

A run places at most 5 certification buys: a run spends at most USD 50, and
each buy is at most USD 10. Most agents have one to five families and never
reach the limit; for them nothing changes. When an agent has more than 5, the
run chooses which 5 to buy, in this order:

1. Families no run has tried yet.
2. Families whose latest result failed, and families a run tried that have no
   result yet, for example because the run skipped them before buying.
3. Families whose latest result passed but whose evidence has gone stale, as
   [How certification is kept](https://docs.apostra.com/v3/certification.md#how-certification-is-kept)
   describes it.
4. Families whose latest result passed and whose evidence is still fresh.

Inside each group, the family a run last tried longest ago goes first, whether
that run bought it or skipped it. A run chooses only as many families as its
spending limit pays for, so the limit does not skip a family it chose. A family
whose cheapest buy costs more than the USD 10 per-buy cap does not take one of
the 5 places: the run records it as `budget_exceeds_per_buy_cap` and buys the
next family in the order instead. The
exception is a run that also checks that your agent refuses a buy with no
creatives ([Create without creatives finding](https://docs.apostra.com/v3/certification.md#create-without-creatives-finding)):
that check books one more buy from the same limit, so the last family the run
chose can be skipped for the limit. A family skipped only because the run's
spending limit ran out has not been tried, so it keeps its place in the order
for the next run. The families left over are bought on later
runs in this same order, so every family comes round. A family that is skipped
before a buy every time (for example, because certification has no creative for
its format) never gets a result, so it waits its turn with the failed families
instead of taking a place on every run and pushing the others out. A family
that passed with fresh evidence waits only when the limit forces something out;
with room to spare, it is bought again so its evidence does not expire.

### Formats certification does not test

A product can offer several format options, and a run plans one buy for each
distinct option. When a run plans no buy for a format option your products
offer, Apostra records the option with the reason and shows
it as the `certification.format_not_tested` finding on the Agent page. The
finding names each option, its product and channel, except an option with the
reason `recently_passed`, which is not untested. It is an attention finding:
it does not stop buys or fail your certification, and the options it names stay
bookable. It does mean Apostra has no evidence those formats work.

When a certification buy carries a creative, each package assigns it in
`creative_assignments` and names the one format option that creative is meant
to fill. AdCP treats a package that names no format as asking for every format
on the product, so naming the option tells your agent that the one creative
covers the package. Once that option has its creative, your agent should start
the buy, not hold it in `pending_creatives` for the product's other formats.

How the option is named depends on whether your agent takes canonical formats
on `create_media_buy`:

* **Your agent takes canonical formats**, for example because it declares
  `media_buy.features.canonical_creatives: true` in `get_adcp_capabilities`
  (see [Getting ready for AdCP 4.0](https://docs.apostra.com/v3/adcp-4-readiness.md)): the package names
  your `format_option_id` in `format_option_refs`.
* **Otherwise:** the package names the legacy `format_ids` entry your product
  declares for that option, for example in the option's `v1_format_ref`.
* **The option has no legacy entry of yours, and your agent does not take
  canonical formats:** the package names no format, so your agent may hold
  the buy in `pending_creatives` until every format on the product has a
  creative. Declaring `canonical_creatives: true` lets Apostra name the option.

A family planned from one of your legacy formats names that `format_ids` entry,
as before.

For each family, Apostra chooses the format option its test creative fills from
your product's options of the family's own format kind, in the order your
product lists them, whether Apostra's tracker or your reports judge the family.
A creative of another kind is never used, even when your product also offers
that kind: an image is never bought for a video family. A family that stands
for one of several options of a kind, or for a kind no use case names, chooses
only from its own option. It leaves out any option
the creative's own facts conflict with, as `@adcp/sdk` judges them: for example
a VAST 3.0 tag and an option that declares `vast_version: "4.2"`. Of the rest
it takes the first option the creative meets exactly, or else the first option
it can be adapted to, syncs the creative to your agent under that option, and
names the same option on the package as described above. When the creative's
facts cannot settle the choice, for example a VAST tag whose length is not
measured, the package names the option only when one is left. If none of
Apostra's test creatives fits any of them, the family is skipped before any buy
as `buy_creative_channel_unmatched`, which is Apostra's gap, not yours.

| Reason | What happened | What to change |
| - | - | - |
| `format_not_covered` | No use case buys this kind of format on this channel. Only a run that found your products through briefs records it | Nothing on your side. Your other formats still count toward certification |
| `unsupported_channel` | The product puts the format on a channel certification does not buy on | Declare a channel certification buys on, such as display, video, audio, ctv or dooh |
| `missing_channels` | Neither the product nor the format option declares a channel | Declare `channels` on the product, or `applies_to_channels` on the format option |
| `no_family_planned` | A use case covers the format, but the run planned no buy for this product, or the product's offer was not accepted for that channel's brief. Only a run that found your products through briefs records it | Nothing on your side |
| `another_option_bought` | The product offers several options of one kind on one channel, such as image sizes, and they share one certification buy, which used another option. Only a run that found your products through briefs records it | Nothing on your side. Apostra does not test the other options yet |
| `option_not_identified` | The same shared buy, but the run did not record which option it used, so none of them counts as tested. Only a run that found your products through briefs records it | Nothing on your side |
| `deferred_by_cap` | A run places at most 5 buys, and this format's family did not fit. A later run buys it, in the order under [How many buys a run places](https://docs.apostra.com/v3/certification.md#how-many-buys-a-run-places) | Nothing on your side |
| `recently_passed` | The same limit, but the family passed and its evidence is still fresh, so it waited. It is not untested, so it raises no finding | Nothing on your side |

The list comes from the latest run on each of your active inventory sources.
Runs started before Apostra recorded this show no finding.

### Products buyers cannot see

Before a storefront answers `get_products`, it checks each product against the
AdCP release the buyer is served: `3.2`, unless the buyer pins another release.
A product that fails that release's product schema is left out of the answer,
so no buyer at that release sees it or can book it. The answer's `errors` list
names the product in a `PRODUCT_UNAVAILABLE` entry, with the field that failed
(see [AdCP versioning](https://docs.apostra.com/v2/concepts/adcp-versioning.md)).

A certification run reads the same answer a buyer gets. It records each
product of its inventory source that the answer left out, with the release and
the field that failed, and the Agent page shows them as the
`certification.product_withheld` finding. Each product is named by its id in
your agent. It is an attention finding: it does not stop buys or change a
certification result, and the run certifies your other products as usual. A
storefront answer names at most 20 of the products it leaves out, so the
finding says when there may be more.

To clear it, make each product valid at the release named. The field is shown
as a JSON pointer into the product, for example `/format_options/0/format_kind`.
Correct the product in your agent, and the next certification run reads it
again. If the product already looks valid to you, tell Apostra: a storefront
serves your products through its own projection, and a defect there can leave
out a product you declared correctly.

The finding comes from the latest run on each of your active inventory sources.
When the storefront leaves out every product of a source, certification cannot
start a run there at all. The finding then comes from that refused automatic
start, names the products the same way, and says certification could not start
on the source. Runs started before Apostra recorded this show no finding.

### How Apostra measures a display tag

A display tag is HTML that Apostra sends your agent, so Apostra can carry its
impression pixel inside the tag. That is how a `display_tag` format with no
tracker slot is still measured, provided the format takes the tag as inline
markup: its `supported_delivery_types` lists `inline_markup`, and its slot is
the HTML the tag fills. AdCP assumes a tag URL only when a format declares no
delivery types, so list `inline_markup` explicitly.

For the certification buy only, Apostra adds one 1x1 image to the end of the
markup it sends in `sync_creatives`. The image is Apostra's impression tracker
for that buy. It carries `CACHEBUSTER`, `DOMAIN` and `APP_BUNDLE` for your agent
to fill where it serves the tag, so the [macro check](https://docs.apostra.com/v3/certification.md#what-each-check-judges)
judges them on the tag. Apostra fills its own identity in the pixel, such as
the media buy, before it sends the tag. The creative in Apostra's library is not
changed, and a tag Apostra syncs for a real buy is sent exactly as the buyer
supplied it.

If the format declares an impression-tracker slot, Apostra uses the slot and
adds nothing to the markup, so an impression is never counted twice.

A format that takes its tag as a URL (a required `tag_url` slot and no HTML
slot) is sent a tag Apostra hosts: Apostra stores its certification test
creative as an HTML page and puts that page's https URL in `tag_url`, for your
agent to serve in an iframe. Apostra cannot add its pixel to a page served from
a URL, so such a format is measured through its impression-tracker slot. Without
one it is skipped as `seller_format_cannot_carry_tracker` until the format also
takes inline markup or declares a tracker slot. A format whose
`supported_tag_types` leave out `iframe` expects a script or a redirect at that
URL, which Apostra cannot host, so it is skipped as
`buy_creative_channel_unmatched`, Apostra's gap.

## What each check judges

| Check | What Apostra observes | Applies when |
| - | - | - |
| The buy goes live | Your agent accepts the buy, reports it `active` or `completed`, and starts serving | Always |
| Your agent echoes our context | Every response hands back the request's `context` unchanged, `get_media_buys` returns the buy with the `context` it was created with, and each package comes back with its own package `context`. See [Context your agent must hand back](https://docs.apostra.com/v3/certification.md#context-your-agent-must-hand-back) | Always |
| Macros are replaced | Impression hits carry real values where our macros were. `CACHEBUSTER`, `DEVICE_TYPE`, `COUNTRY` and `MEDIA_BUY_VERSION_HASH` must fill on every hit. Display and video hits must fill `DOMAIN` or `APP_BUNDLE`, and the one that does not apply must arrive empty: a hit on a website fills `DOMAIN` and sends `APP_BUNDLE` empty. A placeholder left in the hit, such as `[APP_BUNDLE]` or `{APP_BUNDLE}`, fails the check even when the other one is filled. Consent-dependent macros such as `DEVICE_ID` and `IP_ADDRESS` may arrive empty but never literal | Our tracker can fire |
| Clicks fire | At least one click reaches our click tracker with its macros filled. Each click is judged on the macros its own creative's click tracker was sent with: a creative whose format option your agent declares no macros for, such as an HTML5 click tag on Google Ad Manager, goes out without them, so its click is not expected to fill them. It fails on 1,000 impressions with no click. Clicks from known crawlers and from Google's ad review are not counted, so they neither pass nor fail the check; the result says how many it set aside. See [Hits the tracker checks set aside](https://docs.apostra.com/v3/certification.md#hits-the-tracker-checks-set-aside) | Display and video formats that take clicks |
| Reports arrive on time | A report arrives for every period by the time the product promises. More than 60 minutes late counts as a miss. One miss is a warning and two in seven days fail the use case. A `delayed` notice buys one 24-hour extension for that period. If your product declares `supports_webhooks: false`, Apostra reads your reports by [polling](https://docs.apostra.com/v3/seller-reporting-delivery.md#when-apostra-reads-your-delivery) at 02:00 and 14:00 UTC and does not send a `reporting_webhook` on the buy, so the deadline runs from the first of those reads after the report falls due: a report that is there at that read is on time, and one that is not is late by the same 60 minutes. A report counts only when its `reporting_period` starts and ends on the boundaries of the product's periods in the `timezone` your `reporting_capabilities` declare and it includes the buy. A period may end at the next midnight (AdCP 3.2) or on its last second, such as `23:59:59Z` (the AdCP 3.1 example); both name the same period. A report counts for each period it covers that had ended when the report arrived, so a report for a period still running is not counted; a report that spans several whole periods supplies no seller totals for the reconciliation check. The check names any report it did not count and why, and [reporting receipts](https://docs.apostra.com/v3/seller-reporting-delivery.md#reporting-receipts) show every report Apostra received for the buy. From 1 December 2026, a report your agent pushes to Apostra's delivery webhook counts only when it arrives as a valid AdCP 3.1+ envelope: a report in the AdCP 3.0 bare format is not counted, and neither is one Apostra refused for failing the schema, which the check names with its first failing field. A report Apostra reads by polling is unchanged. See [Delivery report format finding](https://docs.apostra.com/v3/certification.md#delivery-report-format-finding). If you change the declared `timezone` while a test buy runs, reports in the new timezone count, including one for a day already marked missed because its report was in the new timezone; each is judged against the new timezone's deadline | Always |
| Reports agree with our tracker | Reported impressions match our tracker within 20% over the flight. Below 1,000 tracker impressions the result is inconclusive and does not block | Our tracker can fire |
| Ad-server delivery | Our tracker's impressions match your ad server's pre-filter count within 20%, once the tracker has 100 impressions. Your agent may report the pre-filter count as `unfiltered_impressions` from Google Ad Manager. Without it the check is inconclusive and does not block | Our tracker can fire |
| Spend stays within the budget | Spend our tracker observes, at the rate the buy was booked at, never passes the package budget plus 20%. It applies to a buy booked on a fixed CPM and is checked from the day it ships, with no report-only period. It fails as soon as the spend is over | Our tracker can fire |
| A pause skips finished packages | Apostra books two packages, the first finishing before the second starts, and pauses the buy once the first has finished. The pause must succeed, your agent must report the buy `paused` on its next read, our tracker must go quiet within the channel's grace, and a resume must restart serving. It is checked from the day it ships, with no report-only period | Our tracker can fire, and the product's minimum spend leaves room for two packages |
| A paused buy stops serving | Once the channel's grace has passed after the pause, our tracker hears no impressions until Apostra resumes the buy. The grace is 2 hours for display and 6 hours for video, audio and CTV. For DOOH it is 24 hours. When the buy has one package (see below), your agent must also accept the pause and report the buy `paused` on its next read | Our tracker can fire |
| A resume takes effect | Our tracker hears impressions again within the same grace after the resume | Our tracker can fire |
| Deleting an audience stops delivery | Apostra books a package that excludes a certification audience bound through your partner route, then deletes the audience. Once the channel's grace has passed after the delete, our tracker hears no impressions on that package. Report-only, and not yet run; see [Deleting an audience stops delivery](https://docs.apostra.com/v3/certification.md#deleting-an-audience-stops-delivery) | Your agent declares a partner route for audiences, and Apostra holds a certification dataset on that route |
| Live creative changes | Once the pause and the resume are done, Apostra changes the creatives on the same test buy, one change at a time: it attaches a second creative of the same format, detaches it, and replaces the first creative with it. For each change your agent declares, your agent must take it. For each change your agent leaves out of an action list it did send, your agent must refuse it with an error code. This is a finding only: it never makes a use case fail. See [Live creative changes finding](https://docs.apostra.com/v3/certification.md#live-creative-changes-finding) | The buy of the pause check, and a second creative of the same format offered to the run |
| Assignment operations | Once the creative id probe below has put a copy on a package of the test buy, Apostra syncs your agent a second copy of the buy's creative and sends one `sync_creatives` with an `assignment_operations` `replace` that swaps the first copy for it, to an agent it calls at AdCP 3.2 or later. It needs no serving, so it runs soon after the test buy is booked. Your agent should take it. A refusal that names `assignment_operations` as what to send instead is its own finding. This is a finding only: it never makes a use case fail. See [Assignment operations finding](https://docs.apostra.com/v3/certification.md#assignment-operations-finding) | The buy of the pause check, and the copy the creative id probe assigned |
| Creative ids with a tilde | Once the test buy is booked and its creative is synced, Apostra syncs your agent one creative under an id with a `~` in it, 128 characters long, the shape of a per-package copy, and reads it back with `list_creatives`, then assigns it to a package of the same test buy with `update_media_buy` and reads the buy with `get_media_buys`, only when that package is booked under Apostra's sandbox account. Your agent should keep the id exactly as sent and report the package as holding it. This is a finding only: it never makes a use case fail. See [Creative ids with a tilde](https://docs.apostra.com/v3/agent-requirements.md#creative-ids-with-a-tilde) | The buy of the pause check, and the creative already synced to your agent |
| Quartiles fire | Start, first quartile, midpoint, third quartile and complete arrive in order, and your `quartile_data` and `completed_views` agree with them. The result gives our tracker's count for each event and names any that did not arrive. Until 7 November 2026, browser video players could not read the VAST file Apostra hosts, so quartile events could be missing from a run that started before then; a certification run that starts after then judges it again | Video and audio |
| A buy with no creatives is held in `pending_creatives` | When Apostra first certifies your agent, when what it declares changes, after a probe that did not pass, and otherwise once a week after a pass, Apostra creates one more buy, with valid packages and no creatives, on the product your agent has just accepted or, when the run created no buy, on the cheapest product it can book, and cancels it again. Your agent must accept it and hold it in `pending_creatives`, as AdCP says. This is a finding only: it never makes a use case fail. See [Create without creatives finding](https://docs.apostra.com/v3/certification.md#create-without-creatives-finding) | A product of yours can carry the probe: a pricing option with an id, in a currency Apostra can settle in, within the USD 10 per-buy cap and, on an auction, with a price to bid |

The pause, stop and resume checks run on the first certification buy, so an
agent whose buys cannot be stopped is not certified. The live creative changes
run on the same buy after the resume, and are a finding only.

### Hits the tracker checks set aside

The tracker checks judge only hits a viewer's browser or app sent. Two kinds of
hit are counted apart and never judged. The clicks check says how many clicks
it set aside, and the stop and resume checks say how many review impressions:

* **Known crawlers.** A crawler such as Google's ad-review bot opens your
  creative's click-through URL without an ad being served, so the click's
  macros arrive empty. We recognise these by their user agent.
* **Google's ad review.** When Google Ad Manager reviews a creative, it renders
  it on Google's own pages and clicks it, which is not serving on your
  inventory. The render reports its site as `google.com` for display or
  `doubleclick.net` for video, and its click follows within two minutes with no
  site. A hit whose site is one of those domains is set aside, as is a click
  with no site or app that follows such a render of the same creative within
  two minutes and carries either no cachebuster or the render's own
  cachebuster. If you declare `google.com` or
  `doubleclick.net` (or a subdomain of either) as one of your properties,
  hits on that domain are judged as delivery as usual.

Set-aside hits count toward no check: not impressions, clicks or quartile
events, not the macros judged on them, and not a paused buy's silence. So a
review render during a pause does not fail the stop check.

### Reports the check does not count

When the reports check sets one of your delivery reports aside, its result says
how many reports it did not count and why, in the words in the first column.
A report set aside counts as no report for its period, so the period can still
be missed. Fix the reports your agent sends; the next report that counts is
judged as usual.

A buy is owed the whole of every period of the product's schedule that its
flight touches, including the period it went live in. AdCP puts a report's
`reporting_period` on the schedule's period boundaries, so report that first
period from its start, not from the moment the buy went live. A report on the
boundaries counts for the buy's periods it covers even when it also covers time
before the buy went live or after it stopped, such as a whole-day report for an
hourly product on the day the buy started. A report that covers only time
before the buy went live, or only time after it stopped, is about no period the
buy is owed, so the check neither counts it nor lists it. Apostra's first read
of a buy it polls asks for the day before the buy went live, and that read is
one of these.

| The result says the report | What it means | What to change |
| - | - | - |
| could not be read | The report is not a delivery report Apostra can read: it has no `reporting_period` with a `start` and an `end`, or no `media_buy_deliveries` list whose entries each carry a `media_buy_id` | Send each report in the shape of AdCP's `get_media_buy_delivery` response |
| did not include this buy | The report has no `media_buy_deliveries` entry for the test buy, under your id for the buy or Apostra's | Include an entry for every buy the report covers, with that buy's `media_buy_id` |
| did not carry a valid reporting period | The `reporting_period` `start` or `end` is not a date and time, or the period ends at or before it starts | Send `start` and `end` as ISO 8601 date-times, with the end after the start |
| carried an invalid finalization date | The buy's entry has a `finalized_at` that is not a date and time | Send `finalized_at` as an ISO 8601 date-time, or leave it out until the numbers are final |
| covered a span that is not a whole number of the product's scheduled reporting periods in its declared timezone | The `reporting_period` does not start and end on the boundaries of the product's reporting periods in the `timezone` your `reporting_capabilities` declare, for example a daily report that runs from midnight UTC when you declare `America/New_York` | Report each period from its start to its end in the timezone you declare, or declare the timezone you report in. A report may cover several whole periods |
| covered only periods that had not ended when the report arrived | Every period the report covers was still running when the report arrived, so it cannot be that period's complete report | Send each period's report after the period ends |
| arrived as the AdCP 3.0 bare delivery report, and a pushed report counts only as an AdCP 3.1+ envelope | From the delivery report cut-over date in "Reports arrive on time", your agent pushed the report to Apostra's delivery webhook in the AdCP 3.0 bare format. Apostra still records it for reporting, but the check does not count it | Send each report as the AdCP 3.1+ envelope, with the report under `result`. See [Delivery report format finding](https://docs.apostra.com/v3/certification.md#delivery-report-format-finding) |
| did not match the AdCP delivery webhook schema, and Apostra answered 400 | From the same date, Apostra refused the pushed report because it failed the AdCP delivery webhook schema, so the report was never stored. The result names the first field that failed | Fix the field the result names, and do not resend a report Apostra answered with `400` unchanged |

Seller-reported channels skip the tracker checks. They pass on the buy going
live, on your agent echoing our context, and on reports arriving on the
schedule your agent declares in `reporting_capabilities`.

A seller-reported buy carries a test creative, as every certification buy does:
Apostra never places a buy without one (see [A family Apostra has no creative
for](https://docs.apostra.com/v3/certification.md#a-family-apostra-has-no-creative-for)). For a display,
video, audio, CTV, DOOH, out-of-home, radio, print or influencer product,
Apostra looks among the creatives it offers for that channel (on out-of-home,
radio, print and influencer, the one creative a run offers to every channel)
for one whose format kind, size and length match one of the
formats your product declares exactly (a hosted video for a `video_hosted`
family, an image for an `image` family). A creative that would need resizing or
trimming does not count while Apostra can make one that matches. It syncs the
creative to your agent and assigns it to the buy, so an agent that holds a buy
until it has a creative can activate it. Apostra does not check that creative
for its tracker macros, because a seller-reported buy is not judged on them.

If none of the creatives Apostra offers matches exactly, Apostra makes one for
an `image`, `html5`, `audio_hosted`, `video_hosted` or `video_vast` format. It uses the first
format your product declares that it can make: the fixed size, the first
declared size, or a standard display size inside your size limits. For audio it
makes a 15 or 30 second tone, or, when neither fits your length limits, a tone
at the nearest limit. It makes images and HTML5 creatives up to 7680x4320 pixels
(no side above 8192) and up to two minutes of audio. Out-of-home gets the same
images and videos as DOOH, radio and podcasts the same spots as streaming audio, print an
image at the page size your format declares, and influencer an image or a
video at the size and orientation your format declares.

For `video_hosted` it uses one of nine standard videos: 1920x1080 (16:9),
1080x1920 (9:16) or 1080x1080 (1:1), each 6, 15 or 30 seconds long. Each is a
flat grey picture with a silent AAC audio track (H.264, 30 frames per second, a
keyframe every two seconds), exactly as long as its name says. Apostra takes the
fixed size or the first declared size your format lists when it is one of those
three. Otherwise it takes the first of the three that has your `orientation` and
`aspect_ratio` and sits inside your size limits. For length it takes your exact
length when it is 6, 15 or 30 seconds, else the first of 15, 6 and 30 seconds
that your length limits allow. Apostra reuses each creative it makes for later
buys.

For `video_vast` it hosts the same standard video and writes a VAST tag that
plays it: one inline `<Ad>` with a single linear creative, a click-through to
`https://scope3.com/`, and an MP4 media file. The tag is stored in Apostra's
asset storage like any VAST tag a buyer saves, but your agent receives a URL on
Apostra's API, of the form
`https://api.interchange.io/delivery/v1/certification-vast/{id}`, and
Apostra's trackers are added around it exactly as they are for a buyer's own
tag. That URL answers a browser player's cross-origin request the way Google's
IMA SDK requires: it echoes the page's `Origin` in
`Access-Control-Allow-Origin`, sends `Access-Control-Allow-Credentials: true`
and `Vary: Origin`, and answers the `OPTIONS` preflight. It needs no
credentials and serves only the tags certification writes. The size and length
come from the same rules as
`video_hosted`, using your format's `aspect_ratio`, `orientation`, size limits and
exact length or length range. The tag is written as VAST 4.2, or as the
`vast_version` your format declares when that is 4.1, 4.2 or 4.3. Any other declared version, including 4.0, gets 4.2. Its own
`Impression` element, which VAST requires, points at a host that does not resolve,
so a player sends nothing anywhere for it; the impression Apostra measures is the
one it adds.

For an `agent_placement` or `native_in_feed` format, Apostra builds the creative
from the slots the format declares, by asset type: copy for the certification
advertiser, Acme Outdoor, in each text slot, cut to the slot's length limit
or to the limit your format's params set for it (`title_max_chars`,
`body_text_max_chars`, `cta_max_chars`), whichever is stricter, and in a
call-to-action slot the first of your `cta_values` that fits that limit, in
place of Apostra's own copy;
Apostra's click URL in a click slot; a generated image in an image slot, at the
size the slot declares; and Apostra's impression tracker in an impression-tracker
slot, so a format that declares one carries Apostra's tracker. For a
`native_in_feed` format, which states its image sizes as format parameters, the
main image is built at the first of your `main_image_sizes` and the icon at your
`icon_size`. An icon is left out when your format declares no `icon_size`, and
an image is left out when your `image_formats` does not include PNG, the format
Apostra generates. Apostra uses a creative it built for one of your formats for
another only when each of its images is a size that format declares for that
image; otherwise it builds the other format its own creative at your declared
size. A required slot
Apostra cannot fill, such as a brief, a repeatable group of assets other than a
carousel's cards, or a VAST tag, skips the family before any buy as
`buy_creative_channel_unmatched`, and the
result names the slot and what stops Apostra. An optional slot it cannot fill is
left empty and recorded on the family as an advisory, with the checks it would
have made possible, and no result claims those checks. Certification plans these
formats only on out-of-home, radio, print and influencer today, so the same
format on a display product is not bought yet: the run lists it as
`format_not_covered`. Apostra reuses a creative it built this way, including
for a carousel, for later runs on the same format. When the format's
declaration changes, or Apostra changes how it fills the slots, the next run
builds a new one.

For an `image_carousel`, Apostra builds AdCP's `cards` group with as many cards
as your format requires, and never fewer than AdCP's minimum of two. Each card
carries a generated image, the headline "Gear up for every trail" cut to your
`card_headline_max_chars`, and Apostra's click URL as its `landing_page_url`.
Your agent receives them as AdCP card objects in the `cards` asset, alongside
the carousel's `primary_text` and `landing_page_url`. Each card image is sized
from your format's `card_aspect_ratio`, at 1080 pixels on the short side
(`4:5` gives 1080x1350), or 1080x1080 when your format declares no ratio. AdCP
gives a card no pixel size, so a size your agent declares under another
parameter is not read; if your agent needs a particular card shape, declare it
as `card_aspect_ratio`. A carousel that takes only video cards is skipped as
`buy_creative_channel_unmatched`, naming the `cards` slot. If your agent
rejects the carousel, the family is skipped as `creative_sync_failed` with your
agent's message.

For `audio_daast`, Apostra writes a DAAST 1.0 tag that plays its own test audio
and sends podcast families with it. A family on a format
Apostra cannot make a creative for, tracked or seller-reported, is skipped before any buy as
`buy_creative_channel_unmatched`. That is Apostra's gap, never yours: nothing in
your product is wrong and there is nothing for you to change, and you do not
need to report it: Apostra tracks these gaps itself. The family is tested in a
later run once Apostra can supply a creative for the format. Until then the buy
use cases for that format stay untested. The result for the family says so and
names the format. Certification reads your products as Apostra serves them to
a buyer, at the AdCP release the buyer is served, so it plans a product that
declares an AdCP 3.2 format such as `audio_vast`. Apostra does not yet make an
`audio_vast` creative.

When your product lists several formats of the creative's kind and your agent
publishes them as legacy `format_ids` that state no size, Apostra sends the
creative under the legacy format ID of the format it matches. It does not leave
your agent to pick among them by size.

Apostra falls back to an offered creative that would need resizing or trimming
only when it cannot make a matching one: a format larger than the limits above,
or a hosted video whose size, orientation or length none of the nine standard
videos meets (for example 1280x720, or exactly 10 seconds). If
your agent rejects the creative, for example because it requires a minimum
bitrate (the standard videos are a few tens of kilobits per second), the family
is skipped as `creative_sync_failed`.

Apostra applies the tracker checks only where your format declares a place for
its trackers. A hosted video or audio format promises that Apostra's trackers
fire when it declares an impression-tracker slot (the slot id contains
`impression`, `tracker_pixel` or `imp_pixel`, with asset type `url` or
`pixel_tracker`), or a playback-tracker
slot (`start_tracker`, `first_quartile_tracker`, `midpoint_tracker`,
`third_quartile_tracker` or `complete_tracker`, with asset type
`pixel_tracker`). For such a format, a buy whose tracker receives no hits
fails. A hosted format that declares none of those slots cannot carry
Apostra's trackers, so the tracker checks do not apply to it. It is certified
as a seller-reported sandbox buy, on the buy going live, on your agent echoing
our context and on reports arriving on schedule. The same hosted formats on DOOH stay seller-reported whatever
slots they declare.

DOOH screens are certified from your own reporting unless Apostra's tracker can
fire. A DOOH-only agent that sells hosted `image` and `video_hosted` formats at
screen sizes therefore passes on the same three checks as out-of-home.

### A family Apostra has no creative for

Apostra never places a certification buy without a creative. A buy with no
creative cannot go live: your agent rightly holds it in `pending_creatives`, so
it delivers nothing, sends no reports and proves nothing. When no offered
creative fits a family and Apostra cannot make one for the format it declares
on its channel, the family is skipped before Apostra calls your agent at all,
including the sandbox account setup, and it spends none of the run's budget.
The skip reason is `buy_creative_channel_unmatched`, and the family's result
names the format and the channel. That is Apostra's gap, never yours: nothing
in your product is wrong, there is nothing for you to change, and you do not
need to report it, because Apostra tracks these gaps itself. A later run tests
the family once Apostra can supply a creative for it. A run started with no
creatives offered at all skips such a family as `creative_sync_unsupported`
instead. That is a setup gap on Apostra's side, not yours either: nothing
changes on your side, and Apostra support supplies a creative.

This covers a channel Apostra makes no creative for yet (linear TV, cinema
and product placement), and a format it cannot make on any channel, such as
`audio_daast` or a carousel of video cards. The one buy
Apostra sends with no creatives on purpose is the [create without creatives
finding](https://docs.apostra.com/v3/certification.md#create-without-creatives-finding), which checks that
your agent holds such a buy in `pending_creatives`, and it is cancelled again.

A buy Apostra placed without a creative under its earlier rule keeps its
result, and the result says the buy had no creative: its reporting result stays
inconclusive and never fails, because a buy with no creative cannot deliver. A
buy your agent rejected, or an agent that dropped our context, still failed.

### Spend stays within the budget

Certification checks that your agent, not Apostra, keeps spend inside the budget
it accepted. Each certification buy is a small probe, and the check applies from
the day it ships, with no report-only period, to Apostra's own sales agents on the
same terms as yours.

**Threshold.** For a buy booked on a fixed CPM (`pricing_model: "cpm"` with a
`fixed_price`), Apostra prices the impressions its tracker counts at that CPM,
in the currency the buy was booked in. Spend above the package budget plus 20%
fails the use case. Spend within it passes once the tracker has seen the buy
serve. A buy booked on any other pricing is not judged, because its spend cannot
be worked out from impressions.

**Usual causes.**

* The package has more than one ad-server object behind it, and each can spend
  the full budget, so the budget is spent twice.
* A cap is applied as a daily limit that never reaches the total.
* The agent accepts a package it cannot cap and leaves it to serve.

**Next step.** Make the objects behind a package unable to spend more than the
package budget together. For a package you cannot cap, refuse it, or pause it,
and say so with an AdCP status or error rather than leaving it to serve. Report
each package's effective budget as you read it from your ad server, counting
every object behind the package.

### Create without creatives finding

AdCP treats a media buy created with no creatives as valid. A buyer can create
the buy first and assign creatives later. Your agent accepts the buy and holds it
in `pending_creatives` until creatives are assigned and approved. AdCP 3.3 keeps a
buy with no creatives there: no package can begin delivery without creative
coverage, and `pending_start` is for a buy whose creatives are assigned and
waiting on review or a start date. An agent that refuses such a create turns away
a booking AdCP says is fine, and the buyer sees a failed booking instead of a buy
that is waiting for its creative.

**What Apostra sends.** Apostra sends your agent one extra `create_media_buy` in a
run. When the run has created a buy, it books the product, pricing option, account
and budget your agent has just accepted. When the run has created no buy (none of
your products could be planned for a tracked family, or each was skipped), Apostra
sends it on its own, on the cheapest product it can book. Either way it is a single
package at the smallest budget the product allows, with one difference: no package
carries `creative_assignments`, and Apostra syncs no creative for it. The flight
starts a day after the call, so the buy cannot start. The probe never needs a
product's formats, channels or tracker support, so a product Apostra cannot plan a
tracked family for can still carry it.

**When Apostra cannot send it.** If none of your products can carry the buy, Apostra
records the result as inconclusive with the skip reason `no_probe_product`; see the
[skip reasons](https://docs.apostra.com/v3/certification.md#skip-reasons). That is not a failure of your agent. When
Apostra cannot send the probe, a result that already passed stands: it is not replaced
by an inconclusive one.

**How often.** Each probe books a real buy on your agent, so Apostra does not send
one on every run. It sends one when your agent is first certified, when the
capabilities or AdCP version it declares have changed since its last probe, and
when its last probe did not pass (so a failed or inconclusive probe is tried again
on the next run). After a pass it sends one again once a week. It never sends one
on the runs that certify Apostra's own staging embedded sales agent for a release.

**What your agent must do.** Accept the create: return a `media_buy_id` and report
the buy `pending_creatives`. The check reads the status your agent itself gave in
its answer.

**What a pass changes for buyers.** A passing result is the evidence Apostra uses
to book at once a buy whose only creatives are still in your agent's review. On an
agent that has passed, that buy is booked with no creative and each creative
attaches when your agent approves it, so the buyer does not lose flight days to the
review. On an agent with no passing result for an inventory source the buy routes
to (a failed or inconclusive probe, or no probe yet), Apostra holds the buy until
your agent has reviewed a creative, because some agents refuse a create with no
creative for good. The latest probe decides, so a probe that later fails returns
your agent to holding. See [When every creative is held](https://docs.apostra.com/v3/creative-sync-outcomes.md#when-every-creative-is-held).

**Apostra's embedded sales agent.** A source served by Apostra's embedded sales agent
is not probed. The embedded sales agent declares, in its `get_adcp_capabilities`
response, whether the ad server behind each source accepts a create with no creatives
(`ext.scope3.create_without_creatives`, with the release that declared it), and Apostra
reads that declaration. AdCP has no field for it yet; Apostra has proposed one
([adcontextprotocol/adcp#8723](https://github.com/adcontextprotocol/adcp/issues/8723)).
A source whose embedded sales agent has declared nothing is judged by its certification
result, as any other source.

**What fails.** The check fails, and the provider owns the fix, when:

* your agent answers the create with an error that says no, for example that every
  package needs a creative;
* your agent returns a buy and reports it `rejected` or `canceled` straight away;
* your agent reports it `active`, `paused` or `completed`: a buy with no creatives
  cannot be running or finished;
* your agent reports it `pending_start`: that tells the buyer nothing is missing,
  when the buy cannot start without creatives; or
* your agent reports a value AdCP does not define as a media buy status.

The result names the status your agent reported and what AdCP expects. For an
error, it shows your agent's own error code and message as it sent them, cut to
400 characters with links and credentials removed.

**What is inconclusive.** Apostra does not count anything that is not your agent's
answer as a failure: a timeout, an agent that is unavailable or rate limited, a
credential or configuration fault, a failure on Apostra's side before the call
reached your agent, a create your agent holds for a decision, and a create whose
answer gave no status. When the answer gave no status, a status your agent gave the
buy on a read before Apostra cancelled it settles the result. The probe is tried
again on the next run.

**The test buy is always cancelled.** Apostra records that it owes your agent a
cancel before it sends the create, then cancels the buy as soon as your agent
answers. If your agent does not confirm the cancel, Apostra tries again with
growing waits, up to twelve times, until your agent confirms the buy ended or says
it holds no such buy. A cancel Apostra cannot get confirmed within 12 hours of
sending the buy is raised. It is raised as the finding
`certification.probe_buy_not_cancelled` on your Agent page when your agent refused
the cancel or kept the buy, and to Apostra's own team when Apostra's attempts could
not be sent or answered. The buy carries no creative and starts a day after it was
sent, so it cannot deliver in the meantime.

**Severity.** This is a finding today. It shows as an attention finding on the
Agent page, and it stops nothing: it never makes a use case fail and never
withholds a certification pass. Whether it becomes required is a later decision,
which this page will announce before it takes effect. It applies to Apostra's own
sales agents and to third-party agents on the same terms. A run that created no
buy sends no such create.

**What is not judged.** Only your agent's answer to the create is judged. A buy
your agent accepts and rejects later, after Apostra has cancelled it, is not seen.

**Next step.** Accept a `create_media_buy` whose packages carry no
`creative_assignments`. Hold the buy in `pending_creatives` and start it once
creatives are assigned and approved. Accept a cancel for a buy that carries no
creative. The finding clears the next time a probe is sent and your agent accepts
it.

### A pause skips finished packages

Certification checks that your agent can pause a buy in which one package has
already finished. Each certification buy for a tracked use case books two
packages on the same product. The first flies for one hour from the buy's start.
The second starts five minutes after the first ends and runs to the end of the
buy. Three hours after the start, once our tracker has heard the buy serve,
Apostra pauses the buy, so the pause reaches a package that has finished and one
that is still live. Two grace periods after the pause, Apostra resumes it.

The check passes when all of these hold:

1. **The pause succeeds.** Your agent accepts the pause. A refusal fails the
   check and the result shows your agent's own error code and message. A pause
   that is held for approval, or that your agent never answers, is
   inconclusive. The pause and the resume are sent the way a buyer sends them,
   with the optional `push_notification_config` callback present. This is so
   even when your agent lists `tasks_get`, which is when Apostra otherwise
   leaves the callback off. AdCP defines the callback, and the version field on
   the request envelope, as optional, so your agent must accept an update that
   carries them. A refusal that names either field fails the check, and the
   result says which field and links to
   [Takes buy corrections](https://docs.apostra.com/v3/agent-requirements.md#takes-buy-corrections).
   Accept the update and ignore a field you do not use, rather than treating
   every top-level field as a change to make.
2. **Your agent reports `paused`.** On its next read after it accepted the
   pause, `get_media_buys` reports the buy `paused`. Apostra asks for that read
   soon after the pause. Any other status fails the check, and so does no read
   within 30 minutes of the pause (inconclusive).
3. **Serving goes quiet.** After the channel's grace, our tracker hears no
   impression until the resume.
4. **The resume restarts serving.** Our tracker hears an impression within the
   grace after the resume. A refused resume fails the check.

**A product whose minimum spend is above USD 5 books one package.** A second
package would take the buy past the USD 10 per-buy cap, so the buy has one
package and no finished package for a pause to skip. Apostra still pauses it,
after the same three hours, and resumes it two grace periods later. The pause
check does not apply, and the result says the buy has one package. The stop and
resume checks apply as usual, and the stop check also needs your agent to accept
the pause and report the buy `paused` on its next read. A refused pause fails
the stop check, with your agent's own error code and message.

A use case that our tracker judges is never certified without the stop check
judged. A buy that was never paused, such as one booked before this check
existed, shows the stop check as not yet judged until Apostra books a new
certification buy for it.

This is the case that failed on 20 October on an embedded agent: a pause was
sent to every package, including one its ad server had already closed, and the
whole pause was reported as failed. The buy then showed `active` with every live
package paused.

**Usual causes.**

* The agent tries to pause an ad-server object that has finished and reports the
  whole pause as failed when that one refuses.
* The agent accepts the pause but pauses only some packages, so the buy keeps
  serving.
* The agent reports the buy `paused` before the ad server stops serving, or
  keeps reporting it `active` after it has.
* The resume re-enables a package that has finished and fails.

**Next step.** On a pause, act on the packages that can still serve and skip any
that has finished (`canceled`, or its `end_time` has passed). Report the buy
`paused` once every package that can still serve is paused. A resume must
restart the packages the pause stopped. The finding clears the next time a
certification buy passes.

### Deleting an audience stops delivery

Certification checks that deleting an audience on your agent stops the packages
that use it. It applies to an agent that declares a partner route for audiences:
`media_buy.audience_activation` in `experimental_features`, with a route in
`media_buy.audience_targeting.supported_activation_methods`. See
[Deleting an audience stops the packages that use it](https://docs.apostra.com/v3/agent-requirements.md#deleting-an-audience-stops-the-packages-that-use-it)
for the requirement.

**How it runs.**

1. Apostra binds a certification audience on your certification account,
   through the partner route your agent declares.
2. It books a package that excludes that audience in `audience_exclude`, and
   waits until our tracker hears the package serve.
3. It deletes the audience with `sync_audiences` and `delete: true`.

The check uses an excluded audience because an audience of certification ids
matches nobody: a package that targets it never serves, so there would be
nothing to see stop. A package that excludes it serves normally. It is also the
case that matters most, because an agent that drops a deleted exclusion and
keeps serving reaches the people the buyer asked to leave out.

**The result.**

* **Passes** when, once the channel's grace has passed after the delete, our
  tracker hears no impression on that package. The grace is the same as for a
  pause: 2 hours for display; 6 hours for video, audio and CTV; 24 hours for
  DOOH.
* **Fails** when our tracker still hears impressions on the package after the
  grace.
* **Is inconclusive** when the package never served before the delete.
* **Also reported:** whether your agent reports the package with
  `canceled: true` on `get_media_buys` after the delete. This is shown, but it
  does not pass the check on its own.

**Status.** The check is report-only. It never becomes a blocker, and it does
not stop certification or buying. It is not yet run for any agent: it starts
once Apostra holds a certification dataset on your agent's partner route. What
a pass unlocks is described in the requirement linked above.

**Next step.** When you receive `delete: true` for an audience, stop every
package whose targeting names it in `audience_include` or `audience_exclude`,
and report each one with `canceled: true` on your next `get_media_buys` read.

### Live creative changes finding

Buyers change the creatives on a live buy: they add one, take one off and swap
one for another. Certification does the same on its test buy, so Apostra learns
how your agent behaves before a buyer meets it.

**What Apostra sends.** Once the pause and the resume are done and your agent
reads the buy `active`, Apostra sends up to three changes, one at a time, each as
a package update that carries only the package's complete `creative_assignments`
and nothing else. The buy holds the first certification creative from the start.
Apostra needs a second creative of the same format that the run offered. It
syncs that creative to your agent before a change names it.

| Step | What the package holds after it | The action your agent declares |
| - | - | - |
| Attach a second creative | both creatives | `update_creative_assignments` |
| Detach it again | the first creative | `remove_creative` |
| Replace the first creative | the second creative | `replace_creative` |

The order keeps at least one creative on the buy at every point. The change goes
to the package that can still serve, the second of the two.

**Each change your agent declares is sent.** An action in your `available_actions`
(or `valid_actions`) is declared, in any mode. Apostra reads the declaration from
your agent's latest `get_media_buys` answer with the code Apostra's own write gate
reads, so the two agree. The change passes when your agent takes it. It fails when
your agent declared the action as `self_serve` and refused it, and the result
shows your agent's own error code and message. A change your agent declared with
conditions (`conditional_self_serve`), or that needs approval, and then refused or
held, is inconclusive: a test buy may not meet the conditions.

**Each change your agent leaves out is sent once, to see it refused.** When your
agent sent an action list and the list leaves a change out, the change is not
supported, and Apostra sends it once anyway. It passes when your agent refuses it
with an error code, such as `ACTION_NOT_ALLOWED`. Apostra reads the code its
storefront relays to a buyer, which can be its own code for the kind of failure
(a refusal of the change as a request reads as `INVALID_REQUEST`), so the result
may show a different code than the one your agent sent. It fails when your agent
accepts it, or answers with an error that carries no code or only
`INTERNAL_ERROR`. The
buy is not left worse off if your agent accepts: both creatives fit the product,
and the steps that follow continue from whatever your agent now holds. A change
the agent could not answer now (`SERVICE_UNAVAILABLE`, `RATE_LIMITED`) is
inconclusive.

**An agent that sent no action list is not probed.** Apostra lets creative
changes through to an agent that declares nothing, so there is no refusal to
expect. [Creative changes declared](https://docs.apostra.com/v3/certification.md#creative-changes-declared-finding)
reports that gap.

**What is not judged.** Apostra judges your agent's answer to each change. It does
not read the package's assignments back, so it does not confirm that an accepted
change shows on a later read: that part is not checked yet. A change your agent
holds for approval, or never answers, is inconclusive. So is a run in which no
second creative of the same format was offered, and a buy booked before
certification paused its buys.

**Severity.** This is a finding today. It shows as an attention finding on the
Agent page when a change your agent declared was refused, or a change it left out
was accepted, and it stops nothing: it never makes a use case fail and never
withholds a certification pass. Whether it becomes required is a later decision,
which this page will announce before it takes effect. It applies to Apostra's own
sales agents and to third-party agents on the same terms.

**Next step.** Take the creative changes you declare, or stop declaring the ones
you do not take by leaving them out of `available_actions`. For a change you
leave out, refuse it with an error code that says it is not supported. The
finding clears the next time a certification buy is judged.

### Context your agent must hand back

AdCP has your agent return, unchanged, the `context` object a request carries,
and certification checks that it does. During a certification run:

* Every call Apostra makes to your agent carries a `context`:
  `sync_accounts` for the sandbox account, `get_products` for a brief,
  `sync_creatives`, `create_media_buy`, and the `get_media_buys` read each
  evaluation makes. Each response must hand that `context` back unchanged,
  including an error response and a `submitted` or `working` answer.
* `create_media_buy` carries `{ "storefront_media_buy_id": "<Apostra's id>" }`.
  `get_media_buys` must return the buy with that same `context`.
* Each package of the buy carries `{ "storefront_package_id": "<Apostra's id>" }`.
  The `create_media_buy` response and `get_media_buys` must return each package
  with its own package `context`, on the package that books that product. A
  `submitted` create carries no packages yet, so they are checked on
  `get_media_buys` instead.

Values are compared as JSON, so a number you return as `1.0` instead of `1`
still counts as unchanged. Keep every key, including any whose value is
`null`. The check fails if any response leaves its `context` out or changes it;
the result names the calls and, for each, the keys Apostra sent that your agent
dropped or changed and how many keys it added, for example "The seller did not
echo the context unchanged on: sync\_accounts (live\_certification\_request\_key
changed; 1 key added)." The result never quotes what your agent returned. The
run's session carries those calls, so you can read the request and response
Apostra judged, with the values (see [Read a run and the calls Apostra made to your
agent](https://docs.apostra.com/v3/certification.md#read-a-run-and-the-calls-apostra-made-to-your-agent)).
While your agent has not accepted or reported
the buy, cannot be reached, or sends a response Apostra cannot read, the check
waits instead of passing. A call that did not echo during a run keeps that use
case failed for the run; `get_media_buys` is read again on each evaluation, so a
fix there passes on the next one.

### Assignment operations finding

AdCP 3.2 gives `sync_creatives` an `assignment_operations` list: `assign`,
`unassign` and `replace`. A `replace` swaps one creative on a package for another
in one atomic step, and it is how a buyer changes a creative that is already
live. The older `assignments` list is deprecated in its favour. The `CREATIVE_LIVE_UPDATE_UNSUPPORTED` error that AdCP 3.3 defines tells a buyer to sync the change as a
new creative and swap it in with an `assignment_operations` `replace`.

**What AdCP requires.** The `sync_creatives` request schema of AdCP 3.2 defines
`assignment_operations`, and AdCP lists no capability a seller can decline it with.
Later releases add `supports_assignment_merge`, which covers only the separate
`merge` operation.
AdCP does not say in so many words that a sales agent must take it. So Apostra
treats a refusal as a gap, reports it, and requires nothing.

**What Apostra sends.** Once the creative id probe has put a copy of the buy's
creative on a package of the test buy, which needs no serving, Apostra syncs your
agent a second copy of that creative under a plain id and sends one
`sync_creatives` request on the same test buy. It carries no creatives and one
operation: a `replace` on that package, swapping the first copy for the second,
with `validation_mode: strict`. The buy keeps the creative it was booked with.
When the creative id probe did not leave a copy on the package, there is nothing
to replace and the replace is not sent. It sends the request only
to an agent Apostra calls at an AdCP release whose `sync_creatives` request
defines `assignment_operations`. An agent called at 3.1 is not sent it. The run
records what your agent answered: that it took the replace, or the error code,
recovery and field of its refusal.

**What is flagged.** A refusal shows as one of two findings, so a refusal that
sends the buyer to the same operation reads differently from one that does not:

* **Takes the assignment\_operations replace it advises.** Your agent refused the
  replace, and it names `assignment_operations` as what to send instead, in that
  refusal or in an answer on recorded traffic in the last 14 days. We look for the
  name as one whole identifier in an error's `message`, `suggestion` or `details`,
  so `not_assignment_operations` does not count. A buyer that follows the advice
  is refused again.
* **Takes an assignment\_operations replace.** Your agent refused the replace and
  does not name it as what to send. This is reported separately and is
  informational in kind, because AdCP does not require it in so many words.

**What is not judged.** An agent called below AdCP 3.2, a run in which no second
creative reached your agent, an answer your agent did not give in time, and a
transient refusal (`SERVICE_UNAVAILABLE`, `RATE_LIMITED`, `TIMEOUT`) are not judged. A
refusal with no code, or only `INTERNAL_ERROR`, is judged, and the result says it
must carry a code a buyer can act on.

**Severity.** These are findings today. They show as attention findings on the
Agent page and stop nothing: they never make a use case fail and never withhold a
certification pass. Whether either becomes required is a later decision, which
this page will announce, with the date, before it takes effect. They apply to
Apostra's own sales agents and to third-party agents on the same terms.

**Next step.** Take an `assignment_operations` `replace` on `sync_creatives`. If
you cannot yet, do not tell a buyer to send one: change the refusal so it names
only what you accept. See
[A refusal suggests only what your agent accepts](https://docs.apostra.com/v3/agent-requirements.md#a-refusal-suggests-only-what-your-agent-accepts).
The findings clear the next time a certification buy is judged.

## Test buy size

Each certification buy is capped at USD 10, and each run is capped at USD 50.

Apostra books the test buy in your own currency, at your own prices. It certifies
any pricing option in a currency Apostra can settle in: USD, EUR, GBP, JPY, CHF,
CAD, AUD, NZD, CNY, HKD, SGD, SEK, NOK, DKK, PLN, KRW, INR, MXN, BRL and ZAR. A
USD option needs no conversion. For any other currency, Apostra converts the
USD 10 cap at its daily locked exchange rate, the same rate it uses to quote and
book buys that day, and rounds it down to the currency's smallest unit, for
example EUR 9.20 at 0.92 euros to the dollar, or JPY 1,513 at 151.37 yen. The USD
50 run cap counts every buy in USD at those same rates, so a run that mixes
currencies still stops at USD 50 in total. The result records the currency, the
rate and the day the rate was locked on.

A buy's budget is the smallest pricing option on the product in one currency: a
flat-rate option uses its fixed price, any other option uses its minimum spend
per package, and an option with no minimum uses the converted cap. Apostra never
rounds a minimum down. A product whose smallest option is above its converted cap
is skipped as `budget_exceeds_per_buy_cap`. When several options qualify,
Apostra uses an option that fits its cap before one that does not, then a
fixed-price option before an auction, then a USD option, then the option with
the smallest value in USD at the locked rates.

An option with no `fixed_price` is an auction, and AdCP requires each package
booked on it to carry a bid. Apostra bids the median of recent winning bids the
option publishes (`price_guidance.p50`), or its `floor_price` when that is
higher or there is no median, in the option's own currency. The bid is the price
per unit; the budget still caps what the buy spends. Apostra never books an
auction option that has neither a floor nor a median, and a product whose
options are all like that is skipped as `seller_auction_bid_unavailable`.

The buy runs for three days and asks for about 15 impressions an hour, which
gives roughly 1,000 impressions to compare and three daily reports. A tracked
buy books [two packages](https://docs.apostra.com/v3/certification.md#a-pause-skips-finished-packages)
and both count against the per-buy and per-run caps:

* A product that sets no minimum books two packages at half the cap each, USD 5
  each and USD 10 in total, splitting the per-buy cap between them. In another
  currency each half is rounded down to the currency's smallest unit.
* A product whose smallest minimum is at most half the cap (USD 5 or less) books
  each package at that minimum, so the buy books twice the minimum in total.
* A product whose smallest minimum is above half the cap (USD 5) books one
  package at that minimum, and its buy is not judged on the pause.

Your sandbox decides whether money moves. Apostra does not pay for test impressions.

## When Apostra starts a run

Once `certificationRequested` is `true` (**Allow certification buys** is on), Apostra starts a run on each active
Source that uses your agent, using Apostra's own certification buyer and
creatives. Each Source gets one run at a time, and every run carries the reason
it started.

| Reason | When it applies |
| - | - |
| `certification_requested` | You allowed certification buys and the Source has not passed since. Apostra also starts again for this reason after a run that failed or ended with nothing to judge |
| `evidence_expiring` | The Source's latest pass is within four days of leaving the seven-day evidence window, and the previous run has finished |

Apostra does not start a run beside one that is still collecting evidence. A
run is collecting while its three-day buy is flying, and after that until it
has a passed or failed result, for at most 14 days after the buy was planned.
A Source that passes is re-certified about every two weeks while it stays
requested. A Source whose run failed is tried again once that run's buy has
finished flying and the run is at least 24 hours old. When your agent refuses
the certification creative with an error that AdCP says needs a changed request
(its recovery is `correctable` or `terminal`, for example `VALIDATION_ERROR`,
`CREATIVE_REJECTED` or `CREATIVE_VALUE_NOT_ALLOWED`), the use case ends at once
as `creative_sync_failed` with your agent's reason, instead of waiting a day to
send the same creative again. A creative Apostra cannot send for this product
at all ends the same way, as `creative_not_sent`. A test buy that Apostra could
not send for a reason that can clear by itself (for example your agent was
rate limiting or unavailable, or did not answer) no longer holds the Source 24
hours after that failure, and the next run starts with a fresh buy. A test buy
with no recorded failure still holds it. A run waiting for you to approve the certification
creative also holds the Source, for the five-day wait at most; see
[Certification-ready sandbox](https://docs.apostra.com/v3/certification.md#certification-ready-sandbox).

Once a run's buy has finished flying, nothing more is tested in it. A use case
that is still inconclusive then changes only if a late report settles a check
that waits on reports. A check that needs the buy itself, such as the stop
check on a buy that was never paused, cannot be judged any more. The run still
holds the Source until 14 days after its buy was planned. Apostra then starts
the next run by itself, once the Source's latest pass, if it has one, is three
days old, as `evidence_expiring` above describes. Apostra judges a run's
passing use cases again every hour while the run holds the Source, so after a
run with a passing use case the next run starts about 17 days after the buy was
planned. While you wait, the use case's finding and the
`certification.no_passing_use_case` finding say that the run's buy has finished
serving and give the date the next run can start. They stop saying
certification is running.

A new run cancels the test buys of earlier runs that it replaces: a format it
buys again, and a format it no longer plans because your agent stopped offering
it. Apostra sends no cancel for a test buy your agent has already reported
`completed` or `canceled`, since it has already ended; the run only records it
as ended.

A Source whose run cannot start gets no run and no test buy; see
[When a run cannot start](https://docs.apostra.com/v3/certification.md#when-a-run-cannot-start). A run that
ends with nothing to judge, for example because every family was skipped, is
also retried no sooner than 24 hours later, never every hour.

When a Source's runs keep ending the same way, Apostra waits longer between
them. If every family that counts toward certification was skipped for the same
reasons as in the run before, and your agent's capabilities and products are
unchanged, the wait doubles with each such run: 24 hours, then 48, then 96,
up to seven days. It starts over at 24 hours as soon as your agent's
capabilities change, or you turn Allow certification buys off and on again. A
change to your agent's products is seen by the next run, which then starts the
count over; to have Apostra look sooner, ask Apostra support to start a run. Apostra never stops trying a Source that asked for certification;
it only spaces the runs out.

Apostra does not yet start a run when your agent's products or capabilities
change. After a change, the next run starts when the evidence expires, or when
Apostra support starts one.

### When a run cannot start

Sometimes Apostra picks a Source and cannot start a run, so there is nothing to
wait for. Apostra records the attempt, and every read of your agent says so
instead of saying certification is running: the agent's `stuckOn` step,
the `certification.no_passing_use_case` finding and the agent's
`certificationStage` all name the blocked start, the Source Apostra tried
through, and whose move it is. A Source's own read and a storefront's
`publish_validation` readiness step say the same. The blocked start clears the
moment a run begins on the Source, from any start, and also when you turn
**Allow certification buys** off. Once an earlier run has recorded results for
your agent, the agent's reads lead with those results instead, and the finding
adds that Apostra's latest attempt to start another run could not, so no read
says that no run exists while results show.

| Whose move | When it applies | What the finding says |
| - | - | - |
| Your agent's developer | Your agent rejected or failed a call Apostra made to it, for example it answered `get_adcp_capabilities` with HTTP 400, so the storefront had no products to buy; or a step of your sandbox account failed (see [Your sandbox account](https://docs.apostra.com/v3/certification.md#your-sandbox-account)) | The call Apostra made and your agent's own answer, quoted as untrusted text, and what to change. The stage reads `waiting_on_you` |
| Apostra | Apostra's own dispatch, its test buyer setup or an internal error stopped the start, and none of the calls Apostra made to your agent during the attempt failed | That the problem is on Apostra's side, with nothing for you to change. The stage reads `waiting_on_apostra` |

When Apostra cannot start a run because the storefront had no products from
your agent, it records your agent's answer to every call that failed during that
attempt: the call, the HTTP status your agent answered with (or that it did not
answer at all), and the words it used, with secrets and your endpoint's host
removed and the text cut to 400 characters. Your agent's answer is what decides
whose move it is, so an attempt that was stopped by a failed call to your agent
is yours to fix even when Apostra recorded no other health reading of your
agent, and an attempt where every call to your agent succeeded, or none was
made, is Apostra's. The answer stays on that attempt: it stops showing the
moment a run begins on the Source, and the next attempt records its own.

When a step of your sandbox account stopped the start, the attempt also records
what Apostra saw at that step, so the finding names the one cause behind
`seller_sandbox_account_failed` and the change that clears it, instead of
every cause the skip reason covers:

| What Apostra saw | What the finding says to change |
| - | - |
| Your tools do not include `sync_accounts`, `list_accounts`, or either | Implement the tools it names and list them in `get_adcp_capabilities` |
| Your `account.supported_billing` lists none of `agent`, `operator` or `advertiser` | Add one of them, and accept `sync_accounts` with that billing. The finding quotes what you list |
| Your agent refused the `sync_accounts` request | Change your agent so it accepts the request. The finding quotes your agent's own error code and message, as untrusted text, and the billing Apostra asked for |
| The `sync_accounts` request did not complete, for example it timed out or never reached your agent | Answer `sync_accounts` in time, on the credential the Source uses. The finding quotes the failure Apostra recorded; ask Apostra support if it names Apostra |
| Your agent's answer held no account for the brand and operator Apostra asked for, or returned one that is not active, not marked sandbox, or has no `account_id` | Return the account active, with `sandbox: true` and an `account_id`. The finding names what was wrong with the account |

Every value Apostra records from your agent's answer is cut short and has
secrets, URLs and addresses removed first. An attempt Apostra made before it
kept this detail reads as the skip reason does in
[Skip reasons](https://docs.apostra.com/v3/certification.md#skip-reasons), until the next attempt.

Apostra tries the Source again by itself 24 hours after the blocked attempt,
and each day after until it works, so a fix at your agent is picked up within a
day with nothing for you to do. There is no call that retries sooner; ask
Apostra support to start a run if a day is too long.

## How long it takes

Plan for about three days of serving, plus the reports that are due after the
flight. Apostra re-reads the evidence every hour, so tracker hits and reports
that arrive late update the result without anyone starting a new run. Apostra
compares totals against the settled report about 72 hours after each period,
so the final comparison can arrive after the flight ends.

## Results

Each use case and product family has one latest result. Most of a run is judged
within hours of the buy going live, so you see the immediate checks as they land
and then wait only for reporting. The flight stays three days.

The agent read shows the results of the runs that count for your agent: runs
on an active Source that uses it, or on a pending Source of your own
organization, which certification buys through before it goes live, taken
since the Source was connected to your agent.

Each run buys a rotating handful of product families, so the read shows each
Source's newest run that recorded a result, plus any pass from an earlier run
that still counts toward certification. An earlier run's other results stay on
that run's session (see
[Read a run](https://docs.apostra.com/v3/certification.md#read-a-run-and-the-calls-apostra-made-to-your-agent)),
and the `certification.no_passing_use_case` finding says how many, for
example "2 older results from earlier runs are on their sessions." A failure
an earlier run recorded comes back when a later run buys that family again.
A source's readiness counts failed and inconclusive results by the same rule.

| Result | What it means | What to do |
| - | - | - |
| Passed | Every check that applies passed on live traffic | Nothing. It stays valid while evidence stays fresh |
| Failed | A check failed, for example macros arrived literal, two report periods were missed, or the counts disagreed beyond 20% | Fix the cause named in the reason. The use case recovers when live traffic passes again |
| Inconclusive | No check failed, but Apostra could not finish judging. Either evidence is still arriving, the family was skipped before a buy, or Apostra could not send its buy yet | Wait for the next hourly update. If the reason is a skip reason, see below |

Each use case's result on the agent read carries `displayName`, the use case's
name as the table in [Use cases](https://docs.apostra.com/v3/certification.md#use-cases) gives it, and
`gating`. `gating` is `true` when the result decides certification and `false`
for a use case that is shown beside the others but never counts: a pass there
certifies nothing and a failure there fails nothing. Today those are the compact
lifecycle, the accounts use case and the create-without-creatives probe. The
Overview page marks each use case as counting toward certification or not from
this field, so a **Passed** on a use case that does not count is never a
certification pass.

Each use case's result also carries `failedCheck`, the name of the
first check that failed, on a failed result, and `skipReason`, the skip reason
code, on a result from a family that has no buy: one that was skipped, or one
whose buy Apostra tried to send and could not before it reached your agent.
The second kind keeps waiting for its buy. When Apostra did not send its
creative, `skipReason` is `creative_not_sent` and the reason is the cause
Apostra recorded. Otherwise its `reason` first says that Apostra could not send
the buy and the date it tries again by itself, no sooner than a day after the
failure, then what the skip reason means, what to change and the detail Apostra
recorded; when the attempt recorded no skip reason, `skipReason` is
`buy_never_sent`. The use case's finding on the agent shows its newest result,
so a later run that waits on your agent replaces an earlier failure as the
finding, and the earlier failure stays on its run.

When no family that counts toward certification has a buy in its latest result,
because each was skipped or Apostra could not send its buy, the
`certification.no_passing_use_case` finding says so. It names the skip reasons
and how many families each stopped, says whose move it is, and gives the date
Apostra tries again. It does not say that certification is running, because no
certification buy is serving. The owner is your agent's developer when any of
those skip reasons is yours to change (see
[Skip reasons](https://docs.apostra.com/v3/certification.md#skip-reasons)), Apostra when the rest are
Apostra's, and nobody when a later run covers them all.

When a use case did not pass because of one of its checks, the reason names that
check and what Apostra saw. A failed use case gives the first check that failed,
for example "The click\_fires check failed: No click reached our tracker in 1000
impressions." An inconclusive use case gives the first check that has no result
yet, for example "Waiting on the report\_cadence check: The seller has not yet
produced a decided reporting period." Before any impression has reached
Apostra's tracker, the macro check waits with "No impression has reached our
tracker yet, so there are no macro values to judge." It judges macros from the
first impression on."

### See each check as it lands

Each use case's result on the agent read also carries `checks`: the checks that
apply to it, in the order Apostra judges them, taken from its latest evaluation.
Each check has:

| Field | What it says |
| - | - |
| `check` | The check's name, such as `buy_goes_live` or `report_cadence` |
| `result` | `passed`, `failed`, or `waiting` when Apostra has not been able to judge the check yet |
| `detail` | Apostra's sentence about what it saw on your agent's certification buy, at most 300 characters. A host that reads it as a model receives it fenced as untrusted text |
| `gating` | `false` for a check that is a finding only, such as live creative changes and a buy created with no creatives. It is shown but never fails a use case or withholds a pass |
| `expectedBy` | On a waiting check that needs the flight's reports (reports arrive on time, and reports agree with our tracker), when Apostra expects to judge it |

The checks that need only a few hours of serving are judged within hours: the buy
goes live, your agent echoes our context, macros are replaced, clicks fire,
spend stays within the budget, the pause, stop and resume work, quartiles fire,
and live creative changes are taken. Only the reporting checks need the flight:
whether reports arrive on time, whether they agree with our tracker, your ad
server's delivery and the settled report. `expectedBy` is the end of the
three-day flight plus about 72 hours, the delay after which the settled report
is due (see [How long it takes](https://docs.apostra.com/v3/certification.md#how-long-it-takes)).

So six hours into a run, an agent that has passed every immediate check shows
them as `passed` and the reporting checks as `waiting` with the date they are
expected. The use case's finding and the agent's next step say it in one
sentence, for example "7 of 10 checks passed on ctv\_video; waiting on reporting
until 9 November." The count covers the checks that decide the use case.
The sentence leaves out a use case that was skipped before a buy and one that
waits for your agent to approve a certification creative. `failedCheck` and
`reason` are unchanged.

A skipped family never produced a buy. It is shown as inconclusive with its skip
reason. It does not fail the use case, stops no running buys and cannot certify.
A later run judges the family again. A family whose buy Apostra could not send
yet is shown the same way until Apostra sends it.

### Read a run and the calls Apostra made to your agent

Each live certification run is a session. Every use case result on the agent read
(`get` with `kind: "agent"`, in `liveCertification.useCases`) and every certification use case finding
carries the `sessionId` of its run, when you can read it (see below). From your Agents account, read it with `get` and `kind: "session"`,
or list your runs with `search` and `kind: "session"`. An Agents account reads only this session source,
`live_certification_run_v1`, so `search` needs no `filter.sessionSource`. A run is not a Murph
conversation: `get` with `kind: "conversation"` does not read it.

The events of a run are its steps, in the order Apostra recorded them:

* **Run started.** The products Apostra planned the run from. Apostra reads them from its own copy of
  your agent's catalog, so this step has no call to your agent.
* **Buy sent.** Apostra began sending the certification buy to your agent. It carries what Apostra sent
  and what your agent returned: the certification creative sync and the create, one call for each
  attempt. A buy sent again after a failed attempt is a new event with its own calls. When your agent
  answers a call asynchronously, the call still shows the request Apostra sent, such as the
  `create_media_buy` tool call, never the `tasks/get` or `tasks/result` poll, and its response is the
  last answer Apostra received: the task's result once your agent finished it.
* **Buy created.** Your agent accepted the buy. It carries what happens once the buy exists: later
  changes to it, such as the pause, and the callbacks your agent sends, such as a webhook.
* **Skipped.** Apostra did not send a buy for the use case, and why. A family is skipped at most
  once, so this event appears once.
* **Agent answer.** A request to your agent did not complete, with its status.
* **Evaluation.** A result for the use case and, when it did not pass, every check that failed.
  When the context check failed, it carries the calls it judged: each call whose response did not
  hand back the `context` Apostra sent, or the `get_media_buys` read that returned the buy without
  its create `context`. An evaluation is a new event when the result changes.

An agent whose provider no administrator had claimed when the run started has no Session for it.

A step that involved your agent carries its calls. Each call gives what Apostra sent, what your agent
returned, the HTTP status, how long it took and the error. Apostra removes its own credentials and the
values under keys that look like credentials, such as `token`, `secret` or `password`, and shows them as
`[REDACTED]`. A step shows at most
50 calls. When a step had more calls than it shows, its event carries `agentCallsTruncated: true`.
Apostra keeps the request and response bodies for 90 days; after that a call still shows its timing and
status, with no body.

A run is `active` while it is still collecting evidence, as
[When Apostra starts a run](https://docs.apostra.com/v3/certification.md#when-apostra-starts-a-run) describes: while Apostra is
sending one of its buys or waiting to, while a buy's three-day flight is running, and after that until
the buy has a passed or failed result, for at most 14 days after the buy was planned. A buy that already
failed a check stays `active` while it flies, because Apostra keeps judging it. A run is `closed` once
none of its buys is collecting: each was skipped, stopped or replaced, or has finished flying with a
result. Use `lifecycle` on `search` to list one or the other.

Beside the calls, a Session returns these facts about the run. Apostra holds them, and your agent did not
receive all of them:

* **The run.** Its id, your agent's name, whether it is `active` or `closed`, and when it was created and
  last updated. `search` also gives the number of use cases that passed, failed, are inconclusive or are
  still pending, and how many product families they cover. A run tests a use case on one or more
  product families. The use case counts as failed when any of its families failed, as passed when none
  failed and one passed, as pending while a family has no result, and as inconclusive otherwise.
* **Run started.** How many products Apostra read from its stored copy of your catalog, and the ids of the
  first 20.
* **Every step for a use case.** The use case and its family key.
* **Buy created.** The media buy id of the certification buy.
* **Skipped.** Why Apostra did not send a buy, in the words of the skip reasons below, with the error code
  and message your agent returned when it returned one.
* **Agent answer.** The status of the request that did not complete, with the error code and message.
* **Evaluation.** The outcome (passed, failed, inconclusive, or recorded without a result) and every
  check that failed, or else the first check still waiting, with what Apostra saw. A failed context
  check names each key Apostra sent that your agent dropped or changed, and how many keys it added;
  the calls it carries hold the values. When Apostra placed the buy without a creative, the evaluation
  says so.
* **Stopped or replaced.** That Apostra stopped the buy, or cancelled it because a newer run replaced it.

A Session does not return any other seller's prices, buyers or settings, or anything else that was never
sent to your agent. Apostra's credentials are removed.

Any member of the Agents account reads the runs of agents the account owns, whatever their role,
whichever seller's storefront the run used. A member reads exactly what is described above: the steps, the
calls Apostra made to your agent, with credentials removed, and the run's facts. No one changes or cancels
a run from here. An Operator or Admin decides whether runs start, with **Allow certification buys**, and a
Member cannot. The history starts
when your organization took the agent. Moving the agent between accounts of one organization keeps it. A
run that started before your organization took the agent, because Apostra staff assigned it to you or it
moved from another organization, is not shown. Archiving an agent does not remove its certification
sessions: you can still find and read them with `search` and `get` (kind `session`). The seller who
connected your agent does not read these sessions.

### See certification evidence on the Overview page

In an MCP host such as Claude or ChatGPT, ask to open your agent, or call `open_agent_page` with the
agent's `agentId`. The Overview page it opens carries the certification evidence, each item opening
to its full detail:

* **Live certification.** The latest result for each use case, named as the [Use cases](https://docs.apostra.com/v3/certification.md#use-cases)
  table names it, with its channel, when it was judged, the result of each check and, when it did not
  pass, the reason Apostra recorded. Apostra derives the use cases that apply from the agent's products
  and capability declarations, so you do not choose them. Each one is marked as counting toward
  certification or not. Only the ones that count decide certification. A use case that does not count
  can still show Passed, and that pass certifies nothing.
* **Manual test runs.** For a sales agent, the test plan (each test mode, whether it is available and
  why not) and the agent's recent manual test runs, with the outcome, the failed stage, who is
  accountable and the next step. These are the runs someone starts on purpose. Live certification runs
  separately and does not create one, so an agent can have no manual test runs and still show live
  certification results. A manual test never certifies the agent.
* **AdCP 4.0 readiness and capability declarations.** The same checks as
  [Getting ready for AdCP 4.0](https://docs.apostra.com/v3/adcp-4-readiness.md) and the declarations the agent makes, with what
  Apostra saw and how to fix each. A declaration reads **Declared** or **Eligible for testing**:
  it says what the agent claims and that Apostra can test it, never that the agent passed.
* **Allow certification buys.** Whether the owner has allowed certification buys. For an Operator or
  Admin of the Agents account, who can change the setting, this is a switch: turn it on or off and the
  page saves it with `save_agent`, then reads itself again, so what it shows is what Apostra saved. If
  Apostra refuses the change, the page shows Apostra's message. Anyone else sees only whether it is on.
* **Exemption.** When Apostra has exempted the agent from certification until a date, one line under
  the switch gives that date. Nothing is shown when there is no exemption or it has ended.
  See [See whether Apostra exempted an agent from certification](https://docs.apostra.com/v3/connect-an-agent.md#see-whether-apostra-exempted-an-agent-from-certification).

The page is a curated view of the same read `get` makes for the agent, shown to the same people who can read it.
It leaves out internal fields, such as source identifiers and the links to a run's diagnostics. Opening
it changes nothing; its one write is the switch. The page is available in Agents accounts. The text
Apostra writes for a result is in English whatever language the host uses. The Overview page is
described in full under [Open the Overview page](https://docs.apostra.com/v3/connect-an-agent.md#open-the-overview-page).

### Skip reasons

Skip reasons describe what stopped the buy before it was sent.

#### Your sandbox account

| Skip reason | What happened | What to change |
| - | - | - |
| `seller_sandbox_account_pending` | Your agent held the account for approval (`pending_approval`) or accepted `sync_accounts` as a task that has not finished | Approve the account or finish the task. Apostra checks again on the next run |
| `seller_sandbox_account_failed` | Your agent rejected the account, returned one that is not active or not a sandbox, returned no `account_id`, did not answer in time, or does not offer `sync_accounts` | Accept the test identity and return an active sandbox account with an `account_id` |
| `seller_operator_auth_unsupported` | No longer recorded for third-party agents. Certification runs agents that declare `account.require_operator_auth: true` on the credential you connected. Runs before 19 November 2026 keep this reason | Nothing. Run certification again |
| `seller_update_media_buy_unsupported` | Your agent does not list `update_media_buy` in its tools | Implement `update_media_buy` as AdCP defines it, accepting its optional request fields, and list it in your tools. A buy booked through your agent cannot be corrected without it |
| `sandbox_brand_unverified` | The certification advertiser has no linked brand | Nothing on your side. Apostra fixes its test advertiser |
| `sandbox_buyer_account_unavailable` | Apostra could not finish looking up its test buyer account in time | Nothing on your side. The next run tries again |
| `sandbox_unverified` | Apostra could not verify the sandbox account for another reason | Ask Apostra support |

#### Your agent's response to the buy

| Skip reason | What happened | What to change |
| - | - | - |
| `seller_creative_review_required` | Your agent held the certification creative for review and nobody approved it within the five-day wait. While the wait lasts, the use case shows a finding that certification is waiting for you to approve the creative | Approve the certification creative, or let your agent accept certification creatives without a manual review hold. Apostra skips only its own creative review, so your agent and ad server still apply theirs. See Certification-ready sandbox |
| `seller_sync_creatives_unsupported` | Your agent lists no `sync_creatives` in its tools, or answers a `sync_creatives` call as a tool it does not have, so Apostra cannot send it the certification creative | Implement `sync_creatives` as AdCP defines it and list it in your tools. A creative cannot reach your agent without it |
| `creative_sync_failed` | The certification creative could not be synced to your agent, or your agent rejected it. The result carries your agent's own message when it sent one. A creative that never left Apostra is skipped as `creative_not_sent` instead | Accept the creative, or fix the error your agent returned. When the result says Apostra built the creative to the format option as your product declares it, your agent refused a creative that fits its own declaration: see Accept the creatives your formats declare. Otherwise, if your agent's message says the creative's size or duration fits none of the formats your product declares, that is Apostra's creative and not yours: Apostra support offers one that fits |
| `creative_not_sent` | Apostra stopped its own certification creative before it left Apostra, so your agent never received it. The result carries the reason Apostra recorded | Nothing on your side. Apostra fixes it, and a later run tests the family. If the fix needs a change to a format your product declares, Apostra support tells you |
| `seller_format_cannot_carry_tracker` | The ad format Apostra chose for the product has no tracker slot, no VAST or DAAST wrapper path for a buyer impression tracker, and does not take a display tag as inline markup that can carry it | Add a URL impression-tracker slot named `impression`, `tracker_pixel` or `imp_pixel`. For hosted video or audio, add a `pixel_tracker` slot. For a display tag, declare `inline_markup` in the format's `supported_delivery_types` |
| `seller_approval_required` | Platform safety review held the buy, or the approval check could not run. Results from earlier runs can show the same reason as `approval_required` | Ask Apostra support. Nothing to change in your agent |
| `seller_<reason>` | Your agent refused the buy. The text after `seller_` is the refusal reason, for example `seller_all_sources_failed`. The result also carries your agent's error code and message when it sent them, and says so when no message came back | Read your agent's refusal and fix it. When no message came back, find the buy in your agent's own logs |
| `buy_<code>` | Apostra's buy was rejected with a validation error. `<code>` is the error code in lower case, for example `buy_validation_error` | Read the message in the result, or ask Apostra support |
| `buy_never_sent` | Apostra's buy never reached your agent: Apostra stopped it before sending it, Apostra's own dispatch ended before it contacted your agent, or the run was stopped first. When Apostra stopped it, the result carries the reason Apostra recorded | Nothing on your side. A later run covers it |

A creative sync failure is your agent's only when the certification creative
reached your agent. Apostra stops its own creative first when its creative sync
does not reach the Storefront, when one of Apostra's own checks refuses the
creative, or when the AdCP library Apostra uses cannot shape it for the formats
your product declares. The use case then reads `creative_not_sent` from that
attempt on, with the cause Apostra recorded, and its finding says to wait for
Apostra. Apostra staff are alerted. It does not replace an earlier pass of the
use case, and a later run tests the family again.

A refused buy is your agent's only when the buy reached your agent. When the
AdCP library Apostra uses refuses Apostra's own request, or cannot shape the
buy's format choice for your agent, Apostra stops the buy before sending it.
The use case then reads `buy_never_sent`, with the cause Apostra recorded, and
its finding says to wait for Apostra. Apostra staff are alerted.

#### Budget

| Skip reason | What happened | What to change |
| - | - | - |
| `budget_exceeds_per_buy_cap` | The smallest pricing option needs more than the USD 10 per-buy cap, converted to your currency at Apostra's daily rate | Offer a pricing option at or below the cap on a product Apostra can buy |
| `budget_currency_unsupported` | No pricing option with an id is in a currency Apostra can settle in | Offer a pricing option in a currency Apostra can settle in. See Test buy size |
| `exchange_rate_unavailable` | Your pricing options are in a currency Apostra can settle in, but Apostra has no locked exchange rate for it from the last seven days | Nothing on your side. Apostra restores the rate, and a later run covers it |
| `seller_no_pricing_option` | The product has no pricing option with a `pricing_option_id` | Give each pricing option an id |
| `seller_auction_bid_unavailable` | Every pricing option Apostra could book is an auction with no `floor_price` and no `price_guidance.p50`, so Apostra has no price to bid | Give the auction option a `floor_price` or a `price_guidance.p50`, or offer a fixed-price option. See Test buy size |
| `no_probe_product` | None of your products could carry the one buy Apostra sends with no creatives: each needs a pricing option with an id, in a currency Apostra can settle in, that fits the USD 10 per-buy cap and, on an auction, gives a price to bid | Offer a pricing option with an id, in a currency Apostra can settle in, at or below the cap on a product Apostra can buy |
| `budget_exceeds_run_cap` | Adding this family would take the run past USD 50 | Nothing. It keeps its place in the order, and a later run buys it |
| `run_budget_exhausted` | Earlier buys in the run used the USD 50 | Nothing. It keeps its place in the order, and a later run buys it |
| `certification_buys_off` | You turned Allow certification buys off before this family's buy was sent | Turn Allow certification buys on, and a later run covers it |

#### Agents that sell only through briefs

An agent that lists no wholesale products and declares the `brief` buying mode
in `media_buy.buying_modes` is certified through a brief. Declaring
`media_buy.supports_proposals` is not required: an agent that answers a brief
with products and no proposal is certified the same way, and an agent that
declares `supports_proposals: true` is certified through briefs too. Apostra's
standard briefs cover display with a tag, online video with a VAST tag, and
linear TV with a format your agent supports. Each has a USD 10 budget (or its
equivalent in your currency) and a three-day flight. Apostra buys a matching
offer within the cap. Linear TV is judged on seller-reported evidence because
the Apostra tracker cannot observe it.

Each brief goes to your agent under the sandbox account your agent set up for
the run, the same account Apostra's test buy and creative use. Apostra sends a
brief only for a channel your Storefront serves. A Storefront that serves
display only is sent the display brief and no video or linear-TV brief. If your
Storefront serves none of the covered channels, the run does not start and
says so.

| Skip reason | What happened | What to change |
| - | - | - |
| `buy_no_matching_proposal` | Your answer to the brief held no product that serves the use case | Return a product with the channel, creative kind and tracker path the brief asked for |
| `buy_brief_unavailable` | Apostra could not get an answer: your agent timed out, returned an error or answered incompletely | Answer briefs within 45 seconds with a complete response |

If Apostra cannot start a run at all because buyers cannot see the Source, it
says why: for example that the Storefront is not set up and what is missing, or
that the Source is not mapped to an agent. Fix that first; certification
reads the same view of the Source that buyers get.

#### Apostra's side

| Skip reason | What happened | What to change |
| - | - | - |
| `creative_sync_unsupported` | Apostra offered no certification creative for the family, so it did not place the buy | Nothing on your side. Apostra support supplies one |
| `buy_creative_channel_unmatched` | Apostra has no test creative for the format this family declares on its channel and cannot generate one, so it did not place the buy. This is a gap in Apostra's certification, not a defect in your product | Nothing on your side. Apostra supplies a creative for the format, and a later run tests the family |
| `adapter_storefront_unsupported` | The Source sits behind a managed ad-server Storefront, which does not take trusted sandbox buys | Nothing. This does not apply to third-party sales agents |
| `seller_storefront_unavailable` | The Storefront behind the Source is unavailable | Ask Apostra support |

#### The compact lifecycle

| Skip reason | What happened | What to change |
| - | - | - |
| `compact_lifecycle_not_runnable` | Your agent declares the compact lifecycle, and Apostra does not run its compact-lifecycle test yet | Nothing on your side. This does not affect your certification |

A product with no declared AdCP channels is skipped before any family is built
(`missing_channels`). That is a finding with the products named, not a failure.
Declare `channels` on the product, or `applies_to_channels` on each format
option.

## How certification is kept

Certification is continuous, and evidence has to stay fresh.

* **Fresh evidence.** Most checks need a pass from the past seven days. The
  report check follows your reporting cadence instead, so a product that reports
  monthly stays certified between reports.
* **Real buys count.** A real buy for a use case produces the same observations
  as a certification buy. While one is live, its traffic is the evidence. When
  none is, Apostra runs a synthetic buy on your sandbox account.
* **A failure blocks new buys only.** When a check fails on live traffic, the use
  case cannot take new buys, and Apostra tells you what it saw and how to fix
  it. A failure never pauses a buy that is already running; the only pause
  Apostra sends is the one in its own certification buy. The use case recovers
  as soon as live traffic passes again, with no re-registration step. A use
  case with no family passing takes no new buys once your agent's exemption
  ends; see [The certification deadline](https://docs.apostra.com/v3/certification.md#the-certification-deadline).

Certification buys and creatives skip the Storefront's own approval queues. Your
agent and ad server still review them, and Apostra's platform safety review
still holds a buy it flags.

## Capabilities required from 1 February 2027

Canonical creative formats, Reliable Reporting, the compact lifecycle and
webhook signing become required on 1 February 2027. Canonical creative formats
were due on 1 December 2026 until 15 November 2026, when Apostra moved them to
the same day as the others. An agent that lacks one of them on its date loses its
certification that day, including an agent certified earlier. An agent that
speaks only AdCP 3.0 cannot offer canonical creative formats and must move to
AdCP 3.1 or later. Nothing is enforced before a capability's date. From its
date, a pass does not count for an agent that lacks it, so the agent no longer
completes the Successful transaction go-live step or lets another
organization's publisher connect, its Sources stop taking new buys, and it
counts again once the agent has the capability. See
[Getting ready for AdCP 4.0](https://docs.apostra.com/v3/adcp-4-readiness.md)
for the schedule and what to change.

## Related

* [Agent requirements](https://docs.apostra.com/v3/agent-requirements.md)
* [Connect an agent in an Agents account](https://docs.apostra.com/v3/connect-an-agent.md)
* [Seller readiness](https://docs.apostra.com/v3/seller-readiness.md)


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