WO2014068340A1

WO2014068340A1 - Sytem and method for processing content of a web resource for display

Info

Publication number: WO2014068340A1
Application number: PCT/GB2013/052882
Authority: WO
Inventors: Andy Evans; Babac VAFAEY
Original assignee: Net Communities Limited
Priority date: 2012-11-02
Filing date: 2013-11-04
Publication date: 2014-05-08
Also published as: EP2915072A1; GB201219787D0; WO2014068340A9

Abstract

Systems and methods are disclosed for processing content of a web resource for display, where the web resource has at least one dimension exceeding an initial viewable area of a browser of a display device. The web resource is retrieved and information from the web resource rendered in the browser. However, rendering of a content unit for a portion of the web resource outside the initial viewable area is delayed. An event is detected indicating a change of the initial viewable area to a secondary viewable area and, on detection of the event, the content unit is rendered. The secondary viewable area may contain that outside portion of the web resource. The event may be triggered by a user, for example by a user interaction with a rendered web resource, and may be a movement event, such as a scroll event.

Description

SYTEM AND METHOD FOR PROCESSING CONTENT OF A WEB RESOURCE FOR DISPLAY

FIELD OF THE INVENTION

The present invention relates to systems and methods for processing content of a web resource, such as a webpage, for display. In particular, the present invention relates to online advertising in instances where a webpage extends beyond the dimensions of the display device being used to view the webpage.

BACKGROUND OF THE INVENTION Web resources of different types, such as webpages, video, images and other media, and the like can be accessed over the internet and via other network types, such as private networks. Webpages display various types of content on loading in a web browser, such as text, images, framed content and the like. One such type of content commonly written into webpages is advertising - usually displaying an advertisement (an "advert", or "ad").

Online display advertising is the oldest form of online advertising, and is currently worth an estimated $25 Billion globally, and is expected to grow to $200 Billion by 2017.

An example of online advertising display is the delivery of IAB (Internet

Advertising Bureau) banner advertisements in pre-defined ad placements across web pages. Ad placements are delivered and served by a specified ad server. An ad server distributes the relevant advertisement to a user based on pre- defined criteria (such as IP address), counts them and provides both buy and sell sides with performance information.

An ad server typically delivers advertisements when an ad placement code is inserted into the script of a webpage and then is subsequently called when a webpage is loaded. Currently when a page loads, all ad placements on the page will usually automatically load and ads will be delivered in all ad placements, irrespective of where the ads sit on the page, or the visitor's location on the website. A relatively key limitation of this current approach is that a large portion of advertising units are delivered 'below the fold,' and they are delivered whether or not the user scrolls down the website to where the advertisements are located.

As a result ad inventory sold 'below the fold' (BTF) is commonly regarded, as inferior as unlike 'above the fold' (ATF) inventory an advertiser is uncertain as to whether or not inventory served below the fold is actually 'viewed' by a visitor.

One of the ways of mitigating the risk of wastage and to bring CPMs - Cost Per Mille, or cost per thousand served, the de facto currency of trade for online banner inventory - for 'ATF' and 'BTF' more in-line is the current industry movement towards 'viewable' impressions, spearheaded by the IAB (Internet Advertising Bureau). This movement started in early 201 1 as advertisers & publishers became increasingly aware of the difference between a 'delivered' impression and a 'viewed' impression (as described above). There are conflicting reports as to the exact extent of the problem, but from research conducted by analytics companies the number of ads served that were never viewed can range between 40-80%. Of course, this can fluctuate based on a number of variables such as CPM rate, vendor, format and the like.

There are currently numerous vendors in the industry who are pushing for the adoption of a new standard for buying and selling online media - CPMv (cost per thousand viewed) as opposed to CPM (cost per thousand served). The IAB is continuously refining the definition but at present a viewable impression is set as an ad unit for which over 50% of the ad unit is in view for one second or more. As the industry moves towards a model for buying and selling inventory on a CPMv basis there are numerous vendors in the marketplace with solutions to enable this change. These vendor solutions can broadly be divided into two category types: a) Those that simply count viewable impressions but do not affect delivery.

b) Those that directly affect ad delivery, to only serve viewable impressions.

In the first instance (a), the solutions allow both advertisers and publishers to understand how much of their inventory is 'viewed', by determining whether an ad has been viewed or not viewed on an individual basis.

However the unifying factor with all of these solutions, is that they merely act as a counter and the ad inventory is still served in much the same way when a web pages loads. In other words, un-viewed ads are still served, however they are deemed as un-viewed and therefore potentially not sold on a CPMv basis. The limitations of this approach are clear - there is still huge ad wastage along with unnecessary ad and server loads.

The latter group of vendors (b) have developed solutions to counter these potential limitations by restricting delivery of ad placements to occur only in instances when the user's screen has become 'in-view'. By 'in-view' it is meant that the user arrives on the section of the webpage where the ad placement is located, so that the display device being used to view the (whole) webpage is currently displaying that ad placement on that section of the webpage. It is at the point that the user becomes 'in-view' that the advertisement is then called from the ad server and the ad is fully loaded. This method therefore ensures that all requests to the ad server are made when the website visitor has a verified opportunity to see the advertisement.

