Header bidding has proven to be a successful web monetization option for desktop and mobile browsers. Since 2015, this technology has made the programmatic industry stronger and enabled publishers to generate more revenue.

The idea behind header bidding is quite simple: all ad exchanges and demand sources compete for the publisher’s inventory in an auction. To implement header bidding, the publisher simply inserts the JavaScript code within the header tag on any given page, hence the name of the method.

But how does that translate to in-app environments and what does it mean for app publishers? In this comprehensive guide, we will unravel the intricacies of in-app header bidding, shedding light on how it transforms the way mobile advertising operates.

What is In-App Header Bidding?

In-app header bidding is a programmatic advertising technique used in mobile applications. Despite the similarities in its name, it has nothing to do with headers. Headers are limited to browsers, which is why we had to wait for so long to get an appropriate header bidding iteration for mobile apps.

Since there is no header to insert JavaScript code into, apps use software development kits (SDKs) to get all the plugins necessary to communicate with servers. SDKs are at the core of the programmatic ads, as in-app header bidding requires communication with ad networks.

While the auction mechanisms remain more or less the same, it’s the way that in-app header bidding manages partners that makes all the difference. Header bidding removes the need for superfluous SDKs in an app.

In-app header bidding conducts the auction on the client-side, which means it takes place within the app on the user's device. This allows for parallel bidding, where multiple demand partners can simultaneously bid on ad inventory in real-time.

Increased competition among buyers can lead to higher bid prices, which ultimately benefits the publisher. With higher bid prices, publishers have the potential to earn more revenue from their ad inventory.

How Does In-App Header Bidding Work?

In-app header bidding works through a series of steps that allow multiple demand sources to bid simultaneously on ad inventory within a mobile app. Here's a detailed breakdown of how it works:

  1. Opening an application: A user opens a mobile app on their device.
  2. Request for ad space: The app identifies available ad slots where ads can be displayed (e.g., banners, interstitials, native ad units).
  3. Header bidding integration: The app uses a Header Bidding SDK (Software Development Kit). This SDK facilitates the header bidding process.
  4. Ad space auction request: Instead of sending the ad space request to a single ad network or exchange, the SDK sends it simultaneously to multiple demand partners (ad exchanges, networks, SSPs).
  5. Real-time auction: The demand partners receive the ad space request and begin to participate in a real-time auction.
  6. Bidding and price determination: Each demand partner evaluates the available ad space based on factors like user data, targeting parameters, historical performance and bid price. They submit their bid to the SDK.
  7. Winning bid selection: The SDK collects all the bids and selects the highest bidder as the winner of the auction.
  8. Ad creative delivery: The winning demand partner delivers the ad creative to the SDK.
  9. Ad rendering: The SDK renders and displays the winning ad creative within the app's designated ad slot.
  10. User interaction: The user interacts with the displayed ad (e.g., clicks on it).
  11. Reporting and tracking: The SDK tracks and reports data about the user's interaction with the ad (e.g., clicks, views) to both the app publisher and the winning demand partner.
  12. Revenue distribution: The app publisher earns revenue from the winning bid, which is typically shared with the ad network or exchange.

As we can see, in-app header bidding allows for a more competitive and transparent auction process compared to traditional waterfalling. It enables multiple demand sources to compete simultaneously for ad inventory, potentially leading to higher CPMs and increased revenue for app publishers.

Benefits of In-App Header Bidding

Now that you know what an in-app header is, we can go over all of the benefits you get by using this approach.

In-app header bidding relies on first-price auctions, meaning buyers place bids that show exactly how valuable each user is to them. There are multiple benefits of first-price auctions:

  • more transparency and operational stability in the process;
  • flexibility to integrate new demand partners easily;
  • higher bids on publisher’s inventory;
  • real-time competition.

However, the biggest advantage of them all comes from eliminating the waterfall’s ad network prioritization. In the waterfall, you either prioritize the networks yourself or let the historic data do it for you.

With in-app header bidding, the auction that takes place is simultaneous or parallel (unified auction). All ad networks get an equal chance of winning inventory (not just the preferred ones) and at a better-than-floor price.

It’s worth mentioning that once you replace SDK mediation with in-app header bidding, the number of SDKs you have to install goes down significantly. That equates to better user experience, fewer latency issues and far less maintenance required.

