Connect with us
Cloak And Track Your Affiliate Links With Our User-Friendly Link Cloaking Tool, Try It Free

SEO

What Is Header Bidding?

Published

on

What Is Header Bidding?

The header bidding technology started to develop in 2015, and has since helped many publishers to grow their revenue by as much as 40% (and even, in some cases, to levels of 100% or more.)

What Is Header Bidding?

Header bidding is a cutting-edge technique where publishers offer their ad inventory to many ad exchanges, also called Supply-Side Platforms (or SSPs), simultaneously before making calls to their ad servers.

Here are the steps a publisher needs to pass to have this technology power up its monetization.

  • Apply to SSP partners and get approval.
  • Implement Prebid.JS on website.
  • Configure ad server.
  • Choose a consent management system.
  • Test and debug.

Applying To SSP Partners

There are hundreds of SSP partners available in the list to apply, but I would like to mention what I believe to be the most popular ones:

  • TripleLift.
  • Index Exchange.
  • Amazon UAM/TAM.
  • Xandr (formerly AppNexus).
  • Teads.
  • Pubmatic.
  • Sovrn.
  • Verizon.
  • Magnite (formerly Rubicon).
  • OpenX.
  • Sonobi.
  • GumGum.
  • Sharethrough.
  • Unurly.

One needs to find their online application form and pass through the company’s verification process. For example, in the case of Xandr, the contact page looks like this:

Screenshot from Xandr, December 2022 Xandr tool

Pay attention to the minimum inventory size required to be eligible for applying.

Yes, that is a staggering high of 50M ad impressions a month.

You may need quite an impressive website to be able to apply to some of the ad networks. We will call them further bidders, as they bid on inventory in real time.

However, not all SSPs have such high thresholds for application. For example, Sharethrough only requires 20M ad impressions.

Besides, they consider also audience quality, traffic geolocation, how much time users spend on the website, etc.

It typically takes a few weeks after applying to be approved and onboarded with them, so it can be a fairly time-consuming process that may even take months to finish.

How Does Prebid.js Work?

In nutshell, here is how Prebid.js works.

When a user opens a webpage, an ad request is made to all bidders (SSP partners).

Bidders respond with their CPM bids – let’s say $1 and $1.50 – and Prebid.js makes a request to the ad server, with the highest CPM targeting. In this case, that would be $1.50.

At the ad server, in our case, Google Ad Manager, the request is received and it knows that someone is paying $1.50 USD CPM for an ad. It runs another auction with Google Adsense or AdX.

If Google offers a higher CPM, then the Google Ad will be served.

If not, our ad with $1.50 CPM will win, and be served by our SSP partner.

Header Bidding Working SchemeScreenshot from Google Ad Manager, December 2022Header Bidding Working Scheme

The trick here is that auctions happen in real-time, which creates buying pressure on Google AdX to pay the highest CPM possible.

If Google AdX doesn’t have any competition, it will offer the lowest CPM possible –as it wants to buy inventory for the cheapest price possible.

With header bidding, bidders are able to compete and push CPMs (and therefore revenue) up.

There are two ways to implement header bidding:

  • Client-side: When the auction runs via JavaScript in the browser.
  • Server-side: When the auction is run on the server.

Let’s discuss client-side header bidding.

How To Implement Client-Side Header Bidding

In order to set up header bidding, we need to implement Prebid.js on our website and configure our Google Ad Manager (or ad server).

Implement Prebid.js On Your Website

Prebid.js is a header bidding platform that has more than 200 demand sources integrated.

You need to select the SSP partners you are working with from the customize page and download the library built for your specific configuration.

Don’t forget to select Consent Management modules to comply with GDPR and GPP privacy standards.

Below is the sample code taken from the official documentation.

