Prebid

What Is Prebid?

Prebid is the open-source framework that powers header bidding, the technique publishers use to let multiple advertising exchanges and supply-side platforms compete for an ad slot simultaneously before the page's ad server makes its final decision. Its best-known component is Prebid.js, a JavaScript library that runs in the browser, solicits bids from many demand partners at once, and passes the winning bids into the ad server. Prebid is widely regarded as the de facto open-source standard for header bidding across the publisher web.

Prebid is governed by Prebid.org, a non-profit, community-led organization, and the project is free and open source. That open governance is central to its identity: rather than a single vendor controlling the auction, publishers and ad-tech companies collaborate on a neutral wrapper that any exchange can integrate with by contributing a bidder adapter. The result is a transparent, vendor-neutral layer that competes demand fairly and reduces reliance on any one exchange.

It is important to be precise about what Prebid is and is not. Prebid is not an ad exchange, an SSP, or a source of demand on its own, it does not buy or sell ads. It is the plumbing, a wrapper, that orchestrates the auction among the exchanges a publisher chooses. Those exchanges (OpenX, PubMatic, and many others) plug into Prebid as bidder adapters. So when you detect Prebid, you have found the auction framework, and the actual demand comes from the bidders configured inside it.

The Prebid project spans more than the browser library. Prebid Server moves the auction to a server to reduce page weight and latency, Prebid Mobile brings header bidding to native apps, and there are components for video, connected TV, and identity. But on the open web, the signature artifact is Prebid.js running in the page, and because it is open source with recognizable function names and global objects, it is one of the more detectable pieces of the modern ad stack, even though the individual bidders it calls are often loaded indirectly.

How Prebid Works

Prebid.js orchestrates a client-side auction in the browser. The publisher configures a set of ad units, each describing a slot's sizes and the bidders that should compete for it, and registers them with Prebid.js. When the page loads, Prebid.js fires a bid request to every configured bidder more or less in parallel, then waits a configured timeout (often a few hundred milliseconds) for responses.

Each bidder, via its bidder adapter, translates Prebid's request into its own exchange's format (frequently OpenRTB), runs its slice of the auction, and returns a bid with a price and creative. Prebid.js collects the responses that arrive before the timeout, determines the highest bid for each ad unit, and sets key-value targeting on the ad server's ad call (for example, the winning price bucket and a creative cache key). The publisher's ad server, commonly Google Ad Manager, then compares those header-bidding bids against its own demand and any directly sold campaigns and decides the overall winner, which is rendered into the slot.

To keep page weight down and latency predictable, Prebid offers Prebid Server, a server-side auction host. With server-side header bidding, Prebid.js sends a single request to Prebid Server, which fans out the bid requests to the exchanges from the server rather than the browser. This reduces the number of third-party calls the visitor's browser makes, but it also means the individual exchanges may never be contacted directly from the client, an important nuance for detection.

A few mechanics shape Prebid's behavior. First, the configuration, the ad units and the list of bidders, is usually set up in JavaScript at runtime, so the specific exchanges may not appear in the static HTML even though Prebid.js itself does. Second, the auction is time-boxed: a bidder that responds after the timeout is dropped, which is why ad-ops teams tune the timeout carefully. Third, Prebid exposes a global pbjs object in the browser with inspectable methods, which is a gift for detection because you can query the live auction state. Fourth, identity and consent are first-class concerns; Prebid integrates consent-management signals and identity modules, so its behavior varies by region and consent state.

The relationship between Prebid and the rest of the stack is the key mental model. Picture three layers: Prebid.js (or Prebid Server) as the auction orchestrator, the bidder adapters as the connections to individual exchanges, and the ad server as the final decision-maker that weighs Prebid's winning bids against everything else. Prebid's job is purely to make the exchanges compete fairly and hand the best results to the ad server; it never decides the ultimate winner itself. Understanding this layering explains why detecting Prebid tells you a site runs competitive header bidding, while figuring out which exchanges supply the demand requires inspecting the configured bidders or the site's ads.txt.

How to Tell if a Website Uses Prebid

Prebid.js is one of the more detectable ad-tech components because it exposes a global object and uses recognizable open-source code, though the bidders it calls and any server-side auction are loaded more indirectly. Here are the concrete signals.

