Curated Deals Still Look Like Plain PMP Lines. OpenRTB Has No Curation Field.

A media buyer targets deal curator-deal-8842 because the one-pager promised a retail segment, an MFA exclusion list, and a disclosed curator fee. The SSP sends the same JSON shape it uses for a publisher-direct private auction. Nothing in the payload says "curated," and nothing points at the filter that removed half the supply before the request left the exchange.

That mismatch is not a DSP UI problem. It is a wire contract problem. Programmatic curation is sold as packaging: inventory plus data, assembled upstream, sold as one deal id. On the bidstream it is still just imp.pmp.deals.

What the Deal object actually carries

OpenRTB 2.6 defines the Deal object under Pmp with a small, fixed vocabulary. You get id (required), optional bidfloor, bidfloorcur, auction type at, seat allow lists wseat, advertiser domain allow lists wadomain, guarantee flags, pod pricing helpers like mincpmpersec, and duration floors in durfloors. That is the entire deal surface on the request.

A typical curated line looks like any other PMP entry:

"imp": [{
  "id": "1",
  "pmp": {
    "private_auction": 1,
    "deals": [{
      "id": "curator-deal-8842",
      "bidfloor": 12.5,
      "bidfloorcur": "USD",
      "at": 1
    }]
  }
}]

There is no curator id field, no fee disclosure field, and no machine-readable description of the audience or inventory filter that produced this impression. If the curator applied segments only as an upstream filter, you may never see those segments in user.data either. When segments do ride the request, they show up as separate Data and Segment objects with their own provider ids, which is attribution by convention, not a curation marker.

The OpenRTB deals and PMP guide walks through how preferred, private auction, and programmatic guaranteed lines map onto those fields. Every curated package still lands in that same map.

Where IAB put the Curation object

IAB Tech Lab's answer to opacity is a Curation object with terms, inventory scope, and fee disclosure. It lives in the Deal Sync API, a one-directional SSP-to-DSP push of static deal metadata that runs beside the bidstream. The specification states plainly that the object is not included in the OpenRTB request or response, and that criteria sent through Deal Sync are not guaranteed to match what arrives in live traffic.

For engineering teams, that splits the problem in two. Deal Sync is a reconciliation feed you ingest, store, and diff against reporting. The bid request is the object your bidder, your ARTF agent, and your AdCP-to-OpenRTB mapper actually mutate under time pressure. An implementation can return HTTP 200 on Deal Sync ingestion and still serve auctions where the deal line alone is the whole story.

What is curation in programmatic advertising? states that split in plain language: curated supply arrives as an ordinary deal entry with no marker, which is exactly why curation is hard to audit from OpenRTB alone.

What you can still prove on the auction hop

You cannot infer curator intent from schema validation on an isolated bid request. You can still catch incoherence between the request that went out and the bid that came back, which is where curated deals most often fail in production.

Deal id integrity. A bid that names a dealid the impression never offered is invalid on exchanges that enforce PMP rules (loss reason 4, invalid deal id). That check is relational: it needs the paired request and response, not either file alone.

The right floor. Deal-backed bids clear the deal's bidfloor, not the impression's open-market floor. Bidding against the wrong number produces loss reason 101. Curators move floors when they re-package supply; a stale floor in the live request is a silent revenue leak. The dated rule note on deal floor fields in OpenRTB 2.6-202309 is worth reading next to your snapshot train, because floor semantics moved with the dated snapshots the same way the rest of 2.6 did.

Seat and domain gates. wseat on the deal and seat restrictions on the request decide whose bids are eligible. Curated paths still hit openrtb.seatbid.seat_not_allowed when those lists disagree.

Supply path. Curated inventory still carries source.schain. Fee disputes and reseller authorization do not disappear because a curator filtered the pool. Reconcile schain the same way you would on open exchange supply; the supply chain doc is the field reference when you are debugging custody, not just seller ids.

Run the paired check:

$ rtblint validate --type response --request req.json resp.json

A response that validates alone can still fail with openrtb.bid.dealid_unknown or currency mismatches once the request is in scope. That pattern is the same whether the deal was publisher-direct or curator-wrapped.

Sidecar plus bidstream, not sidecar instead of checks

Teams wiring agentic buying often negotiate deals above the auction, then materialize a deal id in imp.pmp.deals for execution. The agentic buying and OpenRTB primer sits in that gap: AdCP-style negotiation and ARTF mutations still collapse to OpenRTB objects at the exchange edge. Deal Sync is the third leg: static metadata that should align with what the curator sold, but never replaces live validation of the request and response pair.

An LLM or agent toolchain that emits OpenRTB from a brief can hallucinate a deal id, copy last week's floor, or attach a dealid on the response that never appeared on the imp. The RPC can still return OK. The wire contract does not move. rtblint (cargo install rtblint, npm install rtblint-core, MCP rtblint-mcp) is the deterministic check on that object: dated OpenRTB snapshots, cross-document bid checks, ARTF envelope validation when an agent patched the request, and AdCP discovery when you need to see what the seller claimed before the bid went out. It is independent of IAB Tech Lab and of AgenticAdvertising.org; nothing in the spec requires it, but nothing in the spec validates your paired traffic for you either.

Where to go next

Start with programmatic curation and the Deal Sync split if you are onboarding buyers who conflate deal targeting with package transparency. Use the guides index for OpenRTB version trains and schain migration notes when curated lines cross SSPs with different snapshot dates. When floors move on curated packages, keep the Deal Sync export and the live imp.pmp.deals entry in the same diff; the auction object is the billable truth, but the sidecar is the only place IAB defined curator terms.