<html>

    <head>        
        <script async src="https://www.googletagservices.com/tag/js/gpt.js"></script>
        <script async src="https://your-customized-prebid.js"></script>
        <script>
            var div_1_sizes = [
                [300, 250],
                [300, 600]
            ];
            var div_2_sizes = [
                [728, 90],
                [970, 250]
            ];
            var PREBID_TIMEOUT = 1000;
            var FAILSAFE_TIMEOUT = 3000;

            var adUnits = [
                {
                    code: '/19968336/header-bid-tag-0',
                    mediaTypes: {
                        banner: {
                            sizes: div_1_sizes
                        }
                    },
                    bids: [{
                        bidder: 'appnexus',
                        params: {
                            placementId: 13144370
                        }
                    },
                     { 
                      bidder: "conversant",
                       params: {site_id:"122869",secure:1}
                     }
                   ]
                },
                {
                    code: '/19968336/header-bid-tag-1',
                    mediaTypes: {
                        banner: {
                            sizes: div_2_sizes
                        }
                    },
                    bids: [{
                        bidder: 'appnexus',
                        params: {
                            placementId: 13144370
                        }
                    },
                    { 
                     bidder: "conversant",
                     params: {site_id:"122869",secure:1}
                    }
                     ]
                }
            ];
            
            var googletag = googletag || {};
            googletag.cmd = googletag.cmd || [];
            googletag.cmd.push(function() {
                googletag.pubads().disableInitialLoad();
            });

            var pbjs = pbjs || {};
            pbjs.que = pbjs.que || [];

            pbjs.que.push(function() {
                pbjs.addAdUnits(adUnits);
                pbjs.requestBids({
                    bidsBackHandler: initAdserver,
                    timeout: PREBID_TIMEOUT
                });
            });

            function initAdserver() {
                if (pbjs.initAdserverSet) return;
                pbjs.initAdserverSet = true;
                googletag.cmd.push(function() {
                    pbjs.que.push(function() {
                        pbjs.setTargetingForGPTAsync();
                        googletag.pubads().refresh();
                    });
                });
            }
            // in case PBJS doesn't load
            setTimeout(function() {
                initAdserver();
            }, FAILSAFE_TIMEOUT);

            googletag.cmd.push(function() {
                googletag.defineSlot('/19968336/header-bid-tag-0', div_1_sizes, 'div-1').addService(googletag.pubads());
                googletag.pubads().enableSingleRequest();
                googletag.enableServices();
            });
            googletag.cmd.push(function() {
                googletag.defineSlot('/19968336/header-bid-tag-1', div_2_sizes, 'div-2').addService(googletag.pubads());
                googletag.pubads().enableSingleRequest();
                googletag.enableServices();
            });

        </script>

    </head>

    <body>
        <h2>Basic Prebid.js Example</h2>
        <h5>Div-1</h5>
        <div id='div-1'>
            <script type="text/javascript">
                googletag.cmd.push(function() {
                    googletag.display('div-1');
                });

            </script>
        </div>

        <br>

        <h5>Div-2</h5>
        <div id='div-2'>
            <script type="text/javascript">
                googletag.cmd.push(function() {
                    googletag.display('div-2');
                });

            </script>
        </div>

    </body>

</html>

Let’s break down the code above.

  • The first lines load all required JS files and our customized Prebid.JS file.
  • Ad slots are defined in the adUnits array variable.
  • In the adslot definitions, you can see the SSP partners’ names and IDs you will be given when onboarding when them.
  • googletag.pubads().disableInitialLoad(); is called to disable ad request to be sent to Google Ad Manager until Prebid.js finishes the auction.
  • pbjs.requestBids function calls SSP partners and determines the winner.
  • initAdserver() function is called to send an ad request to the Google Ad Manager with hb_pb key, which contains the winning CPM value, e.g. hb_pb=”1.5″. (This step is connected with setting up Google Ad Manager in the next step.)
  • When Google Ad Manager gets the request with the winning bid, it runs its own auction in Google AdX, and sends back either the AdX ad with a higher CPM, or the ad of the winning SSP.

For your specific case, you may need to code differently and change the setup, but the principle stays the same.

Other than that, I would like to quickly go over how to implement lazy loading, because it is a little different.

How To Implement Lazy Loading

The Google tag for publishers has a lazy loading framework which will not work in the case of header bidding.

This is because you need to run an auction, and determine and set key values before sending a request to the ad server.

Because of that, I would advise using the Intersection Observer API to determine when to load the ad in the HTML <div> tag when it is about to enter into the viewport.

options = {
root: null, // relative to document viewport
rootMargin: '1500px', // margin around root. Values are similar to css property. Unitless values not allowed
threshold: 0 // visible amount of item shown in relation to root
};

your_observer = new IntersectionObserver( observer_handler, options );
your_observer.observe( goog_adslots[i] );

In the observer_handler call back function, you can run the prebid auction and call the ad server.

function observer_handler( entries, observer ) {

dynamicAdUnit =[{
code: 'your_html_div_id',
mediaTypes: {
banner: {
sizes: [728,90]
}
},
bids: [{ bidder: 'appnexus', params: { placementId: 13144370 } }, { bidder: "conversant", params: {site_id:"122869",secure:1} } ]
}];

pbjs.addAdUnits(dynamicAdUnit);

slot = window.googletag.defineSlot('/1055389/header-bid-tag-0', [728,90], 'your_html_div_id' ).addService(googletag.pubads());

lazySlotPrebid(slot, 'your_html_div_id')

}