Typically vendors who offer this type of solution employ methods to achieve this which could be either a combination of script code (such as Javascript™), HTML5 or Flash® delivered independently or within an iframe. While group (b) clearly solve some of the limitations with group (a), various limitations still exist. For example, to deliver multiple ad placements below the fold on a viewable basis, users will have to manually set up numerous placement codes and insert these in areas of the site where they intend them to load. This is a lengthy approach and will typically not enable publishers, for example, to monetise webpages that dynamically change in length, as at the time of insertion the page length is unknown. This is particularly an issue for websites which have heavy user engagement -such as a newspaper articles, or those that enable comment features. These pages are likely to change multiple times from the point of original publication, leaving large amounts of whitespace. The current solutions that exist are not able to detect this whitespace and deliver an appropriate ad when an opportunity to see it arises, and therefore the publisher will not be able to monetise various portions of their own site.

The previously considered solutions can also be computationally intensive, wasting resources available for rendering the webpage(s). Other previously considered solutions can be unreliable in determining whether the ad is in fact viewable, leading to difficulty in efficiently tracking the number of impressions. Others may require re-writing each individual element of a webpage, a further waste of resources.

Other previously considered methods have addressed dynamically generated webpages, however these have either not considered problems of content insertion (such as ad placement ), or do not address how to account for content which may already have been committed for inclusion in the ultimate webpage dynamically generated, but is nevertheless not currently present in-view, or in an initial static page. It is an object of the present invention to overcome or substantially mitigate the above mentioned problems. STATEMENT OF INVENTION

Aspects and embodiments of the invention are set out in the accompanying claims.

In general terms, one embodiment of a first aspect of the invention can provide a method of processing content of a web resource for display, the web resource having at least one dimension exceeding an initial viewable area of a browser of a display device, the method comprising: retrieving the web resource and rendering information from the web resource in the browser; delaying rendering of a content unit for a portion of the web resource outside the initial viewable area; detecting an event indicating a change of the initial viewable area to a secondary viewable area; and on detection of the event, rendering the content unit.

This allows an efficient way to provide a piece of content only once the relevant part of the web resource is in-view. More adverts can be used in the web resource, and more otherwise wasted whitespace can be used. This method also responds to an event, rather than having to use computationally intensive means, for example, by frequently checking for in-view status.

The web resource may be a webpage, for example. The initial viewable area may be the window area of the browser, for example that seen by the user on an initial rendering of the web resource. The at least one dimension of the web resource may be a height or width, and may be a dimension of the web resource during rendering or once rendered. The portion of the web resource outside the initial viewable area may be that which is rendered, rendering, or to be rendered outside the viewable area. Alternatively, the at least one dimension exceeding the initial viewable area may be that a portion of the web resource is designated not to appear in the initial viewable area. Preferably, the secondary viewable area contains said outside portion of the web resource. The content unit may (already) be in this portion of the web resource outside the initial viewable area, that is, the content unit (perhaps an initial part of the code) may have been initiated to place the content unit there, or the DOM (Document Object Model) may already have fixed the location of the unit.

Suitably, the event is triggered by a user. This may be by a user interaction with the web resource, for example via a user interface. Preferably, the event is a movement event. In an embodiment, the change of the viewable area is a movement of the viewable area from an initial position on the web resource to a secondary position on the web resource. The change of the viewable area may be measured or detected on the web resource as rendered.

Suitably, the event is a scroll event. Alternatively or additionally, it could be a resizing or similar event. The scroll may be vertical or horizontal.

An advantage of using events in this way is reliability - an event such as a scroll event can indicate conclusively the (changed) position of a viewable area, rather than relying on techniques which may require assumptions or supposition as to position.

In an embodiment, the step of detecting the event comprises monitoring for the event. For example, the event may be one that is irregular or infrequent, especially if generated by the user. Suitably, the content unit is an advert placement tag. Other content units could be video, images, polls, or tags linking to other websites and/or social media. ln an embodiment, the web resource is at least in part a static web resource, and wherein the steps of delaying and detecting comprise modifying code in a static portion of the web resource. The modification may be to an existing content unit in a webpage, to alter the code so that the content unit is not called or rendered in the usual sequence, but delayed until detection of the event.

Preferably, the step of modifying the code comprises editing an advert placement tag, by inserting instructions for delaying rendering of the advert until detection of an event indicating a change to the viewable area to include at least a portion of the advert.

In another embodiment, the web resource is a dynamic web resource, having at least one dimension exceeding the initial viewable area. Preferably, the steps of delaying and detecting comprise: storing on a server instructions, activatable when the dynamic web resource is to have at least one dimension exceeding an initial viewable area of a browser of a display device, for said delaying rendering and said detecting an event and, on detection of the event, said rendering the content unit.

More preferably, the method further comprises storing the instructions in code of the web resource, and wherein the instructions comprise a shell for

accommodating content called on rendering of the dynamic web resource. The shell may accommodate an advert placement tag, for example. Such a shell may be provided in a web resource so that content can be placed in it before it is known that the dynamically generated page will exceed the dimensions of the browser, the instructions of the shell being activated when those circumstances arise. Suitably, the method further comprises, on said detection of the event, rendering the content unit into a whitespace portion of the web resource. ln an embodiment, the method further comprises: detecting an event indicating a change of the secondary viewable area to a tertiary viewable area; and on detection of the event, rendering a further delayed content unit.

