A cache-buster is a unique piece of code that prevents a browser from reusing an ad it has already seen and cached, or saved, to a temporary memory file.
What Does a Cache-Buster Do?
The cache-buster doesn’t stop a browser from caching the file, it just prevents it from reusing it. In most cases, this is accomplished with nothing more than a random number inserted into the ad tag on each page load. The random number makes every ad call look unique to the browser and therefore prevents it from associating the tag with a cached file, forcing a new call to the ad server.
Cache-busting maximizes publisher inventory, keeps the value and meaning of an impression constant, and helps minimize discrepancies between Publisher and Marketer delivery reports.
What Does a Cache-Buster Code Look Like?
Typically, a java script function like the one below powers a cache buster. An example of a cache buster looks like this:
<script type="text/javascript" language="JavaScript">
ord=Math.random()*10000000000000000;
</script>
This code is put toward the top of the page within the site’s <body> tag and creates a random number for the “ord” value in the ad tag. So, when a browser hits a tag, it builds the ad tag like this -
http://ad.doubleclick.net/ABC/publisher/zone;topic=abc;sbtpc=def;cat=ghi;kw=xyz;tile=1;slot=728x90.1;sz=728x90;ord=7268140825331981?
If the browser then returns to the same page later on, the same tag might look like this, where everything remains the same except for the random number.
http://ad.doubleclick.net/ABC/publisher/zone;topic=abc;sbtpc=def;cat=ghi;kw=xyz;tile=1;slot=728x90.1;sz=728x90;ord=6051834582234?
Why Does a Browser Cache in the First Place?
When a browser navigates to a web page today, the Publisher’s Content Server sends it an HTML file with instructions on how to format the page and where to retrieve all the images, text, and other pieces of the page. Downloading this information all takes time and memory to accomplish for the browser, so it tries to save as much of the information as possible for future use in temporary folders (the cache) on a user’s hard drive.
This technique lets a browser surf through a website much faster. It’s less important in an age of high speed fiber optic connections, but made a huge difference in the days of 56K modems, when each page took seconds if not minutes to load. And, since most web pages are built on templates, many elements of a site are used on every page, for example, the site’s logo. Why fetch the same image again and again when the browser can save it once, and simply reference the same file on every page? The browser is smart enough to read the HTML code for each page and recognize what content it already has and just skip to the next line of code to look for the unique and previously unseen data.
This would certainly work for the ads on the page, too. If a user loaded a publisher’s homepage for example, then went to an article page, then back to the homepage, the ad tag would be exactly the same and the browser would just re-use the ad it called the first time if a cache-buster was not implemented. Since Publishers get paid for every impression though, they don’t want this to happen, they want the browser to call or consume another impression so they can charge for it. Advertisers might like the idea of free impressions, but when pressed, most would tell you cache-busting is a good thing for them, too. Recycled ads screw up reports, mess with ROI calculations, and add an uncertainty factor to campaign data, not to mention create tension between Publishers and Advertisers via discrepancies.
In fact, if you are having an issue with 3rd party discrepancies where the publisher numbers are much higher than the advertiser numbers, the first thing you should check is that a cache-buster is in place and working.
{ 3 comments… read them below or add one }
I don’t know if I agree with that. That might bust the doubleclick cache, but not the browser cache
I mean even though the javascript is generating a random number, it is loading the same script
”
ord=Math.random()*10000000000000000;
”
to bust a browser cache, I thought a tried an true method was adding a query param to the src or href attribute, as is done in your blog:
Well it’s certainly true there is one method – a query string will do the trick, too, and is probably more common among dynamic web pages from a content point of view, but in terms of ads, I think you’ll typically see the random number generator technique. The reason being is that because the systems that produce the ad are often owned by more than one company, so they need a static URL to reference. You can often find the ad’s location on the CDN, such as an Akamai by looking at the src, and because that address is static, you have to make something else about the call dynamic. Since DoubleClick’s DFP product is one of the most common adservers out there and has perhaps the most transparent cache buster, I wanted to showcase that method in particular.
{ 1 trackback }