function lazySlotPrebid(slot, div_id) {

pbjs.que.push(function() {
pbjs.request bids({
timeout: PREBID_TIMEOUT,
adUnitCodes: [div_id],
bidsBackHandler: function() {
pbjs.setTargetingForGPTAsync([div_id]);
googletag.pubads().refresh(slot);

});
});

} 
}// endd of initDynamicSlotPrebid

Now, let’s jump on setting up the ad server using Google Ad Manager.

How To Set Up GAM For Header Bidding

Ad servers need to have dozens of price priority line items with key hb_pb targeting all possible CPM values, such as hb_pb=0.04, hb_pb=0.03, etc.

hb_pb key valueshb_pb key value targetinghb_pb key values

This is the key point that makes the header bidding engine work.

  • The auction runs in the browser on page load.
  • The winning SSP partner is sent to GAM with a key value targeting hb_pb = 2.62.
  • Since the order has the same CPM value, GAM understands that there is a bid at $2.62.
  • GAM runs an AdX auction and has to pay more than $2.62 in order to win the bid and display a Google Ad.

As I mentioned above, you would need to build line items in GAM with certain granularity, say 0.01 – and for the CPM range $0-$20, you would need to create 2,000 line items, which are impossible to do manually.

For that, you would need to use GAM API.

Unfortunately, there are no solid solutions that you can simply download and run in one click.

It is a somewhat complex task, but thanks to contributors who built API tools (even though they are not actively supporting them), we can still modify it a little and make it work.

Let’s dive into how to set up Google Ad Manager and understand the following:

Step 1: Enable API Access

In the Google Ad manager Global > General settings section, make sure API access is enabled.

Click on the Add service account button and create a user with the sample name “GAM API USER” and email “[email protected]” with admin rights.

GAM general settingsScreenshot from Google Ad Manager, December 2022GAM general settings

Step 2: Create A New Project

Navigate to Google API Console Credentials page.

From the project drop-down, choose Create a new project, enter a name for the project, and, optionally, edit the provided Project ID.

Click Create.

On the Credentials page, select Create credentials, then select Service account key.

Select New service account, and select JSON.

Click Create to download a file containing a private key.

Google API Console Credentials pageScreenshot from Google API Console Credentials page, Deccember 2022Google API Console Credentials page

 

Service account detailsScreenshot from Google API Console Credentials page, Deccember 2022Service account details
Fill in the service account details you’ve created above.

Assign the role “owner” and create the service account OAuth2 credentials.

Then, click on the created user and create JSON type key, and download it.

Service account JSON keyScreenshot from Google API Console Credentials page, Deccember 2022Service account JSON key

Step 3: Download Project

Download the project zip file and unzip it, directory (alternatively, you can use the git command tool to clone the repo).

Install composer for your operating system in order to build the project.

Step 4: Change your PHP.INI

Change your php.ini (located at /xampp/php/php.ini ) file and enable “extension=soap” by removing “;” in front of and set “soap.wsdl_cache_ttl=0” and restart Apache from the control panel of XAMPP.

Step 5: Create Subfolders And Build The Project

Once you have everything set up and unzipped, open composer.json file and change “googleads/googleads-php-lib”: “^44.0.0” to use the latest version “googleads/googleads-php-lib”: “^59.0.0”.

Check for the most fresh version at the moment you perform this.

Search and replace in /app/ folder of the project “v201911” with “v202202”, because that git project wasn’t updated since 2019, to use the latest version path of libraries.

Open the command line of your PC and switch to the directory where you’ve unzipped the files (using cd command or right-click inside the folder “Git bash here” if you have git installed), and run composer update in the PC terminal or git terminal.

It will create subfolders and build the project.

Step 6: Set Up Your Google Ad Manager Credentials

Move the downloaded JSON key “gam-api-54545-0c04qd8fcb.json”  file into the root folder of the project you’ve built.

Next, download adsapi_php.ini file and set up your Google Ad Manager credentials in it.

networkCode = "899899"
applicationName = "My GAM APP"
jsonKeyFilePath = "D:xampphtdocsdfp-prebid-lineitemsgam-api-54545-0c04qd8fcb.json"
scopes = "https://www.googleapis.com/auth/dfp"
impersonatedEmail = "[email protected]"

jsonKeyFilePath is the absolute directory path to the JSON key file in the folder root.

Step 7: Set The Content Of The File

Finally, navigate to the file /script/tests/ConnexionTest.php and set the content of the file like below:

putenv('HOME='.dirname(__DIR__)."/../");
require __DIR__.'/../../vendor/autoload.php';

$traffickerId = (new AppAdManagerUserManager())->getUserId();

if (is_numeric($traffickerId)) {
echo "n====Connexion OK====nn";
} else {
echo "n===Connexion KO====nn";
}

In your terminal (or git bash console) test the connection by running the command (if you are in the /script/tests/ folder).

php ConnexionTest.php

You should see a message “====Connection OK====”

Step 8: Configure The Parameters

Navigate to the file /script/tests/ConnexionTest.php in your project and open it.

Copy and paste the below code into that file, and configure the parameters in the $entry and $buckets arrays per your needs.

putenv('HOME='.dirname(__DIR__)."/../");
require __DIR__.'/../../vendor/autoload.php';

use AppScriptsHeaderBiddingScript;

$bucket_range = array();
$Your_Advertiser_Name="Sample_Advertiser";
$buckets =
["buckets" =>[
['precision' => 2, 'min' => 0, 'max' => 4.00, 'increment' => 0.01],
['precision' => 2, 'min' => 4.01, 'max' => 8.00, 'increment' => 0.05],
]
];

foreach ( $buckets["buckets"] as $k => $bucket ){

$request_bucket = array( 'buckets' => array( $bucket ) );

$order_name="Your_Order_name ".$bucket['min'].'-'.$bucket['max'];
// echo $order_name.'<br/><br/>';


$entry = [
'priceGranularity' => $request_bucket, // can be 'low', 'med', 'high', 'auto','dense', 'test'
'currency' => 'USD',
//'sizes' => [ [1,1] ,[160, 600], [250, 250], [300, 250], [300, 600], [320, 50], [320, 100], [300, 100], [336, 280], [728, 90], [970, 90], [970, 250]],
'sizes' => [ [250, 250] ],
'orderPrefix' => $Your_Advertiser_Name, //prebid advertiserName
'orderName' => $order_name
];
$script = new HeaderBiddingScript();
$script->createGlobalAdUnits($entry);

}

Optionally you can also specify ‘geoTargetingList’ => “dz, pk, ke, pt” or custom key value targeting customTargeting’ => [‘amp_pages’ => yes’] if you want your header bidding to work only when the custom key value is set.

Run the command below and it will start creating line items per the bucket settings you’ve specified.

php ConnexionTest.php

There is a tool using Python that is used similarly; you may want to give it a try as well.

Debugging

For debugging, there are a few browser add-ons you can use to see if the auction runs without errors.

Alternatively, open your webpage URL using “/?pbjs_debug=true” parameter at the end of the URL, and watch console logs messages.

You need to make sure that hb_pb key values are passed to Google Ad Manager. Use “/?google_console=1” at the end of the URL to open the GAM console, and click on “Delivery Diagnostics” of each ad unit.

You should see that hb_pb values are set and passed to the ad server.

GAM Deliver DiagnositcsScreenshot from Google API Console Credentials page, Deccember 2022GAM Deliver Diagnositcs

Choose A Consent Management System

Users’ privacy is one of the most important factors, and you want to make sure that you comply with both GDPR and GPP.

The detailed instructions on how to set up a consent management system in your wrapper are here.

There are many providers which comply with IAB’s latest standards, and here are a few of the most popular ones:

Conclusion

You may find it surprising that setting up header bidding involves so many steps, but it is really worth it to implement. It can easily boost your revenue by +30% or more by creating selling pressure on Google Ads.

This guide is for technically savvy users – but if you have questions and issues, there is an Adops slack channel you may subscribe to and ask questions to the community.

I hope that after reading this article, you will find it easier to set up header bidding and enhance the monetization of your website.

More resources:


Featured Image: Search Engine Journal

var s_trigger_pixel_load = false;
function s_trigger_pixel(){
if( !s_trigger_pixel_load ){
setTimeout(function(){ striggerEvent( ‘load2’ ); }, 500);
window.removeEventListener(“scroll”, s_trigger_pixel, false );
console.log(‘s_trigger_pixel’);
}
s_trigger_pixel_load = true;
}
window.addEventListener( ‘scroll’, s_trigger_pixel, false);

window.addEventListener( ‘load2’, function() {

if( sopp != ‘yes’ && addtl_consent != ‘1~’ && !ss_u ){

!function(f,b,e,v,n,t,s)
{if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};
if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version=’2.0′;
n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];
s.parentNode.insertBefore(t,s)}(window,document,’script’,
‘https://connect.facebook.net/en_US/fbevents.js’);

if( typeof sopp !== “undefined” && sopp === ‘yes’ ){
fbq(‘dataProcessingOptions’, [‘LDU’], 1, 1000);
}else{
fbq(‘dataProcessingOptions’, []);
}

fbq(‘init’, ‘1321385257908563’);

fbq(‘track’, ‘PageView’);

fbq(‘trackSingle’, ‘1321385257908563’, ‘ViewContent’, {
content_name: ‘header-bidding’,
content_category: ‘programmatic’
});
}
});