This provides greater, more efficient, and potentially more varied use of the whitespace, particularly in webpages which may have long sections of comments or the like, long past any initially placed adverts. The further delayed content unit may be rendered into whitespace below or beside the previously rendered delayed content unit.

In another embodiment, the method further comprises: detecting an event indicating a change of the secondary viewable area to a tertiary viewable area; and on detection of the event, maintaining the content unit in the viewable area.

This provides an alternative means for better use of excess whitespace - maintaining the initially delayed content unit in the viewable area. Preferably, the step of maintaining the content unit comprises fixing the content unit in a position in a browser window, during changes of the viewable area from one location on the web resource to another. This may be done by monitoring movement events, such as scroll events, and deriving from the web resource the position of whitespace occupiable by the content unit during the change of viewable area. Suitably, the method further comprises changing the content for the content unit after a given viewable duration or length of scroll. The duration of length of scroll may be measured in the distance moved, for example by one of: a total count of scroll events; a length of time measured over the total movement of the viewable area; and a scroll length measured in pixels. ln an embodiment, the method further comprises gathering data during rendering of the web resource, the data comprising any events detected and details of any content units rendered. For example, the number of scroll events between initial and final viewable areas, may be gathered, or the scroll event firing rate, to judge scroll speed. Preferably, the method further comprises updating a tracking cookie with gathered data.

One embodiment of a second aspect of the invention can provide a system for processing content of a web resource for display, comprising: a user device, configured to: retrieve a web resource from a web server, and render information from the web resource in a browser of the user device, the web resource having at least one dimension exceeding an initial viewable area of the browser; and a component of the web resource configured to: delay rendering of a content unit for a portion of the web resource outside the initial viewable area; detect an event indicating a change of the initial viewable area to a secondary viewable area; and, on detection of the event, render the content unit in the browser of the user device.

One embodiment of a third aspect of the invention can provide a system for storing and processing a dynamic web resource for display, comprising: a web server storing the dynamic web resource, the dynamic web resource retrievable by and renderable in a browser of a user device; and a component of the dynamic web resource comprising instructions, activatable when the dynamic web resource is to have at least one dimension exceeding an initial viewable area of a browser of a display device, for: delaying rendering of a content unit for a portion of the dynamic web resource outside the initial viewable area; detecting an event indicating a change of the initial viewable area to a secondary viewable area; and, on detection of the event, rendering the content unit. One embodiment of a further aspect of the invention can provide a computer- implemented method of processing content of a web resource for display, the web resource having at least one dimension exceeding an initial viewable area of a browser of a display device, the method comprising, by a processor: retrieving from a web server the web resource and rendering information from the web resource in the browser of the display device; delaying rendering of a content unit for a portion of the web resource outside the initial viewable area; detecting an event generated in the processor and/or display device indicating a change of the initial viewable area to a secondary viewable area; and on detection of the event, rendering the content unit in the browser of the display device. One embodiment of a further aspect of the invention can provide a method for delivering an ad unit into the whitespace of a webpage, the original location of the ad unit being initially below the fold, comprising: triggering delivery of an ad unit when the pre-defined delivery zone appears in the visible area of a user's browser.

Preferably, the method further comprises and adding a wrapper of code around a pre-existing ad placement tag.

One embodiment of a further aspect of the invention can provide a web resource comprising: instructions and content for rendering a webpage, at least one dimension of the webpage exceeding an initial viewable area of a browser of a display device; instructions for, on rendering of the webpage in the browser of the display device, delaying rendering of a content unit for a portion of the webpage outside the initial viewable area; detecting an event generated on viewing of the webpage in the display device indicating a change of the initial viewable area to a secondary viewable area; and on detection of the event, rendering the content unit in the browser of the display device.

One embodiment of a further aspect of the invention can provide a media device storing computer program code adapted, when loaded into or run on a computer or processor, to cause the computer or processor to become a system, or to carry out a method, according to any of the above described aspects or embodiments.

The above aspects and embodiments may be combined to provide further aspects and embodiments of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention will now be described by way of example with reference to the accompanying drawings, in which:

Figure 1 is a diagram illustrating a system for activating content in a webpage according to an embodiment of the invention;

Figure 2 is a diagram illustrating a comparison with a previously considered system for displaying content in a webpage according to an embodiment of the invention;

Figure 3 is a diagram illustrating a process for displaying content in a webpage according to an embodiment of the invention;

Figure 4 is a diagram illustrating a system for displaying content in a webpage according to an embodiment of the invention;

Figure 5 is a diagram illustrating steps of a process for displaying content in a webpage according to an embodiment of the invention; and

Figure 6 is a diagram illustrating an apparatus according to an embodiment of the invention.

DETAILED DESCRIPTION OF EMBODIMENTS

When the following terms are used herein, the accompanying definitions can be applied: ΙΑΒ - Internet Advertising Bureau - the trade association for online and mobile advertising. It promotes growth and best practice for advertisers, agencies and media owners. BTF - below the fold - ad inventory which is only visible to a website user once a user scrolls past the initial on load portion of the web page

ATF - above the fold - ad inventory which is visible without scrolling and appears on the user's screen on initial webpage load

CPM - an acronym for Cost Per Mille, or Cost Per Thousand ad impressions. Ad inventory is predominantly traded on a CPM basis.

