- Published
- Oct 30, 2026
- Updated
- Oct 31, 2026
- Reading time
- 11 min read
Prebid CMP Not Found? Audit Consent Timing and API Readiness
Diagnose Prebid CMP-not-found errors by separating API discovery, responses, user action and auction events. Check waitForCmp against the deployed version.

In this guide (10 sections)
When Prebid reports that a CMP was not found, establish whether its API was discoverable when the consent lookup began. A visible banner, a stored choice, a successful API response and an auction proceeding are different observations. Increasing a response timeout does not necessarily repair a missing interface.
Two real publisher questions illustrate the confusion. An older CMP integration question describes a rendered banner and stored choice while Prebid cancels the auction. Another asks why requests appear before the consent dialog closes. They concern older versions, and the first poster later reports a vendor-side improvement. Do not apply their historical configuration snippets to today's build.
There is also a current technical development: the Prebid 11.45.0 release, published on 28 October 2026, includes late CMP API support. That makes this a useful moment to inspect the integration boundary, not a reason to assume every consent problem requires an upgrade or one new setting.
Start with the boundary that actually failed#
Use a timeline containing these separate checkpoints:
| Checkpoint | Observation to capture | What it does not establish |
|---|---|---|
| Banner rendered | The visitor can see the interface | The expected CMP API exists in Prebid's execution context |
| CMP API discoverable | Prebid can find the supported interface or locator | User choices are available or favorable |
| Response received | An actual callback and its status | All consent data is valid and final |
| Choice available | The reported state for the relevant activities | Every vendor or activity is allowed |
| Auction events | Which request/auction events occurred | Correct enforcement or successful ad rendering |
Do not replace the timeline with “consent works.” Identify the exact failed transition and preserve its timestamp, page version and execution context.
This guide concerns the publisher's Prebid.js consent integration. It does not establish legal compliance, and it does not diagnose GA4 behavioral-model eligibility. The GA4 consent-modeling guide owns that separate reporting question.
Trace CMP discovery and response timing
Record API availability, consent lookup and auction timing for one test.
Use the tracking QA checklistOpens a practical guide. No email required.
Confirm the deployed version and page integration#
Record the Prebid build and included modules, CMP integration version, wrapper configuration, page release and relevant script-loading order. Include the affected browser, device, geography test condition and whether the observation came from the top page or a frame.
Inspect the released asset rather than only a corrected local build. A wrapper may load a different Prebid version on different templates. A production page and a development page can also differ in script order, embedding and configuration ownership.
The TCF CMP API specification describes a synchronous stub before scripts that depend on the API. The stub can queue calls until the full CMP implementation loads. It also defines the locator mechanism for communicating from frames.
Ask the CMP owner to verify that integration contract. Seeing the full banner appear later is not evidence that the stub was available earlier. Conversely, finding a callable stub does not mean the full implementation has finished loading or that the visitor has made a choice.
Do not manufacture a replacement API that returns an invented consent state. Fix the supported integration and preserve the user's actual choices.
Separate CMP discovery, CMP response and user-action timers#
Current Prebid TCF documentation distinguishes three settings:
timeoutlimits waiting for consent data from the discovered CMP interface.actionTimeout, when configured, starts after an initial/provisional response indicates that user action is still needed.waitForCmpallows waiting for an interface that was absent at lookup time; it defaults to false.
Without the late-interface option, a missing CMP interface can fail discovery immediately even when a response timeout is configured. That is why “we already allowed several seconds” does not settle a CMP-not-found error.
Capture the actual error text. “CMP not found,” a callback-registration failure, an invalid response and a user-action timeout describe different boundaries. Their next diagnostic step should differ too. A Google publisher TCF code is another product-specific diagnostic: check its current action, consent lifecycle and reporting history instead of applying a Prebid discovery-timeout fix to every warning.
Avoid increasing all timers together. First establish which clock was running and whether the expected event ever occurred. A longer deadline cannot repair a wrong frame relationship, a missing module or an interface that never loads. It can also change how long visitors wait without resolving the underlying cause.
What changed in Prebid 11.45.0#
Pull request 15777 adds optional late CMP discovery across the consent modules. It was merged on 27 October and included in the following release. The option supports integrations whose CMP stub arrives later than the interface specifications require; it is a compatibility mechanism, not permission to ignore those requirements.
For the TCF case, the documented option polls for the API at 100-millisecond intervals within the configured timeout. Check that your deployed version actually supports it before evaluating that behavior. An option shown in current online documentation is not proof that an older publisher bundle implements it.
Keep discovery and user choice separate when assessing the change. Waiting until an API exists does not grant consent, override a denial, correct a malformed response or certify downstream vendor behavior.
Also preserve configuration ownership. The version-pinned 11.45.0 shared consent code warns about starting another lookup while one is still waiting for the CMP. A test should not repeatedly rewrite consent configuration while trying to diagnose a single lookup.
Work a hypothetical timing example#
Suppose an authorized test uses a response timeout of 500 milliseconds and an action timeout of 2,000 milliseconds. These are hypothetical test values, not recommended production settings.
| Elapsed time | Observed event |
|---|---|
| 0 ms | Consent lookup begins; the expected API is absent |
| 300 ms | The API becomes discoverable |
| 340 ms | A valid provisional response indicates that a choice is pending |
| 1,100 ms | The test visitor completes the intended choice and the CMP reports it |
With missing-interface waiting disabled, the first lookup may already have failed before the API appears. Increasing the 500-millisecond response timeout alone does not establish that discovery waited.
With the documented late-interface behavior enabled in a compatible build, the 300-millisecond discovery can occur within that deadline. In this example, the provisional response starts the separately configured action timer at 340 milliseconds. Its hypothetical deadline is 2,340 milliseconds, so the response at 1,100 milliseconds arrives before that deadline.
This illustrates the distinction between clocks, not a guarantee that all implementations will behave identically. Validate the deployed module and actual callback sequence. Nor does the example show an allowed auction: the activities permitted by the resulting state still need their own checks.
A useful acceptance note reports the observed transition, such as “the API was discoverable before the lookup deadline.” It does not say “all privacy problems are fixed.”
Investigate requests before the dialog closes#
A dialog's visual state is not the only source of technical consent state. The TCF API distinguishes loaded data, a surfaced interface and completed user action. Record the callback's status and relevant data state instead of equating a closed modal with the entire consent contract.
The version-pinned Prebid TCF implementation handles specific response conditions, including tcloaded, useractioncomplete and a response indicating that GDPR does not apply. Those code paths explain what to inspect; they do not prove that the state returned on your page is correct.
Ask which request appeared early. A CMP resource request, a consent lookup, a bidder call, an identifier request and a rendered ad are different events. A network panel showing activity is not enough to classify all of them as advertising before consent.
Similarly, do not assume that a valid callback permits every activity. Prebid's TCF Control documentation describes enforcement separately from retrieving and distributing consent data. Check the modules and controls relevant to the actual activity under review.
Build a reproducible test matrix#
Test the environments that reproduce the symptom while preserving the approved consent configuration:
- A new test profile with no saved choice.
- A returning profile with a valid saved choice.
- A deliberate choice update through the supported CMP interface.
- The affected template and a known working template.
- The relevant top-page or framed integration.
- A controlled slow-loading condition if timing is the suspected variable.
For each, record API discovery, first response, subsequent response status, relevant Prebid events and observed requests. Retain the configuration and script versions alongside the result. The getEvents reference documents emitted event types and elapsed timing; those observations can help locate auction progress. An event log remains evidence to interpret, not a complete account of every browser or vendor action.
Use a minimal redacted record. Consent strings, account identifiers, page parameters and network payloads may contain sensitive information. The shared worksheet usually needs event names, state categories and timestamps rather than raw visitor data.
The marketing tracking QA checklist explains how to separate preview, released behavior and receiving-system evidence. Apply that discipline here instead of changing the test environment until the warning disappears.
Choose the next action from the evidence#
| Finding | Useful next action | Unsupported shortcut |
|---|---|---|
| API/stub absent at lookup | Review supported loading order and frame discovery | Treat the visible banner as proof of API readiness |
| API present, response fails | Review callback and CMP diagnostics | Increase the user-action timer blindly |
| Provisional state persists | Inspect user interaction and the configured action deadline | Invent a consent result to continue |
| Correct state received, activity unexpected | Inspect applicable enforcement and adapter behavior | Assume lookup success permits every request |
| Behavior changes only in one build | Compare released modules/configuration and reproduce | Declare a platform-wide outage |
Escalate with the original error, affected context, version evidence, ordered observations and the first missing transition. Keep implementation findings, permission decisions and commercial effects separate.
A lower request or revenue total does not prove that the CMP integration is broken. Valid restrictions, inventory changes and unrelated delivery behavior can affect the comparison. The publisher revenue diagnostic owns that broader investigation.
Keep cache and delivery questions separate#
The same 11.45.0 release includes a video-cache completion fix. It is a separate change from late CMP discovery. Do not interpret that fix as restoring player-added GAM information or AdX demand. Our local VAST-cache guide addresses that distinct request/player boundary.
For a delivery comparison alongside the technical investigation, discuss a scoped AdProof review. Bring the campaign window, counting definitions, timezone and comparable exports. The streaming-publisher delivery case illustrates measured campaign scope; it does not establish CMP certification or a native Prebid debugger. Keep CMP configuration and consent-state evidence with their implementation owners.
Frequently asked questions#
Why does Prebid say CMP not found when the banner is visible?
The banner and the supported API are different interfaces. Establish whether Prebid could discover the API or locator in its execution context when lookup began. A later visible banner does not resolve that earlier observation.
Does increasing timeout make Prebid wait for a missing CMP?
Not necessarily. In the current documented TCF flow, discovery of an absent API requires the relevant supported late-interface behavior. A timeout for a known CMP response is a different clock. Verify the deployed version and actual sequence.
Does waitForCmp make the integration compliant?
No. It is optional technical waiting behavior for late interface availability. It does not replace the expected stub integration, determine legal obligations or authorize data use. Preserve the user's actual choices and relevant enforcement controls.
Can an auction completing prove that every downstream request is correct?
No. Inspect which activities occurred, their applicable state and the relevant adapter behavior. Auction progress, permitted activities, rendered impressions and commercial outcomes are different findings.
Trace CMP discovery and response timing
Record API availability, consent lookup and auction timing for one test.
Use the tracking QA checklistOpens a practical guide. No email required.