Source link

Keep an eye on what we are doing
Be the first to get latest updates and exclusive content straight to your email inbox.
We promise not to spam you. You can unsubscribe at any time.
Invalid email address

SEO

Google’s Web Crawler Fakes Being “Idle” To Render JavaScript

Published

on

By

Google's Web Crawler Fakes Being "Idle" To Render JavaScript

In a recent episode of the Search Off The Record podcast, it was revealed that Google’s rendering system now pretends to be “idle” to trigger certain JavaScript events and improve webpage rendering.

The podcast features Zoe Clifford from Google’s rendering team, who discussed how the company’s web crawlers deal with JavaScript-based sites.

This revelation is insightful for web developers who use such methods to defer content loading.

Google’s “Idle” Trick

Googlebot simulates “idle” states during rendering, which triggers JavaScript events like requestIdleCallback.

Developers use this function to defer loading less critical content until the browser is free from other tasks.

Before this change, Google’s rendering process was so efficient that the browser was always active, causing some websites to fail to load important content.

Clifford explained:

“There was a certain popular video website which I won’t name…which deferred loading any of the page contents until after requestIdleCallback was fired.”

Since the browser was never idle, this event wouldn’t fire, preventing much of the page from loading properly.

Faking Idle Time To Improve Rendering

Google implemented a system where the browser pretends to be idle periodically, even when it’s busy rendering pages.

This tweak ensures that idle callbacks are triggered correctly, allowing pages to fully load their content for indexing.

Importance Of Error Handling

Clifford emphasized the importance of developers implementing graceful error handling in their JavaScript code.

Unhandled errors can lead to blank pages, redirects, or missing content, negatively impacting indexing.

She advised:

“If there is an error, I just try and handle it as gracefully as possible…web development is hard stuff.”

What Does This Mean?

Implications For Web Developers

  • Graceful Error Handling: Implementing graceful error handling ensures pages load as intended, even if certain code elements fail.
  • Cautious Use of Idle Callbacks: While Google has adapted to handle idle callbacks, be wary of over-relying on these functions.

Implications For SEO Professionals

  • Monitoring & Testing: Implement regular website monitoring and testing to identify rendering issues that may impact search visibility.
  • Developer Collaboration: Collaborate with your development team to create user-friendly and search engine-friendly websites.
  • Continuous Learning: Stay updated with the latest developments and best practices in how search engines handle JavaScript, render web pages, and evaluate content.

See also: Google Renders All Pages For Search, Including JavaScript-Heavy Sites

Other Rendering-Related Topics Discussed

The discussion also touched on other rendering-related topics, such as the challenges posed by user agent detection and the handling of JavaScript redirects.

The whole podcast provides valuable insights into web rendering and the steps Google takes to assess pages accurately.

See also: Google Renders All Pages For Search, Including JavaScript-Heavy Sites


Featured Image: fizkes/Shutterstock

Source link

Keep an eye on what we are doing
Be the first to get latest updates and exclusive content straight to your email inbox.
We promise not to spam you. You can unsubscribe at any time.
Invalid email address
Continue Reading

SEO

Google’s Indifference To Site Publishers Explained

Published

on

By

Google inadvertently reveals reasons that explain their seeming indifference to publishers hurt by algorithm updates

A publisher named Brandon Saltalamacchia interviewed Google’s SearchLiaison in which he offered hope that quality sites hit by Google’s algorithms may soon see their traffic levels bounce back. But that interview and a recent Google podcast reveal deeper issues that may explain why Google seems indifferent to publishers with every update.

Google Search Relations

Google has a team whose job is to communicate how site owners can do well on Google. So it’s not that Googlers themselves are indifferent to site publishers and creatives. Google provides a lot of feedback to publishers, especially through Google Search Console. The area in which Google is indifferent to publishers is directly in search at its most fundamental level.

Google’s algorithms are built on the premise that it has to provide a good user experience and is internally evaluated to that standard. This creates the situation where from Google’s perspective the algorithm is working the way it should. But from the perspective of website publishers Google’s ranking algorithms are failing. Putting a finger on why that’s happening is what this article is about.

Publishers Are Not Even An Afterthought To Google