Ad Server - the computer or group of computers responsible for the actual serving of creatives to websites, or for making decisions about what ads will serve. An ad server may also track clicks on ads and other data. Major publishers, networks and advertisers sometimes have their own ad servers.

Publisher - a source of ad inventory. This can either refer to a general site publisher, such as a news conglomerate, or a network-managed entity

Network - an ad network, which is an entity that buys and sells on behalf of advertisers and publishers. DOM - The Document Object Model is a cross-platform and language- independent convention for representing and interacting with objects in HTML, XHTML and XML documents

Embodiments of the present invention can provide systems and methods which can be employed to deliver "below the fold" content, and further provide a range of additional features which enable a publisher to fully monetise each unique visit to their site.

One embodiment of the present invention provides a code routine that may be programmed to serve content from a third party source into, for example, the whitespace of a web page, the original location of the served content being initially "below the fold".

Figure 1 illustrates a simple implementation of an embodiment of the invention, demonstrating the transition from a dormant to an active unit. The white rectangle represents the viewable portion of a webpage on a user's browser. In the left-hand diagram, a web resource 104, here a webpage, is retrieved by a browser and rendered ready for display in the browser, but the webpage is longer than the vertical span of the browser window (102). A content unit, here an advert (106) is part of the retrieved and rendered code of the webpage, but it is currently not in-view, i.e. it is outside the viewable area of the browser 102. The rendering of the content unit itself (rather than any placement or supporting code which may have determined its position) is delayed - the advert is de-activated. Subsequently, as shown in the right-hand diagram, the browser window is moved down the webpage, so that the advert is now inside the viewable area (102). This can be detected by monitoring events generated by the movement of the browser window, such as scroll events. The detection of the event can indicate the movement of the window sufficiently that the advert is now in-view. This can then be made to trigger the rendering of the content unit, activating the advert (108).

The functionality outlined above and in the detailed embodiments described below, besides saving computational resources and providing more efficient rendering of webpages, also enables publishers to monetise their page views via an alternative model than the established and prevalent one which exists with ad- funded publishers today.

Currently, the majority of online publications which are reliant on advertising for revenue are monetised as follows:

Page views = set number of ad impressions served = revenue

This equation means that for every page view rendered a set number of ads are then served, regardless of the individual users' engagement with the page. This approach means that each visit to the website has the same value in terms of advertising, irrespective of the quality of each visit.

For example, a user that has a dwell time of just 2 seconds and does not scroll at all has the same value as someone who scrolls the full length of the page and has a dwell time of 10 minutes.

Embodiments of the present invention however enable publishers to fully monetise each individual visit based on the user's engagement with the site itself (as shown in the revenue model below):

User Dwell time + Depth of Scroll = 100% viewed ads = increased revenue

This approach enables publishers to adopt the above model and fully monetise each visit to an appropriate value, and dynamically alter the distribution and delivery of advertising based on how a user interacts with a page.

As a result the technology not only offers a mechanism for advertising vendors to deliver viewable only ads, it also gives them the power to fully monetise their webpages with a more dynamic revenue model than those currently employed in the marketplace. This is a differentiator between embodiments of the invention and vendors who employ techniques to deliver viewable impressions.

A detailed overview outlining the difference between the two revenue models can be found in Figure 2. Scenarios 1 & 2 demonstrate how an identical visit could be monetised via differing revenue models. In Scenario 1 (202), all page views are equal in terms of ads served and revenue. This is because the same number of ads (206) are rendered in the webpage, whether or not the user scrolls down to see the below the fold content. In Scenario 2 (204) this varies dependent on the dwell time and length of scroll, and as such more ads (208) are delivered and more revenue is generated in this particular instance. This is because (i) content can be delivered depending on whether the user scrolls below the fold, (ii) content can be fixed, changed or re-delivered in the whitespace (in embodiments described below) as the user scrolls.

Returning to the basic implementation of embodiments of the invention, Figure 3 illustrates features of these embodiments in more detail.

A user's browser retrieves a web resource, here a webpage, from a web server (302). Rendering of the webpage begins, and if a dimension of the webpage does not exceed that of the browser window (304), the webpage can be fully rendered (306). Dimensions may for example be the height or width of the webpage, as measured in comparison to the browser window. Webpages are typically 950 pixels wide by 600 pixels long - any content below 600 pixels will therefore be unlikely to be viewed above the fold. Equally, any content wider than 950 pixels will not be seen, so some movement of the window (by scrolling, re-sizing, click and drag, keystrokes) will be required.

The initial load point for a webpage might actually be in the middle of the page - for example, hyperlinks to a particular location in a web document - so that content "below the fold" may actually be above the initial viewable area. If the webpage does exceed the browser window size (304), the webpage is rendered except for any content units located (or scheduled to be located) outside the browser window area (308).

This delaying action (308) can be performed by a piece of code written into the webpage. The code (usually a script) will essentially prevent a content unit from running, or being rendered in the usual way or the usual sequence that would have happened had the webpage rendered normally. For example, in the case of the content unit being an advert, the webpage might have advert placement tags in various places on the webpage. These tags - sections of the code of the webpage - instruct the browser on rendering to render an advert in that location, and to call the actual content for the advert unit from an advert server. The code of the present invention acts as a wrapper around the content unit, e.g. pre-empting the usual advert tag routine, to prevent such a content unit being loaded, for example preventing the advert being called. The second aim of the code is allowing the rendering to be completed later, i.e. outside the usual rendering timeline, in response to the detection of an event (see below).