So, let's summarize the benefits:

  1. Increased competition: In-app header bidding allows multiple demand partners to bid simultaneously on ad inventory. This increases competition, which can lead to higher CPMs and greater revenue potential for publishers.
  2. Higher revenue: Due to increased competition and the ability to fetch higher bids, publishers often experience higher overall ad revenue compared to traditional ad waterfalling methods.
  3. Real-time decision making: In-app header bidding occurs in real-time, enabling publishers to make immediate decisions about which ad to display based on the highest bid.
  4. Transparent auction process: In-app header bidding provides transparency as all demand partners have equal visibility into the auction process, ensuring a fair and open competition for ad inventory.
  5. Reduced latency: In-app header bidding typically has lower latency compared to traditional waterfalling. This means faster ad load times for users, which can improve overall user experience.
  6. Access to premium demand: Publishers can connect with a wide range of premium demand partners, including ad exchanges, networks and SSPs, allowing them to access high-quality ads and advertisers.
  7. Flexible ad monetization: Publishers have the flexibility to manage and optimize their ad inventory based on their specific monetization goals and strategies.

Overall, in-app header bidding empowers publishers to maximize their ad revenue by creating a competitive and transparent auction environment, ultimately benefiting both publishers and advertisers.

In-App Header Bidding vs. Web Header Bidding

In the realm of programmatic advertising, both in-app header bidding and web header bidding play pivotal roles in optimizing ad revenue. However, they operate within distinct environments, each with its own set of considerations. Let's explore the key differences between these two powerful bidding techniques.

Aspect In-app header bidding Web header bidding
Environment Mobile applications Websites
Real-time auction Yes, on a user's device Yes, within the browser
Resource allocation Frees up local resources Consumes local resources
User experience Faster ad loading times Potential impact on page load times
Technical implementation Requires integration of SDK Involves implementation of header bidding wrappers or tags
Optimization Maximizes ad revenue for mobile app publishers Optimizes ad revenue for website publishers
Integration complexity Integrating SDK within the app may require development resources Integrating header bidding requires header bidding wrappers or tags in website's header

The fundamental process of header bidding in web environments and in-app header bidding in mobile applications is quite similar. The key distinction lies in the technical implementation and the specific tools used.

In web header bidding, the publisher integrates a JavaScript code (header bidding wrapper) into the header section of a webpage. This code sends out bid requests to demand partners, and the auction process occurs within the user's web browser. Header bidding wrappers manage multiple demand partners and simplify the implementation process.

In in-app header bidding, as we remember, a mobile application uses a SDK for communication. The SDK facilitates bid requests to multiple demand partners, and the auction process takes place on the user's device within the app.

Takeaway: While both in-app header bidding and web header bidding serve a common goal, they operate within distinct environments with unique technical considerations. The choice between the two depends on the platform (mobile app or website) and the specific optimization goals of publishers. By understanding the differences, publishers can leverage the strengths of each approach to enhance their programmatic advertising strategies and maximize ad revenue.

The Current State of Adoption

The in-app header bidding adoption rates were initially slow and nowhere near as high as rates on desktop and mobile browsers. This was mainly because of the difference in implementation, as in-app bidding required the use of a SDK rather than a simple insertion of JavaScript code.

However, by the third quarter of 2019, the adoption rate took off, and in-app header bidding spending doubled.

While the above statistic accounts only for North America and Western Europe, the Asia-Pacific region also saw a 50% increase in in-app header bidding spending. No matter the region we’re discussing, ad spend is higher than ever.

And, with programmatic ad spend predicted to increase to $168 billion by 2024 in the US, suffice it to say, the increasing adoption rate will continue for the foreseeable future.

Options for Setting Up In-App Header Bidding

There are two routes you can take to implement in-app header bidding:

  • build your own solution using open-source code;
  • find a partner who’s already built their own solution.

The first option involves creating a custom in-app header bidding solution using open-source code. This route requires a significant level of technical expertise and resources, as you'll be responsible for developing and maintaining the solution internally.

Alternatively, publishers can choose to partner with a third-party provider who has already developed their own n-app header bidding solution. This option allows publishers to leverage the expertise and technology of an established partner.

Deciding which path to take largely depends on the technical know-how of your team. If your focus is on advertising and you have the technical resources necessary to build your own header bidding system, then you should invest time and effort into creating your own solution.

However, not every publisher has the resources to dedicate to building an entire bidding environment. In that case, publishers can partner with a provider who has a pre-built in-app header solution. It’s best if it’s built on open-source code, such as Prebid.org, as it allows for maximum flexibility and compatibility.

Such a partner will be able to provide all of the in-app header bidding features that are in high demand, such as dynamic floor optimization, different performance campaigns and integration of all major ad networks.

Criteria Build your own solution Partner with existing solution
Technical expertise High level of technical expertise required Moderate technical expertise needed for integration
Development time Longer development timeline Shorter time to implementation
Customization control Full control over customization and features Limited customization based on partner's solution
Resource investment Requires significant internal resources Relies on external partner's resources
Maintenance responsibility In-house team responsible for maintenance Partner handles maintenance and updates
Costs Potentially higher upfront development costs May involve partnership fees or revenue share
Risk Higher risk of technical challenges and setbacks Lower risk as the partner's solution is proven
Time-to-market Longer time to market due to development process Faster time to market when leveraging existing solution
Scalability Can be tailored for specific scalability needs Relies on partner's solution scalability
Flexibility in partners Not tied to a specific third-party provider Limited to available partners and their solutions
In-house expertise Requires a dedicated team with specific knowledge Less internal expertise needed for integration