The interview by Brandon Saltalamacchia comes against the background of many websites having lost traffic due to Google’s recent algorithm updates. From Google’s point of view their algorithms are working fine for users. But the steady feedback from website publishers is no, it’s not working. Google’s response for the past month is that they’re investigating how to improve.

What all of this reveals is that there is a real disconnect between how Google measures how their algorithms are working and how website publishers experience it in the real world. It may surprise most people to learn that that this disconnect begins with Google’s mission statement to make information “universally accessible and useful”  and ends with the rollout of an algorithm that is tested for metrics that take into account how users experience it but is 100% blind to how publishers experience it.

Some of the complaints about Google’s algorithms:

  • Ranking algorithms for reviews, travel and other topics are favoring big brands over smaller publishers.
  • Google’s decision to firehose traffic at Reddit contributes to the dismantling of the website publishing ecosystem.
  • AI Overviews summarizes web pages and deprives websites of search traffic.

The stated goal for Google’s algorithm decisions is to increase user satisfaction but the problem with that approach is that website publishers are left out of that equation.  Consider this: Google’s Search Quality Raters Guidelines says nothing about checking if big brands are dominating the search results. Zero.

Website publishers aren’t even an afterthought for Google. Publishers are not not considered at any stage of the creation, testing and rollout of ranking algorithms.

Google Historically Doesn’t Focus On Publishers

A remark by Gary Illyes in a recent Search Off The Record indicated that in Gary’s opinion Google is all about the user experience because if search is good for the user then that’ll trickle down to the publishers and will be good for them too.

In the context of Gary explaining whether Google will announce that something is broken in search, Gary emphasized that search relations is focused on the search users and not the publishers who may be suffering from whatever is broken.

John Mueller asked:

“So, is the focus more on what users would see or what site owners would see? Because, as a Search Relations team, we would focus more on site owners. But it sounds like you’re saying, for these issues, we would look at what users would experience.”

Gary Illyes answered:

“So it’s Search Relations, not Site Owners Relations, from Search perspective.”

Google’s Indifference To Publishers

Google’s focus on satisfying search users can in practice turn into indifference toward publishers.  If you read all the Google patents and research papers related to information retrieval (search technology) the one thing that becomes apparent is that the measure of success is always about the users. The impact to site publishers are consistently ignored. That’s why Google Search is perceived as indifferent to site publishers, because publishers have never been a part of the search satisfaction equation.

This is something that publishers and Google may not have wrapped their minds around just yet.

Later on, in the Search Off The Record  podcast, the Googlers specifically discuss how an update is deemed to be working well regardless if a (relatively) small amount of publishers are complaining that Google Search is broken, because what matters is if Google perceives that they are doing the right thing from Google’s perspective.

John said:

“…Sometimes we get feedback after big ranking updates, like core updates, where people are like, “Oh, everything is broken.”

At the 12:06 minute mark of the podcast Gary made light of that kind of feedback:

“Do we? We get feedback like that?”

Mueller responded:

“Well, yeah.”

Then Mueller completed his thought:

“I feel bad for them. I kind of understand that. I think those are the kind of situations where we would look at the examples and be like, “Oh, I see some sites are unhappy with this, but overall we’re doing the right thing from our perspective.”

And Gary responded:

“Right.”

And John asks:

“And then we wouldn’t see it as an issue, right?”

Gary affirmed that Google wouldn’t see it as an issue if a legit publisher loses traffic when overall the algorithm is working as they feel it should.

“Yeah.”

It is precisely that shrugging indifference that a website publisher, Brandon Saltalamacchia, is concerned about and discussed with SearchLiaison in a recent blog post.

Lots of Questions

SearchLiaison asked many questions about how Google could better support content creators, which is notable because Google has a long history of focusing on their user experience but seemingly not also considering what the impact on businesses with an online presence.

That’s a good sign from SearchLiaison but not entirely a surprise because unlike most Googlers, SearchLiaison (aka Danny Sullivan) has decades of experience as a publisher so he knows what it’s like on our side of the search box.

It will be interesting if SearchLiaison’s concern for publishers makes it back to Google in a more profound way so that there’s a better understanding that the Search Ecosystem is greater than Google’s users and encompasses website publishers, too. Algorithm updates should be about more than how they impact users, the updates should also be about how they impact publishers.

Hope For Sites That Lost Traffic

Perhaps the most important news from the interview is that SearchLiaison expressed that there may be changes coming over the next few months that will benefit the publishers who have lost rankings over the past few months of updates.

Brandon wrote:

“One main take away from my conversation with Danny is that he did say to hang on, to keep doing what we are doing and that he’s hopeful that those of us building great websites will see some signs of recovery over the coming months.”