The next step is therefore the detection of an event. This can be done by monitoring for events, such as user interactions with the web browser. These might be mouse actions or keystrokes, or the other examples described herein. In this embodiment, the event is a scroll event. This event is fired whenever an element (either the page, or an element within it) is scrolled, by whatever means - mouse click on the scrollbar, keystroke, or the like. The scroll event can be detected by the same code wrapping the content unit, for example by a script acting as an event handler or listener. In the following step, the detection of the event allows the evaluation (312) of whether the content unit is now (at least partially) inside the viewable area. For example, a scroll event, or a sequence of scroll events, together with the dimensions of a webpage, the size of relevant elements and/or frames and the size and location of the content unit, can be used to determine whether the content unit is in-view. The script including the event listener can perform these tasks. If the content unit is not in-view, the monitoring or detection of events continues (310).

If the content unit is in view, for example if the script determines this from the scroll event(s), the content unit is finally rendered into the webpage (314), "activating" the content. For example, the script allows the rest of the code in the ad placement tag to run, prompting the previously delayed advert to be called from the ad server and rendered into the ad placement position.

A script or wrapper like this can be written into a webpage as a standalone item, or more usually as an edit to an existing webpage. For example a static webpage with advert tags can be edited by wrapping each tag in the code to run the routine described above, turning the page from a standard, all ads rendered at once, page into a page for which only on-screen ads will be rendered. The script can modify a content unit in ways other than or in addition to delaying the ad content. For example, the existing content can be excised, or replaced with other content, depending on the user (e.g. scroll) event. The content unit can be made to perform differently - examples of this are given below. One advantage of these methods is that the detection of events (by a script) is far less computationally expensive than, for example an active method, such as a time-out function checking a scrolltop position every second. The inventive method's computation is only prompted when the event fires; this firing may be very infrequent if the user is dwelling on a page. Another advantage is that they can address, in webpages which are at least in part dynamically generated, how to account for content which may already have been committed for inclusion in the ultimate webpage, but is nevertheless not currently present in-view, or in an initial static page. Previously considered methods which generate add content at the bottom of a webpage dynamically merely call or "get" new information from the server on detecting a scroll event. Methods of the present invention however are able to delay the rendering of content which is already committed, even to dynamically generated pages, such as content which has already been rendered below the fold, even where a remaining portion of the page below the fold has yet to be generated. For example, an advert may be scheduled to appear in a below the fold location, the content for which location is not yet fully rendered, but the initial code placement for the advert tag has been rendered in place. Embodiments of the present invention can delay loading of the advert content (in spite of the initial tag code having been rendered), not just the remainder of the content being dynamically generated.

