What is enforced today
Routing buys by declared features is being rolled out. Today, when a buy has a property list, we send the list only to Agents that declare property-list support. We may still return Products from an Agent that does not declare support, and may send that Agent a buy without the property list. Declare every feature your Agent honours so the routing can apply it correctly. We calculate the seven-day behaviour baseline below from our calls to your Agent; How certification works says where you see it and which checks can stop new buys. A blocker on one of those checks stops your Agent’s certification pass counting, and an Agent without a current certification exemption takes no new buys until it is fixed. Our team reviews the calls we make to your Agent with you. Do not treat a missing block as permission to skip a requirement.How we assess an Agent
We use evidence from our own calls to your endpoint. That includes theget_adcp_capabilities, sync_accounts, and get_products calls we make, as
well as requests made while discovering inventory and handling buys. We measure
the response your Agent sends, its timing, task progress, and whether returned
products honour the request. We do not accept a self-reported claim as proof
that an Agent behaves this way.
Certification runs on this live traffic. The Agent page does not offer a
separate transaction test to start. How certification works
explains what makes an Agent ready, what each check judges, how long it takes,
and what every result means.
For each applicable use case, Apostra runs a small sandbox test buy and judges
it from our tracker and the seller’s reports. Registering a production revision
is not a prerequisite for testing or certification. A registered revision is
useful for change detection, but it does not replace live-certification
evidence.
A passing use case completes the Successful transaction readiness check
(publish_validation) for every Source that uses the Agent. The pass stands
until a later certification result for the same use case and product family
fails.
Tracker macro checks
For display, video, audio, CTV, and programmatic DOOH certification, Apostra checks only the tracker macros that the selected format declares and that apply to that certification use case.TMPX is not required for these standard
macro checks. It belongs only to the separate Trusted Match certification for
Agents that declare Trusted Match support.
Required declarations
AdCP 3
What it is. Yourget_adcp_capabilities response must include major
version 3 in adcp.major_versions. Responses must validate against the schema
for the version we negotiate.
Why buyers care. A buyer needs the same contract that your Agent says it
supports, so a discovery result or buy does not fail when it reaches your
system.
How we measure it. We call your capabilities endpoint and validate the
responses we receive at the negotiated version.
See Getting ready for AdCP 4.0 for the capabilities
we require, when, the checks we run and what to change.
A supported billing model
What it is. Declareagent, operator, or both in supported_billing.
This is a seller-wide declaration, selected for each account in
sync_accounts. We review advertiser billing case by case.
Why buyers care. The billing model determines who can operate the buy and
settle it without a manual intervention after the buyer is ready to transact.
How we measure it. We read the billing declaration from the account and
capability responses we call, rather than relying on a separate statement from
your team. We then check that your Agent accepts the billing models it declares:
a sync_accounts request for a declared model that your Agent refuses shows as a
Declarations match behaviour finding.
Takes buyer account requests
What it is. Your Agent must list bothsync_accounts and list_accounts
and must not require operator authentication
(account.require_operator_auth: true). Buyers declare their own accounts:
sync_accounts receives a buyer’s account request, and list_accounts lets us
read the result back.
Why buyers care. Every buy runs on an account. A buyer can only start
buying from you once your Agent can open an account for them.
How we measure it. We read the tool list from your
get_adcp_capabilities response. The Agent page shows the result as Takes
buyer account requests in its required capability declarations.
What happens when it is missing. When your Agent is the only source behind
a storefront, we cannot open an account for a new buyer, so:
- Certification skips with
seller_sandbox_account_failed(orseller_operator_auth_unsupported), because it sets up its test account the same way. - An advertiser that does not already have an active account with you no longer sees your products in discovery and cannot book with you.
- Advertisers whose accounts you already accepted keep discovering and buying as before.
Creative formats we supply
What it is. At least one Product must declare a format. It can declare a canonicalformat_options[].format_kind that we support (display_tag,
video_vast, or audio_daast), or legacy format_ids.
Why buyers care. A buyer can only place a buy if Apostra can deliver a
creative that the Product accepts and can measure.
How we measure it. We inspect the Products returned by our own
get_products calls.
Per-buy features
Property-list targeting
What it is. Property lists are a per-buy feature. In AdCP 3.1, declaremedia_buy.features.property_list_filtering and, for each applicable Product,
property_targeting_allowed. If your Agent negotiates AdCP 3.2, also declare
media_buy.execution.targeting.property_list and
property_list_exclude, plus overlay_support.property_list on each
applicable Product.
Why buyers care. A property list lets a buyer direct a buy to the intended
publishers, stations, or networks. It applies to every channel, including
linear TV and radio.
How we measure it. We read these declarations from the capability and
Product responses we call. On buys that include a property list, we also check
that the returned Products honour the property list, channels, and countries
we sent.
Property-list support is a per-buy requirement that is being rolled out; it
does not block an Agent. Today, we send a property list only to an Agent that
declares support. We may still return Products from an Agent that does not
declare it and send that Agent a buy without the list. As feature routing rolls
out, a buy that needs a property list will go only to Agents that declare
support, while Agents that do not declare it can still receive buys that do not
need it. Declare every feature your Agent honours.
Required behaviour
We assess these behaviours over the preceding seven days. A failure in this baseline applies to the Agent as a whole, not to one Product or one use case.
Repeated means three or more events within the seven-day window. For this
baseline, that applies to stale async handoffs and breaches of the request.
Persistent means that the flagged condition appears on three or more
separate days within that window.
Async tasks
AdCP 3.1 has no capability field for async tasks. We therefore assess them by behaviour, not declaration. If a request cannot finish in time, returnsubmitted or working with a task handle. Then report a final status for the
task within five minutes of our request, through polling or webhook. The
responsiveness and async-completion rows above are how we assess that handoff.
See Async completion finding for what counts as a
final status.
Behaviour findings and how to fix them
Each row in the Agent’s Agent-wide behaviour list links to one section below. Every section gives the threshold, the usual causes, and the next step. We apply each threshold to every Source bound to the Agent separately, over its own seven days. The Agent-wide row shows the worst result among those Sources and adds up their counts. So “20 handoffs were still unfinished across one Source” means that Source has 20, not that the Agent has 20 in total. Open Source detail to see which Source needs work. A finding that says Not yet evaluated has no matching calls in the last seven days, so it is neither passing nor failing. It clears after we make the kind of call named in its section.Responsiveness finding
Threshold. For each Source, over seven days:- Blocker: more than 5% of at least 20
get_productscalls timed out. A call times out when it returns neither a result nor a task handle before the response deadline. By default that deadline is 45 seconds, counted from the moment we send the request. A buyer can set a shorter or longer budget. - Flag: the p95 time to answer
get_productsis over 10 seconds, and at least one call that took more than 10 seconds returned no task handle.
- The Agent builds the whole catalog during the request, for example by calling
the upstream ad server live on every
get_products. - The upstream ad server is slow or rate limiting the Agent.
- Connection setup and cold starts use part of the deadline.
- The Agent does not use a task handle, so a slow request can only succeed or time out.
get_products calls in your own logs
for the window. If the Agent cannot answer within about 10 seconds, return
submitted or working with a task handle straight away and finish the work in
the background. Where you can, serve the catalog from a cache you refresh on a
schedule.
Async completion finding
Threshold. A handoff is stale when your Agent answeredsubmitted,
working or pending, and five minutes after our request it had not reported a
final status. Per Source: one or two stale handoffs is a flag; three or more
is a blocker. The five minutes is fixed today and is not a per-task deadline
you can set.
A final status is completed, failed, rejected, canceled or
input-required. A working update does not count. A task that finishes late
stops counting at the next evaluation, once we have recorded its final status.
Usual causes.
- The job was lost after the Agent returned the task handle, for example because of a restart, a deploy, or a queue that drops work.
- The Agent finished the work but never recorded the final status where polling reads it, or never sent it to the webhook.
- The webhook call failed, for example on a wrong URL or an expired credential, and was not retried.
- The work routinely takes longer than five minutes and only sends
workingupdates.
input-required, failed or completed as early as you can
rather than only working.
Call success rate finding
Threshold. Over seven days, for each Source, the share of our calls that failed for a reason other than a timeout. A call fails when your Agent returns an error, rejects the request, or cancels it. Flag above 5%. Blocker above 20%, or when every call failed. This finding is Not yet evaluated until we have made at least one call. Usual causes.- Validation that is stricter than AdCP, so your Agent rejects a valid request.
- Credentials for the upstream ad server that have expired or lost access.
- An account that does not exist or is not active on your side.
- An unhandled error inside the Agent, returned as a server error.
Honours request finding
Threshold. We do not calculate this finding yet, so it never shows Flag or Blocker today. When we do, any breach will be a flag and three or more within the seven days will be a blocker. Usual causes. Products returned outside the property list, channels or countries we sent, for example because the Agent ignores a filter it does not support but did declare. Next step. No action is needed for this finding today. Make sure returned Products respect the property list, channels and countries in each request, and that you declare only the targeting you honour.Account references resolve to one account finding
Threshold. Per Source:ACCOUNT_AMBIGUOUS returned once or more is a flag.
It is a blocker when it appears on three or more separate days in the seven
days.
Usual causes.
- Two accounts on your side share the same brand domain and operator, often
because
sync_accountscreated a duplicate (see Account sync is idempotent finding). - The lookup matches on brand alone and ignores the operator or the sandbox flag.
account_id on each account from sync_accounts; we then
address the account by id instead of brand and operator.
Payment terms finding
Threshold. Counted for accounts we requested with agent billing andpayment_terms. A missing billing or payment_terms, or an existing account
kept on different terms, is a flag. A new account returned active on
different terms is a blocker. The full rules are in
Return and honour payment terms on agent-billed accounts.
Usual causes.
- The Agent gives every new account its own default terms and ignores the terms we request.
- The account API your Agent calls cannot store payment terms.
- The response leaves out
billingorpayment_terms.
payment_terms or reject the account. Never return it active on
other terms. Return billing and payment_terms on every such account in
sync_accounts and list_accounts.
Account sync is idempotent finding
Threshold. Per Source: a repeatsync_accounts that creates a second account
for the same brand domain, operator and sandbox flag, or a list_accounts
roster that lists one key more than once, is a flag. It is a blocker when
this appears on three or more separate days in the seven days.
Usual causes.
- The Agent keys accounts on a generated id, or on brand alone, instead of brand domain, operator and sandbox flag.
- A retry after a timeout runs the create again.
- The sandbox flag is left out of the key, so a sandbox account and a live account collide, or the reverse.
action: unchanged or
updated and the same account_id. Merge the duplicates you already hold. Once
each key is listed once, the finding clears as the seven-day window moves on.
Declarations match behaviour finding
Threshold. Today this finding checks billing. We count eachsync_accounts
request we sent in the seven days for a billing model you list in
supported_billing. A request your Agent refused with
BILLING_NOT_PERMITTED_FOR_AGENT or BILLING_NOT_SUPPORTED is a mismatch, whether
the code came on the call itself or on the account in your answer. Any mismatch
is a flag. A mismatch seen on three or more separate days is a blocker.
When we sent no request for a billing model you declare, the finding is not
evaluated.
Usual causes.
supported_billinglists a billing model, such asagent, that your platform is not set up to accept for buyers.- The billing model is accepted only for some buyers or operators, but is declared for all.
supported_billing, or
remove the ones you refuse. Buyers choose a billing model from your declaration,
so a model you declare and then refuse leaves their account unopened. Once your
Agent stops refusing a declared model, the finding clears as the seven-day window
moves on. See Keep capabilities current.
Machine-readable errors finding
Threshold. Over seven days, any error we receive without a recognised AdCP error code is a flag. This finding is never a blocker on its own. Timeouts do not count here. Usual causes.- The Agent returns plain text, an HTTP status or a stack trace in place of an AdCP error.
- The Agent passes through the upstream ad server’s error, or uses its own code that AdCP does not define.
What happens when we find a problem
A flag tells you what we observed and how to fix it. A blocker is shown on the Agent page. Running buys continue in both cases. How certification works says which checks can stop new buys. A blocker on one of those checks stops the Agent’s certification pass counting until the blocker clears, and an Agent without a current certification exemption takes no new buys while its pass does not count. A blocker on any other check leaves the pass alone. Our team reviews the evidence from our calls with you, and the thresholds on this page are the standard for that review.Accept a sandbox account for certification
Before live-traffic certification can run its test buys for an Agent source, we set up a sandbox account on your Agent the way a real buyer would. We call yoursync_accounts for our certification test buyer:
- Brand: the certification advertiser’s brand domain, for example
acmeoutdoor.example. - Operator: the buyer’s operator domain, for example
pinnacle-agency.example. - Sandbox:
sandbox: true. - Billing: a model your
account.supported_billingoffers. We requestagentwhen you offer it, thenoperator, thenadvertiser. We requestagentwhen your Agent declares none.
sync_accounts must accept a sandbox account for that test identity and
return it with status: "active", sandbox: true, and an account_id. We use
that account_id, and only that account_id, for creative sync and the
certification buy. We never fall back to a default account or to the
brand and operator alone. You do not choose or register an account yourself.
Sandbox buys must still run through your real ad serving, at no cost to us.
Certification creatives and buys do not wait in your Storefront’s creative
review or media-buy approval queue, even when you approve those manually for
buyers. They go straight to your Agent, which can still review or reject them
the way your ad server normally does. A creative your Agent holds for review
skips that family with seller_creative_review_required. A buy that our
platform safety review holds is not sent, and the family is skipped with
seller_approval_required.
For a tracked certification family, the Product format selected for the buy
must have a way to carry the buyer’s impression tracker. Declare an impression
slot with asset_type: "url" and an id of impression, tracker_pixel, or
imp_pixel; for hosted video or audio, declare a matching pixel_tracker
slot. URL-delivered VAST and DAAST tags instead use the buyer’s hosted wrapper
to carry the tracker. If the selected format has neither a supported tracker
slot nor that wrapper path, certification cannot measure delivery and does not
sync a creative or book a test buy for that family. Add a supported tracker
path to the format, then start a new certification run.
Certification skips a family, and records why, when one of these reasons applies.
A skipped family never produced a buy. It shows as inconclusive with the reason,
and it does not fail the use case. The Agent page shows the reason code with a
short message and, when your Agent returned one, the first error code and
message it sent. How certification works
says what to change for each.
A managed sales-agent source is certified the same way. We call the managed
sales agent’s
sync_accounts with the same brand, operator and sandbox: true,
and request a billing model from the sales agent’s own
account.supported_billing. We use the account_id it returns, unchanged, for
creative sync and the certification buy. We do not use the certification
buyer’s storefront account, the ad-server advertiser id, or a listing of the
sales agent’s accounts.
If the certification advertiser has no linked brand, certification skips that
family with sandbox_brand_unverified.
Certification for an Agent that sells only through briefs
You do not need a wholesale listing to be certified. If your Agent lists no Products for a wholesaleget_products and declares the brief buying mode in
media_buy.buying_modes in get_adcp_capabilities, we certify it through
briefs. You do not need to set media_buy.supports_proposals: that field says
your Agent returns proposals, not that it takes briefs. An Agent that declares
supports_proposals: true is certified through briefs too. An Agent that lists any wholesale Product is certified from that
listing and is sent no brief.
After the sandbox account is set up, we send one brief for each of these use
cases:
Each brief states a budget of USD 10 in total, the per-buy cap on every
certification buy, and a three-day flight. We accept the first proposal, in the
order you return them, with a Product that serves the use case, and we buy that
Product at the pricing option the proposal allocates. If you answer with
Products and no proposal, we treat the Products as your proposal. We buy through
the same
create_media_buy a buyer’s accepted proposal becomes, on the sandbox
account_id you returned, and the buy is checked like any other certification
buy.
A Product serves a use case under the same rules as a wholesale Product: its
channel, its creative kind, and a tracker path for the format. The buy must fit
the USD 10 cap. When the only matching Product needs a minimum above it, the
family is skipped as budget_exceeds_per_buy_cap so you can see the real
obstacle. When your Agent returns nothing that matches, the family is skipped as
buy_no_matching_proposal and its message says which brief came back empty. A
skipped use case does not fail certification or stop the others.
How long certification gives get_products
Certification runs get_products three times: a brief, a wholesale listing, and a
check that your Products are complete. Each call has the same 45 seconds a live
buyer’s discovery gives your Agent, counted from the moment we send the request,
so connection setup is part of it. An Agent that answers in 35 seconds serves
buyers and passes certification. Other certification reads, such as listing
audiences and event sources, keep a 30-second limit, and buy and creative
operations keep 90 seconds. Certification runs started before this limit changed
finish under the 30-second limit they began with, and an Agent’s existing
certification stays valid until it expires.
Audiences and event sources
A buyer can map their own audiences and event sources to the ones already on their account with your Agent. Two declarations inget_adcp_capabilities
decide which of your tasks we call for this:
If your Agent declares neither, we never call either task to list or map
objects. For listing and mapping, we read only these declarations, not your
tool list.
We are rolling these calls out to buyers in stages. Until a buyer is included,
we make none of the listing or mapping calls below for that buyer’s accounts.
Listing what is on the account. For each account a buyer connects through
your Agent, we call each declared task in discovery mode, about once an hour.
The request names the account and carries no
audiences or event_sources
list, so it changes nothing on your side. We call with the buyer’s own
credential for that account. A malformed response, or one that reports errors,
records nothing, and we try again on the next pass.
Mapping. When a buyer maps one of their event sources to one of yours, we
record which of your event sources, by seller_id, they picked. When a buy
uses that mapping, we read your event sources again in discovery mode and
confirm the one they picked is still listed and accepts the event types the
buy needs. We record audience mappings too, but we do not confirm them on your
Agent yet. Mapping never creates, changes or deletes anything on your Agent.
Pushing audiences. When a buyer syndicates one of their audiences to your
Agent, we send it with sync_audiences, including its members. This push
depends on your tool list including sync_audiences, not on the
audience_targeting declaration. We do not forward conversion events to your
Agent with log_event yet.
Certification checks the listing and mapping calls on your certification
account; see
Audience and event-source certification checks.
Audience and event-source certification checks
Certification adds checks for the buyer objects your Agent says it accepts. They run only whenget_adcp_capabilities declares the matching AdCP 3.2
media_buy block, never because of your tool list, and they only read your
certification account:
If you declare
conversion_tracking, keep at least one buyer-managed event
source on your certification account, or the mapping check fails the run.
Certification does not check log_event yet.
Best practices
These practices are not separate eligibility requirements, but they make an Agent easier to integrate and recover when something fails.Return AdCP error codes
What it is. Return the applicable AdCP error code whenever an operation fails. Why buyers care. A structured error lets buyer software decide whether to retry, correct the request, or show the buyer the next action. How we measure it. We classify the errors returned by our calls. An error we cannot classify is visible in the behaviour review above.Return an account ID from sync_accounts
What it is. When sync_accounts creates or confirms an account, return
its account_id on that account’s row. Apostra stores the ID and sends
account: { account_id } on later get_products and create_media_buy
calls for that account, instead of the brand and operator.
Keep the ID stable for the life of the account. A response row that names a
different brand_id from the one we sent, or reports a failed action, is not
taken as the account’s ID.
Why buyers care. An ID names exactly one account. If the same brand and
operator match more than one account on your side, the brand and operator
alone return ACCOUNT_AMBIGUOUS, and the buyer’s discovery or buy fails.
How we measure it. We read the account_id from the account rows in your
sync_accounts responses, and the account-resolution results of the calls
that follow.
Return and honour payment terms on agent-billed accounts
What it is. When we ask for an account withbilling: "agent" and
payment_terms (for example net_60), do one of two things: accept those
terms, or reject the account. Never return the account as active on
different terms. On every account in your sync_accounts and list_accounts
responses for an account we requested this way, return billing and
payment_terms so we can see what you hold. AdCP states that the seller
“must either accept these terms or reject the account — terms are never
silently remapped.”
Why buyers care. The buyer’s organization chose its payment terms. An
account on other terms means invoices that don’t match what they agreed.
What Apostra does when an Agent doesn’t. We refuse a new account that
comes back on other terms. It is not activated, and it is held for the buyer
to review the seller’s terms. An existing account stays usable, and the buyer
sees a warning that names both the requested terms and the terms your Agent
kept.
How we measure it. We compare the accounts in your sync_accounts and
list_accounts responses over the last seven days with the terms we
requested. Only an account we requested with agent billing and payment_terms
in that window counts. An account we requested without terms is on your default
terms, as AdCP says, and isn’t counted. An account we never requested in the
window isn’t counted either, and a response from before our request doesn’t
count against the account. We don’t assume what your default terms are. For a
counted account, a missing billing or payment_terms is a flag, and an
active account on different terms is a blocker when your Agent created it or
activated it on those terms, and a flag when your Agent already held it. Your
Agent already held it when its sync_accounts response reports
action: unchanged, or action: updated after an earlier response held the
account active. A response that reports action: created or no action counts
as a new account. An account that was a blocker at any point in the seven days
stays one. A counted account whose listing has no billing counts as missing
billing. We
count accounts, not responses: an account is identified by its brand domain,
operator and sandbox flag (and its brand id and operator unit, when you return
them), however often it appears in your responses. An
account counts as missing a field only while its latest response in the window
lacks it, so it stops counting once your next response is complete. From
list_accounts we read only your most recent roster, which is every page of
your latest complete listing, so an account that has dropped out of it isn’t
counted. An account
returned on different terms stays counted for the seven days. This
check reports today and does not yet stop new buys.
Sync accounts idempotently
What it is. The account key is the brand domain, the operator and the sandbox flag. When we sendsync_accounts for a key your Agent already holds,
return that same account with action: unchanged (or updated, if something
changed) and the same account_id. Create an account only the first time the
key appears. list_accounts lists each key once.
Why buyers care. A buyer syncs the same account again whenever their setup
changes. If each call creates a new account, the buyer’s buys, approvals and
invoices spread across accounts nobody asked for, and the seller cannot tell
which one is current.
How we measure it. Over the last seven days we look for two things: two or
more sync_accounts responses that report action: created for one key under
different account_id values, and a list_accounts response that holds more
than one account for the same key and sandbox flag. We read a list_accounts
roster as every page of one listing, joined by pagination.cursor, and use the
latest listing whose last page returns has_more: false; a listing that stops
early isn’t used. Seeing either is a flag.
Seeing it on three or more days is a blocker. A sandbox account and a live
account for the same domain are different keys. Once your Agent merges the
duplicates and lists each key once, the roster signal clears. This check
reports today and does not yet stop new buys.
Hand off long work quickly
What it is. Returnsubmitted quickly when work needs more time, with a
task handle that callers can poll or receive by webhook.
Why buyers care. The buyer gets a durable acknowledgement instead of
waiting for a request that will exceed the response window.
How we measure it. We record the initial response time, task handle, and
later task status from our calls.
Declare AdCP channels on every Product
What it is. Every Product declares the AdCP media channels it sells inchannels, such as display, olv, ctv, or streaming_audio. A Product
that sells different channels through different formats can instead declare
applies_to_channels on each format option. A format type on its own, such as
a video or audio format, is not a channel, because several channels share a
format.
Why buyers care. Buyers filter discovery, route proposal requests, and
report delivery by channel. A Product with no channel is missing from
channel-filtered discovery, and its delivery reports with no channel.
How we measure it. We read channels, then applies_to_channels, on the
Products returned by our get_products calls. Storefront readiness counts the
Products that declare neither (see
Diagnostics), your Agent page
shows the same count as an advisory note under Catalog Product Quality, and live-path
certification skips such a Product with the reason missing_channels rather
than certifying it on a guessed channel. When a Product relies on
applies_to_channels and only some of its format options declare it, the
other formats are skipped with the reason missing_channels:<format_kind>. This is a best practice: a
missing channel produces a warning and never blocks your Agent or fails its
certification. We do not refuse an external Agent’s Products for missing
channels. AdCP is considering making channels required on every Product in
AdCP 4.0
(adcontextprotocol/adcp#7869);
if it does, AdCP compliance will require it.