DevTools Console (the strongest runtime check). Open the console and type pbjs or typeof pbjs. If Prebid.js is present, you will get the Prebid object rather than undefined. From there, pbjs.getBidResponses() shows the bids received, pbjs.getConfig() shows the configuration, and pbjs.installedModules lists the modules and bidder adapters in the build. This is the most direct confirmation that a site runs Prebid and reveals which bidders are competing.

View Source and search for Prebid strings. Search the page source for prebid or pbjs. You may find a prebid.js script reference (sometimes self-hosted under the publisher's own domain, sometimes named generically) and inline configuration calling pbjs.que.push(...). Because publishers often bundle or rename the file and configure bidders in JavaScript, the exact bidders may not be visible here, treat absence as inconclusive.

DevTools Network panel. Reload with the Network tab open. With client-side header bidding you will see bid requests fanning out to multiple exchange domains around the time the page loads, which is the visible footprint of the parallel auction. With Prebid Server, you will instead see a single call to a Prebid Server endpoint and far fewer client-side exchange requests, a sign the auction moved server-side.

Check ads.txt for the configured exchanges. Prebid itself does not appear in ads.txt, but the exchanges it calls do. Fetching https://example.com/ads.txt and reading the authorized sellers tells you which demand partners the publisher works with, which complements the runtime pbjs inspection. This is especially useful when the auction is server-side and client-side requests are sparse.

Wappalyzer and BuiltWith. Both tools recognize Prebid from its script and the pbjs object and report it under advertising. They are a fast confirmation, though, as with other indirect ad-tech, they can miss heavily customized or server-side setups.

Method	What to do	What Prebid reveals
DevTools Console	Type pbjs / pbjs.getBidResponses()	Confirms Prebid.js and lists the bidders competing (strongest signal)
View Source	Search source for prebid or pbjs	Prebid script reference and pbjs.que.push config (bidders may be hidden)
DevTools Network	Watch requests at load	Parallel exchange bid requests (client-side) or a single Prebid Server call
ads.txt	Fetch /ads.txt	The exchanges Prebid is configured to call, as authorized sellers
Wappalyzer/BuiltWith	Run on the live page/domain	Prebid flagged under advertising; historical usage

Prebid is unusually transparent at runtime thanks to the pbjs global, so the console check is both quick and definitive when Prebid.js runs client-side. The harder cases are server-side header bidding via Prebid Server, where the browser sees little, and identifying the specific exchanges, which are loaded indirectly as adapters. In those cases, combine the pbjs inspection with the site's ads.txt. For the broader methodology, see our guides on how to find out what technology a website uses and, because Prebid and its tags are often deployed through a container, how to check if a website uses Google Tag Manager. A server-side scan that fetches the raw HTML and ads.txt is well suited to surfacing the Prebid script reference and the configured sellers.

Key Features

• Open-source header-bidding wrapper. A vendor-neutral framework that lets multiple exchanges compete for each impression.
• Hundreds of bidder adapters. A large community-maintained library of integrations with SSPs and exchanges.
• Client-side and server-side auctions. Prebid.js in the browser and Prebid Server for reduced page weight and latency.
• Multi-format and multi-channel. Support for display, native, video, connected TV, and mobile via Prebid Mobile.
• Identity and consent modules. Integration with identity solutions and consent-management signals for privacy compliance.
• Inspectable runtime API. A global pbjs object exposing configuration and bid responses for debugging and transparency.
• Open governance. Maintained by the non-profit Prebid.org with community-contributed code.

Pros and Cons

Pros

• Increases competition and can lift publisher revenue by letting many exchanges bid at once.
• Vendor-neutral and transparent, reducing reliance on a single exchange's stack.
• Free and open source with a large ecosystem of bidder adapters.
• The runtime pbjs API makes auctions debuggable and Prebid itself easy to verify.

Cons

• Adds latency and page weight if too many bidders or a long timeout are configured.
• Requires real ad-ops expertise to set up, tune timeouts, and manage adapters.
• The configured exchanges are loaded indirectly, complicating demand attribution.
• Server-side header bidding reduces client visibility into which exchanges are bidding.

Prebid vs Alternatives

Prebid competes with proprietary header-bidding wrappers and with fully managed alternatives to header bidding. The table clarifies where it fits.

Approach	Type	Standout strength	Typical adopter
Prebid	Open-source wrapper	Vendor-neutral, transparent, huge adapter library	Publishers wanting control and demand diversity
Google Open Bidding	Server-side, Google-run	Tight Google Ad Manager integration, less code	Publishers centralized on Google's stack
Amazon TAM / UAM	Managed wrapper	Access to Amazon demand, managed setup	Publishers seeking Amazon demand with less ops
Proprietary wrappers	Vendor-managed	Turnkey setup and managed optimization	Publishers preferring a hands-off managed service
Direct ad-server demand only	No header bidding	Simplicity, minimal page weight	Small sites prioritizing simplicity over yield

Because Prebid is just the wrapper, the demand inside it comes from exchanges; compare two common bidders by reading about OpenX and PubMatic to understand the supply side Prebid orchestrates.

Use Cases

Prebid is used by publishers of every size that want to maximize ad revenue through competitive header bidding while retaining control and transparency. A mid-sized publisher might run Prebid.js with a handful of carefully chosen exchanges so that each impression is auctioned competitively, lifting the clearing price above what a single exchange would pay. Larger publishers run extensive Prebid configurations, sometimes server-side via Prebid Server, to balance yield against page performance.

It also serves app publishers through Prebid Mobile and video or connected-TV publishers through Prebid's video components. Ad-ops and revenue teams value Prebid specifically because it is open source and inspectable: they can audit the auction with the pbjs API, tune timeouts, and add or remove bidders without being locked into a single vendor's wrapper.

From a competitive-intelligence and lead-generation perspective, detecting Prebid is a high-value technographic signal. It indicates a publisher sophisticated enough to run programmatic header bidding, manage multiple exchange relationships, and invest in ad-ops, exactly the profile that ad-tech vendors, SSPs, and agencies want to identify. Pairing Prebid detection with the exchanges listed in a site's ads.txt paints a detailed picture of a publisher's monetization stack. Doing this automatically across many domains, rather than inspecting each site's console by hand, is precisely where technology detection delivers value, as our primer on using tech-stack data to qualify leads explains.

Frequently Asked Questions

Is Prebid an ad exchange?

No. Prebid is an open-source header-bidding framework, a wrapper, that orchestrates an auction among the exchanges and SSPs a publisher configures. It does not buy or sell ads itself and provides no demand of its own. The actual demand comes from bidder adapters like OpenX or PubMatic that plug into Prebid. So detecting Prebid tells you a site runs competitive header bidding, while the exchanges supply the bids.

How can I confirm a site uses Prebid.js?

The most direct check is the browser console: type pbjs and press enter. If Prebid.js is loaded you will get the Prebid object rather than undefined, and pbjs.getBidResponses() will show the bids received. You can also search the page source for prebid or pbjs.que.push, and watch the Network panel for parallel exchange bid requests at page load. The console check is the strongest single confirmation.

Why can't I see which exchanges Prebid is using?

Because the bidder adapters are configured in JavaScript at runtime and the auction may run server-side. The Prebid.js script may be present without the bidder list appearing in the static HTML, and with Prebid Server the browser only contacts a single Prebid Server endpoint rather than each exchange. To find the demand partners, inspect pbjs.getConfig() or pbjs.installedModules in the console, or read the site's ads.txt, which lists the authorized exchanges.

What is the difference between client-side and server-side header bidding?

In client-side header bidding, Prebid.js fires bid requests to each exchange directly from the visitor's browser, which is transparent but adds page weight and network calls. In server-side header bidding, Prebid.js sends one request to Prebid Server, which contacts the exchanges from a server instead. Server-side reduces browser load and latency but makes the individual exchanges harder to observe from the client, so detection relies more on ads.txt and runtime inspection.

Does Prebid hurt page speed?

Prebid can affect page speed because header bidding adds an auction step and, in client-side mode, multiple third-party network requests. The impact is managed through the auction timeout, the number of bidders, and by moving to Prebid Server when appropriate. Well-tuned Prebid setups keep latency in check, but poorly configured ones with too many bidders or long timeouts can slow rendering; our guide on how to make your website load faster covers relevant techniques.

Want to detect Prebid and the rest of a site's ad-tech stack instantly? Run any URL through StackOptic at https://stackoptic.com.