Alternatively or in addition, the method could be implemented directly in a server, for example an ad server (as opposed to a host's page), which would enable additional client types from the buy side of advertising to utilise the technology. In such a case, the methods above could be used, simply modifying a content unit to be served at the server rather than the content unit (e.g. a placement tag) on a webpage. This alternative may be particularly useful in the case of dynamic web resources. Here, the webpage may be generated on-the-fly, based on a basic initial setup code, adding content as needed (for example, placing ad tags or calling adverts during generation), and potentially being influenced by user interaction. In such cases, rather than the webpage being static, i.e. already generated, and edited to incorporate embodiments of the invention, embodiments of the invention can be used on the server. For example, in the case of a wrapper code for a content unit, rather than this being added to a webpage, modifying for example an ad placement tag, the wrapper code can be stored on the server, and called to wrap any content unit that is used in generation of the webpage. In such embodiments, the wrapper acts like a shell component.

In dynamic generation of a webpage, the shell can be used to wrap any content units that are dynamically called to make up the content of the webpage, so that the wrapper is available to work in the way described above - delaying ultimate rendering of the content unit in the browser, in the case where the content unit is outside the in-view area, until an event is detected. Of course, this might entail that if a content unit is called and placed in the immediately in-view area, the wrapper is activated immediately and allows the content unit to be rendered - in such a case the wrapper's action is effectively inconsequential. In the case where the content unit is a dynamically placed ad placement, and the placement is outside the in-view area (or is known to be scheduled to be outside the in-view area, even if the content is being generated dynamically), the wrapper will essentially work as in the previous embodiments - in the browser, preventing an ad call on that placement until the ad is in-view.

As noted above, the system can work by taking a client's ad placement and adding a wrapper of code to sit around the ad placement. Once this 'revised' code is inserted into the client's webpage, the technology will alter the delivery of ad units according to the pre-defined requirements of the client. Figure 4 shows an example of the process of implementation. A placement code (404) is generated by the client's ad server (402). The inventive technology (406) is then added to the code and the revised code (408) is added into the source code of the website (410). As a solution for publishers the code can be inserted into the html of the page, and as a result is not restricted by any functionality limitations which may arise from cross domain or unfriendly iframes. An unfriendly or cross-domain iframe is an iframe served from a different domain to the host website. Due to a browser security policy, termed the same origin policy, web browsers do not allow communication between webpages and iframes served from different domains.

An example of the most basic function of the unit - to trigger a delivery of an ad unit when the pre-defined delivery zone appears in the visible area of a user's browser - can involve numerous instances and variables, examples of which can be summarised in Figure 5, a diagram to demonstrate all instances in the cycle from page load to page close.

Initially the page loads (502) and the wrapper code (504) is loaded. This code monitors or detects the visibility of the appropriate area (506). If visibility is not detected (508), the advert placement remains in-active (512), and statistics on this outcome can be gathered (514) and stored or returned to a base station. Later described embodiments give detail on employing statistics gathering.

If visibility is detected (510), the ad placement becomes active (516) and a call is made to the client's ad server (518). An ad therefore loads in the appropriate area of the website (520). Again, statistics are gathered relating to this outcome (522).

For Re-Appearing content units (see below embodiments) the same process will occur once visibility is detected for the new area in which the ad is to load.

In embodiments, the script which powers the inventive technology is written in script code, for example JavaScript™. JavaScript™ is a programming language used to make web pages interactive. It runs on the user's computer and doesn't require constant downloads from the server website. JavaScript™ support is built into all the major web browsers, including Internet Explorer™ , Firefox™ and Safari™. Provided that the visitors to the encoded site are using web browsers that support JavaScript™ (most do) and have JavaScript™ enabled (it is usually enabled by default), then the JavaScript™ will run when they visit the page. Due to its prevalence as a default programming language for building interactive webpages, any non-compatibility instances will be extremely isolated.

As noted above, in embodiments the technology uses browser scroll events to determine the scroll position of a user on a page. Based on the user's location, the browser will add the previously stored and in-active portion of code into the DOM (document object model) of the website at the appropriate moment. It is at that point that the stored code becomes active. For clarity purposes, it must be noted that the portion of code can be anything, including an ad placement code which on load calls its ad server to deliver an appropriate ad.

Served content may then either travel out of the viewable area of the webpage as a scrolling action continues or may be set to maintain a fixed position on the screen as the user scrolls the webpage down - see embodiments below.

In the case of content that is served and then travels outside of the viewable area of the page, the code routine may be arranged to re-serve the content after a certain length has been travelled. It is noted that the re-appearing content may be the same content or may be further content from the same source. By allowing content to re-appear the webpage developer does not need to code multiple instances of code routines for delivering third party content to their webpage since a single instance of the code routine according to the present invention is able to re-serve content to the page.

In its most basic form, the invention enables publishers to deliver ad placements when a user has become in-view. In addition there are supplementary features as mentioned above which provide greater efficiency, reduction in computation, and allow vendors of advertising inventory (publishers, networks) to fully monetise their webpages to their true potential. These additional features are as follows:

1 ) A re-Appearing content unit:

Content units can be set to 're-appear' after a certain length or duration of movement or scrolling. This length can be determined in pixels, which are the natural unit for measuring dimensions on a screen and are often used when precise design is required. The number of pixels can be modified to suit the client's requirements. This enables a web publisher to serve multiple ad units from an ad placement if a user continues to scroll down the website. The technology for this embodiment can work from a single wrapper code, meaning that implementation only needs to occur once, and has the capability to deliver an unlimited number of units.

Re-appearing content units can be delivered as i) standard (which means once served it remains in the original position of load, i.e. a fixed placement, with potentially another ad re-appearing after a set number of pixels) or ii) a moving placement (which means the unit follows the scroll indefinitely and appears fixed in the same position on the screen, potentially until a new ad unit is ready to reappear.) More details on the 'moving' format can be found below.

In a basic implementation, this method simply loads the next, delayed content unit on the page. For example, an ad placement tag below another may also have been wrapped in the delaying code, or both (or all) may have been wrapped by a single script. The lower advert is therefore rendered once in-view, in the same way.

In another embodiment, the code can be used to re-generate an advert placement lower down the page - as the scroll distance is known, and if there is whitespace available, the code can simply duplicate a content unit which earlier exited the viewable area. The content unit can call the same, or a new content, once in-view.

2) Moving With Scroll Ad Unit

A content unit, if appearing in 'white space,' continues to stay in the same position on the screen as the user scrolls further down. Therefore no matter how deep the user's scroll the ad unit will remain fixed in the same part of the page (unless or until it is set to re-appear).

This can be enabled again by detection of movement events, for example scroll events. If the scroll events are detected, and the size of all relevant features of the webpage are known, it can be established that there is continuing whitespace available below (or above) the rendered (previously delayed) content unit, so the content unit can be maintained in place.

In a previously considered content delivery technique a separate content window hovering above the webpage is provided. Upon scroll of the webpage the hovering window "moves" relative to the page content in order to maintain a constant position with respect to the display device. The present invention is distinguished from such a system, for example in that the content is delivered into a location that is initially in a below the fold location (i.e. the content only appears upon a scrolling action being initiated). Furthermore, in the present invention content can be delivered as part of the webpage instead of a hovering over the page as in known content delivery systems. The present invention also locates the delivered content into the whitespace within the webpage.