Bonus: Header Bidding vs. Unified Auction

Interestingly, header bidding paved the way for unified auctions. Unified auctions involve both direct-sold and programmatic demand that compete in a single auction to win an impression.

Unlike traditional header bidding, unified auctions are managed on the server-side, which leads to faster load times. Only one bidding session occurs per impression, ensuring efficiency. Google Exchange Bidding, now known as Open Bidding, is an example of a unified auction system running on Google AdX.


Is in-app header bidding suitable for all types of mobile apps?

Yes, in-app header bidding is suitable for a wide range of mobile apps, including gaming apps, news apps, social networking apps and many others. Publishers can implement in-app header bidding across various categories, provided that the app has a substantial user base and a significant volume of ad impressions.

Are there any potential drawbacks or challenges associated with implementing in-app header bidding?

Yes, there are potential challenges with implementing in-app header bidding. These may include the need for technical expertise, longer development timelines and the integration of multiple SDKs. Additionally, publishers should carefully consider the choice between building their own solution or partnering with an existing provider, as each option comes with its own set of considerations and trade-offs.

How does in-app header bidding contribute to increased competition and higher CPMs for publishers?

In-app header bidding increases competition and CPMs for publishers by allowing multiple demand sources to bid simultaneously on ad impressions. This leads to a more efficient auction process, driving up demand and ultimately resulting in higher CPMs for publishers. Additionally, the transparency and real-time nature of header bidding create a more competitive environment, attracting more demand from advertisers seeking to reach their target audiences effectively.

Can publishers use in-app header bidding in combination with other ad monetization strategies?

Yes, publishers can use in-app header bidding in conjunction with other ad monetization strategies. It can complement methods like ad mediation or waterfall setups. By incorporating in-app header bidding, publishers can diversify their revenue streams and potentially achieve higher yields from their ad inventory. This flexibility allows publishers to optimize their monetization approach to suit their specific app and audience.

What are some best practices for optimizing in-app header bidding setups?

Optimizing in-app header bidding setups involves several best practices:

  1. Implement pre-bid ad quality checks: Ensure that ads meet quality standards before they are sent for auction to maintain a positive user experience.
  2. Use smart timeouts: Set appropriate timeout values to prevent delays in ad delivery while allowing sufficient time for bids to be processed.
  3. Prioritize demand partners: Arrange demand partners based on historical performance and bid rates to maximize yield.
  4. Segment audiences: Customize setups for different user segments to deliver more relevant ads and increase engagement.
  5. Regularly monitor and analyze data: Keep a close eye on performance metrics and adjust settings accordingly to optimize revenue.
  6. Test and experiment: Continuously test different setups and configurations to find what works best for a specific app and audience.

By following these practices, publishers can enhance the effectiveness of their in-app header bidding implementations and maximize their revenue potential.

How can publishers measure the effectiveness and impact of in-app header bidding on their ad revenue?

Publishers can measure the effectiveness of in-app header bidding by analyzing key performance indicators (KPIs) such as:

  1. eCPM (Effective Cost Per Mille): Compare the eCPM achieved through header bidding against other monetization methods to assess its impact on revenue.
  2. Fill rate: Evaluate the percentage of ad requests filled with a paid ad, indicating how effectively header bidding is at monetizing the available ad inventory.
  3. Bid response time: Monitor the time it takes for demand partners to respond with bids, ensuring it aligns with user experience standards.
  4. Ad latency: Assess the time it takes for ads to load, as prolonged delays can negatively impact user experience and ad viewability.
  5. Overall ad revenue: Compare the total revenue generated through header bidding with revenue from other monetization methods to gauge its relative contribution.
  6. A/B testing: Conduct experiments where you compare the performance of header bidding against other setups to understand its specific impact on your app.

By analyzing these metrics, publishers can gain insights into how in-app header bidding is affecting their ad revenue and make informed decisions to optimize their monetization strategy further.


In-app header bidding represents a significant advancement in the realm of mobile app advertising. And while implementing it requires technical expertise, the benefits are substantial.

As in the case with browser header bidding, in-app bidding creates a more open and efficient ecosystem that benefits all parties involved. Both tech solutions reduce ad latency and enable all networks and exchange partners to bid on ad requests evenly, driving more revenue on the publisher side. With all of the advances and improvements in programmatic advertising, there’s simply no reason to still oppose its implementation in app environments.