Yet despite those promises from Danny, Brandon didn’t come away with hope.

Brandon wrote:

“I got the sense things won’t change fast, nor anytime soon. “

Read the entire interview:

A Brief Meeting With Google After The Apocalypse

Listen to the Search Off The Record Podcast

Featured Image by Shutterstock/Roman Samborskyi

Source link

Keep an eye on what we are doing
Be the first to get latest updates and exclusive content straight to your email inbox.
We promise not to spam you. You can unsubscribe at any time.
Invalid email address
Continue Reading

SEO

20 Confirmed Facts About YouTube’s Algorithm

Published

on

By

20 Confirmed Facts About YouTube's Algorithm

Instead of counting the number of clicks or views a video gets, YouTube’s algorithms focus on ensuring viewers are happy with what they watch.

This article examines how YouTube’s algorithms work to help users find videos they like and keep them watching for longer.

We’ll explain how YouTube selects videos for different parts of its site, such as the home page and the “up next” suggestions.

We’ll also discuss what makes some videos appear more than others and how YouTube matches videos to each person’s interests.

By breaking this down, we hope to help marketers and YouTubers understand how to work better with YouTube’s system.

A summary of all facts is listed at the end.

Prioritizing Viewer Satisfaction

Early on, YouTube ranked videos based on watch time data, assuming longer view durations correlated with audience satisfaction.

However, they realized that total watch time alone was an incomplete measure, as viewers could still be left unsatisfied.

So, beginning in the early 2010s, YouTube prioritized viewer satisfaction metrics for ranking content across the site.

The algorithms consider signals like:

  • Survey responses directly asking viewers about their satisfaction with recommended videos.
  • Clicks on the “like,” “dislike,” or “not interested” buttons which indicate satisfaction.
  • Overall audience retention metrics like the percentage of videos viewed.
  • User behavior metrics, including what users have watched before (watch history) and what they watch after a video (watch next).

The recommendation algorithms continuously learn from user behavior patterns and explicit satisfaction inputs to identify the best videos to recommend.

How Videos Rank On The Homepage

The YouTube homepage curates and ranks a selection of videos a viewer will most likely watch.

The ranking factors include:

Performance Data

This covers metrics like click-through rates from impressions and average view duration. When shown on its homepages, YouTube uses these traditional viewer behavioral signals to gauge how compelling a video is for other viewers.

Personalized Relevance

Besides performance data, YouTube relies heavily on personalized relevance to customize the homepage feed for each viewer’s unique interests. This personalization is based on insights from their viewing history, subscriptions, and engagement patterns with specific topics or creators.

How YouTube Ranks Suggested Video Recommendations

The suggested videos column is designed to keep viewers engaged by identifying other videos relevant to what they’re currently watching and aligned with their interests.

The ranking factors include:

Video Co-Viewing

YouTube analyzes viewing patterns to understand which videos are frequently watched together or sequentially by the same audience segments. This allows them to recommend related content the viewer will likely watch next.

Topic/Category Matching

The algorithm looks for videos covering topics or categories similar to the video being watched currently to provide tightly relevant suggestions.

Personal Watch History

A viewer’s viewing patterns and history are a strong signal for suggesting videos they’ll likely want to watch again.

Channel Subscriptions

Videos from channels that viewers frequently watch and engage with are prioritized as suggestions to keep them connected to favored creators.

External Ranking Variables

YouTube has acknowledged the following external variables can impact video performance:

  • The overall popularity and competition level for different topics and content categories.
  • Shifting viewer behavior patterns and interest trends in what content they consume.
  • Seasonal effects can influence what types of videos people watch during different times of the year.

Being a small or emerging creator can also be a positive factor, as YouTube tries to get them discovered through recommendations.

The company says it closely monitors success rates for new creators and is working on further advancements like:

  • Leveraging advanced AI language models to better understand content topics and viewer interests.
  • Optimizing the discovery experience with improved layouts and content pathways to reduce “choice paralysis.”

Strategies For Creators

With viewer satisfaction as the overarching goal, this is how creators can maximize the potential of having their videos recommended:

  • Focus on creating content that drives high viewer satisfaction through strong audience retention, positive survey responses, likes/engagement, and low abandon rates.
  • Develop consistent series or sequel videos to increase chances of being suggested for related/sequence views.
  • Utilize playlists, end screens, and linked video prompts to connect your content for extended viewing sessions.
  • Explore creating content in newer formats, such as Shorts, live streams, or podcasts, that may align with changing viewer interests.
  • Monitor performance overall, specifically from your existing subscriber base as a baseline.
  • Don’t get discouraged by initial metrics. YouTube allows videos to continuously find relevant audience segments over time.
  • Pay attention to seasonality trends, competition, and evolving viewer interests, which can all impact recommendations.