If the content unit is moving with the scroll, a re-appearing or re-revealing function can reload the content, or change the content, after a certain number of movement events, i.e. a certain distance down the page, or after a predetermined time. ln the case of re-revealing ad placements, the ad placement becomes reactivated, for example once a pre-defined length (in pixels) is achieved. This instance triggers another ad load and all stages of the process, for example as outlined in Figures 3 to 5, will then recommence. Ads will typically continue to re- reveal as long as two variables remain consistent- a) there is sufficient white space in which to serve the ad and b) the user continues to scroll. The number of re-revealing ads can be capped by the client, and likewise the pixel length can be defined to suit.

In addition to the above, embodiments of the invention can gather data regarding the processing of the webpage and content units. For example, statistics can be collected on each page load on both i) the performance of the content unit and its wrapper and ii) the user's interaction with the site itself, which can be collected regardless of whether the wrapper on the content unit becomes active. Both sets of statistics are hugely relevant to the publisher and will enable the user of this data to serve not just as a solution to deliver additional advertising inventory, but be able to provide data which publishers can use to inform future decisions on how advertising should be presented on the website. Examples of these statistics can be summarised below:

Summary of statistics gathered per instance:

Wrapper/content unit Statistics Webpage Statistics

Page loaded Number of ads on the page

Ad requested Page makeup

Ad viewed Position of ads on the page

Length of time ad was in view Length of scroll

Engagement / Hover Over Speed of Scroll

Length of hover Dwell time per section of the site Length of page

URL

Browser

Screen Size

Operating System

IP Address

These statistics can be used immediately, in processing the content units in the ways described above, or can be gathered for later use, for example in

behavioural targeting.

As an example of the use of these statistics in processing the current page, scroll speed (e.g. rate of firing of scroll events) can be used as a factor in serving an ad. If a user is jumping rapidly down the page then one embodiment holds back delivery of the ad to allow confirmation that there is a genuine chance for the ad to be seen.

Dwell time and scroll speed and the like can also be used to determine a type of user viewing the page, which can be used to alter the content rendered in a content unit for which rendering has been delayed. For example, for a user determined to be particularly engaged with a page, by dwell time or interaction with features, a content unit outside the viewable area but about to become in view can be chosen to render different content, for example a different advert, or one that carries a higher premium for a more engaged user.

Another such implementation is in mobile devices using browsers. These are typically far smaller than desktop browsers, so other considerations for rendering content are available. For example, it might be deemed intrusive or off-putting for a banner ad to occupy a large portion of the screen (sufficient to be read) on initial loading - embodiments of the invention can be used to dynamically generate an advert to appear later in the use of the page. For example, the appearance of an advert can be delayed until a certain distance or time of scrolling has been incurred. The ad can then be placed intervening the page content, or fixed (moving with scroll) at the top or bottom of the window. This can be done by using a dynamic wrapper code for an otherwise static page - the wrapper can be part of the code of the page, but rather than having a fixed location outside the viewable area and triggered by scroll events, the wrapper code and associated content unit is "outside" by being prevented from appearing in the initial viewable area, and delayed until a certain time.

In a further embodiment, on-page behavioural targeting can be employed. When a user arrives on the page, it is possible as noted above to use statistics gathered to monitor and record how they engage with the web page: do they scroll the whole length of the page? Do they spend a long time on each page? Do they engage with the commenting on a page? By placing a cookie on the user's computer or device and tracking this behaviour across a network, it is possible to build up profiles of individual users and allow advertisers to target these profiles based on criteria such as Interests (what sort of content do they consume), Comment Engagement (for users lingering around and replying to comments), Reading Time (for keen readers), and more user behavioural traits

Reproduced below is a sample of JavaScript™ code which is similar to that used to deliver embodiments of the present invention, and below it is a description of each function, referenced by number. All functionality outlined can be referenced by the appropriate line in the following list.

2. // variables needed for scroll and coordinates calculations 3. // re-revealing interval size in pixels

4. // offset from top for the first ad

5. // counter for revealing containers ids

6. // container for the code to insert

7. // code to insert

9. // function which triggers when user scrolls page

10. // how much pixels were scrolled

11. // redefining scroll variable for the future calculation 13. // function for each ad

14. // calculating the new top position

15. // if ad needs to be fixed 16. // fix position

18. // move top to the new Top coordinate

22. // checking if window is scrolled by interval size

25. // calculating top position

29. // adding new ad to ad-container

As mentioned previously, the technology of embodiments of the invention acts to restrict the delivery of a given code until a user has entered into the defined viewable area. This portion of code can be anything and is not exclusive to advertising - examples include an image, a web poll, content blocks, or anything that is able to be rendered by a browser.

In the instance of re-appearing content it is noted that the code routine may be arranged to re-serve the same content from a given third party. Alternatively, in the event that the third party has multiple content items to deliver, then each time the code routine serves an item of content the content could be different (e.g. different adverts could be served to the webpage during a scrolling action such that a moving "storyboard" of ads is created). Referring to Figure 6, the above embodiments of the invention may be

conveniently realized as a computer system suitably programmed with

instructions for carrying out the steps of the methods according to the invention.

For example, a central processing unit 604 is able to allow the browser to retrieve web resources and render the web resources in the browser. The web resources can be retrieved, arriving at a port 605, which could be a connection to a network, but could also be a reader for portable data storage media.

For example, in an embodiment, the processor performs such steps as: retrieving the web resource and rendering information from the web resource in the browser; delaying rendering of a content unit for a portion of the web resource outside the initial viewable area; detecting an event indicating a change of the initial viewable area to a secondary viewable area; and on detection of the event, rendering the content unit. Software applications loaded on memory 606 are executed to process the content and render the web resources. Temporary data can be stored in random access memory 607.

A Man - Machine Interface 608 typically includes a keyboard/mouse/screen combination which allows user input and a screen on which the results of executing the applications are displayed. In a mobile device, the MMI may be a touchscreen interface

It will be appreciated by those skilled in the art that the invention has been described by way of example only, and that a variety of alternative approaches may be adopted without departing from the scope of the invention, as defined by the appended claims.

Claims

1. A method of processing content of a web resource for display, the web resource having at least one dimension exceeding an initial viewable area of a browser of a display device, the method comprising:

retrieving the web resource and rendering information from the web resource in the browser;

delaying rendering of a content unit for a portion of the web resource outside the initial viewable area;

detecting an event indicating a change of the initial viewable area to a secondary viewable area; and

on detection of the event, rendering the content unit.

2. A method according to Claim 1 , wherein the secondary viewable area contains said outside portion of the web resource.

3. A method according to Claim 1 or Claim 2, wherein the event is triggered by a user.

4. A method according to any preceding claim, wherein the event is a movement event.

5. A method according to Claim 4, wherein the change of the viewable area is a movement of the viewable area from an initial position on the web resource to a secondary position on the web resource.

6. A method according to Claim 4 or Claim 5, wherein the event is a scroll event.

7. A method according to any preceding claim, wherein the step of detecting the event comprises monitoring for the event.

8. A method according to any preceding claim, wherein the content unit is an advert placement tag.

9. A method according to any preceding claim, wherein the web resource is at least in part a static web resource, and wherein the steps of delaying and detecting comprise modifying code in a static portion of the web resource.

10. A method according to Claim 9, wherein the step of modifying the code comprises editing an advert placement tag, by inserting instructions for delaying rendering of the advert until detection of an event indicating a change to the viewable area to include at least a portion of the advert.

1 1 . A method according to any of the Claims 1 to 8, wherein the web resource is a dynamic web resource, having at least one dimension exceeding the initial viewable area.

12. A method according to Claim 1 1 , wherein the steps of delaying and detecting comprise:

storing on a server instructions, activatable when the dynamic web resource is to have at least one dimension exceeding an initial viewable area of a browser of a display device, for said delaying rendering and said detecting an event and, on detection of the event, said rendering the content unit.

13. A method according to Claim 12, further comprising storing the instructions in code of the web resource, and wherein the instructions comprise a shell for accommodating content called on rendering of the dynamic web resource.

14. A method according to any preceding claim, comprising, on said detection of the event, rendering the content unit into a whitespace portion of the web resource.

15. A method according to any preceding claim, further comprising: detecting an event indicating a change of the secondary viewable area to a tertiary viewable area; and

on detection of the event, rendering a further delayed content unit.

16. A method according to Claim 15, comprising rendering the further delayed content unit below the previously rendered delayed content unit.

17. A method according to any of the Claims 1 to 14, further

comprising:

detecting an event indicating a change of the secondary viewable area to a tertiary viewable area; and

on detection of the event, maintaining the content unit in the viewable area.

18. A method according to Claim 17, wherein the step of maintaining the content unit comprises fixing the content unit in a position in a browser window, during changes of the viewable area from one location on the web resource to another.

19. A method according to Claim 18, wherein the step of fixing the content unit in the position comprises: detecting movement events; and deriving from the web resource the position of whitespace occupiable by the content unit during the change of viewable area.

20. A method according to any of the Claims 17 to 19, further comprising changing the content for the content unit after a given viewable duration or length of scroll.

21 . A method according to Claim 20, wherein the viewable duration or length of scroll is measured by one of: a total count of scroll events over the movement of the viewable area; a length of time measured over the movement of the viewable area; and a scroll length measured in pixels.

22. A method according to any preceding claim, further comprising gathering data during rendering of the web resource, the data comprising any events detected and details of any content units rendered.

23. A method according to Claim 22, further comprising updating a tracking cookie with gathered data.

24. A system for processing content of a web resource for display, comprising:

a user device, configured to: retrieve a web resource from a web server, and render information from the web resource in a browser of the user device, the web resource having at least one dimension exceeding an initial viewable area of the browser; and

a component of the web resource configured to: delay rendering of a content unit for a portion of the web resource outside the initial viewable area; detect an event indicating a change of the initial viewable area to a secondary viewable area; and, on detection of the event, render the content unit in the browser of the user device.

25. A system for storing and processing a dynamic web resource for display, comprising: a web server storing the dynamic web resource, the dynamic web resource retrievable by and renderable in a browser of a user device; and a component of the dynamic web resource comprising instructions, activatable when the dynamic web resource is to have at least one dimension exceeding an initial viewable area of a browser of a display device, for: delaying rendering of a content unit for a portion of the dynamic web resource outside the initial viewable area; detecting an event indicating a change of the initial viewable area to a secondary viewable area; and, on detection of the event, rendering the content unit.

26. A media device storing computer program code adapted, when loaded into or run on a computer or processor, to cause the computer or processor to become a system, or to carry out a method, according to any preceding claim.