In Summary – 20 Key Facts About YouTube’s Algorithm

  1. YouTube has multiple algorithms for different sections (homepage, suggested videos, search, etc.).
  2. The recommendation system powers the homepage and suggested video sections.
  3. The system pulls in videos that are relevant for each viewer.
  4. Maximizing viewer satisfaction is the top priority for rankings.
  5. YouTube uses survey responses, likes, dislikes, and “not interested” clicks to measure satisfaction.
  6. High audience retention percentages signal positive satisfaction.
  7. Homepage rankings combine performance data and personalized relevance.
  8. Performance is based on click-through rates and average view duration.
  9. Personalized relevance factors include watch history, interests, and subscriptions.
  10. Suggested videos prioritize content that is co-viewed by the same audiences.
  11. Videos from subscribed channels are prioritized for suggestions.
  12. Consistent series and sequential videos increase suggestions for related viewing.
  13. Playlists, end screens, and linked videos can extend viewing sessions.
  14. Creating engaging, satisfying content is the core strategy for recommendations.
  15. External factors like competition, trends, and seasonality impact recommendations.
  16. YouTube aims to help new/smaller creators get discovered through recommendations.
  17. AI language models are improving content understanding and personalization.
  18. YouTube optimizes the discovery experience to reduce “choice paralysis.”
  19. Videos can find audiences over time, even if initial metrics are discouraging.
  20. The algorithm focuses on delivering long-term, satisfying experiences for viewer retention.

Insight From Industry Experts

While putting together this article, I reached out to industry experts to ask about their take on YouTube’s algorithms and what’s currently working for them.

Greg Jarboe, the president and co-founder of SEO-PR and author of YouTube and Video Marketing, says:

“The goals of YouTube’s search and discovery system are twofold: to help viewers find the videos they want to watch, and to maximize long-term viewer engagement and satisfaction. So, to optimize your videos for discovery, you should write optimized titles, tags, and descriptions. This has been true since July 2011, when the YouTube Creator Playbook became available to the public for the first time.

However, YouTube changed its algorithm in October 2012 – replacing ‘view count’ with ‘watch time.’ That’s why you need to go beyond optimizing your video’s metadata. You also need to keep viewers watching with a variety of techniques. For starters, you need to create a compelling opening to your videos and then use effective editing techniques to maintain and build interest through the video.

There are other ranking factors, of course, but these are the two most important ones. I’ve used these video SEO best practices to help the Travel Magazine channel increase from just 1,510 to 8.7 million views. And these video SEO techniques help the SonoSite channel grow from 99,529 views to 22.7 million views.

The biggest recent trend is the advent of YouTube Shorts, which is discoverable on the YouTube homepage (in the new Shorts shelf), as well as across other parts of the app. For more details, read “Can YouTube Shorts Be Monetized? Spoiler Alert: Some Already Are!

Brie E. Anderson, an SEO and digital marketing consultant, says:

“In my experience, there are a few things that are really critical when it comes to optimizing for YouTube, most of which won’t be much of a surprise. The first is obviously the keyword you choose to target. It’s really hard to beat out really large and high authority channels, much like it is on Google. That being said, using tools like TubeBuddy can help you get a sense of the keywords you can compete for.

Another big thing is focusing on the SERP for YouTube Search. Your thumbnail has to be attention-grabbing – this is honestly what we test the most and one of the most impactful tests we run. More times than not, you’re looking at a large face, and max four words. But the amount of contrast happening in the thumbnail and how well it explains the topic of the video is the main concern.

Also, adding the ‘chapters’ timestamps can be really helpful. YouTube actually shows these in the SERP, as mentioned in this article.

Lastly, providing your own .srt file with captions can really help YouTube understand what your video is about.

Aside from actual on-video optimizations, I usually encourage people to write blog posts and embed their videos or, at the very least, link to them. This just helps with indexing and building some authority. It also increases the chance that the video will help YOUR SITE rank (as opposed to YouTube).”

Sources: YouTube’s Creator Insider Channel (1, 2, 3, 4, 5, 6), How YouTube Works

More resources: 


Featured Image: Roman Samborskyi/Shutterstock

Source link

Keep an eye on what we are doing
Be the first to get latest updates and exclusive content straight to your email inbox.
We promise not to spam you. You can unsubscribe at any time.
Invalid email address
Continue Reading

Trending