Why is this important? Don’t you want to know when visitors search and don’t get any results? Zero result searches can help your identify missing content on your site or a problem with your site search engine.

Many search solutions will provide this information for you. For example, I use Search Meter for WordPress and it shows me which search queries generate zero results. But I thought it would be interesting to add this data to Google Analytics. That way all my site search information would be in one place.

Unfortunately there is no easy way to add this data to GA. You need to do some programming to collect the data. So this post is really meant for those folks with programming resources AND for those developers that maintain GA plugins. Like my buddy Joost, who has a great GA plugin for WordPress.

If you’re interested in the data and analysis, skip to the bottom of this post.

Conceptual Overview

Our goal with this hack is to modify site search data in two ways. First, we’re going to put all search queries with zero results in a category. This will allow us to use the Search Categories report to easily find all the search terms that yielded zero results.

Second, we’ll modify the actual search terms to indicate that a term yielded zero results. This will make it easy to scan a list of all the search terms and identify which generated no results.

Before we get into the implementation, a big THANK YOU to Charles Miller, one of the lead consultants here. He wrote the JavaScript below. Thanks Charles.

Step 1: Identify No Result Search

The first step is to identify a zero results search page. Most websites have the same search results page regardless of the number of results. You need to identify some something that differentiates a zero results search page from a non-zero results search page.

This must be done programatically and is the hardest part of the implementation.

For example, a zero results search page on this blog has the text “No posts found. Try a different search?”

I can create code (or more specifically, Charles can create code) to look for the text “No posts found. Try a different search?” If the code finds this text in the page then I can identify that the visitor’s search yielded zero results and than I can send the data sent to GA. Here’s the code that I’m using on this blog:

var content = document.getElementById('content');
if (content.innerHTML.search('No posts found.')) {

The code looks for a section of the page called ‘content’ and then searches that section for the phrase ‘No posts found.’. If ‘no posts found.’ is found (oh, the irony!) then we will modify the data sent to GA.

Important! The way you detect a zero result search page may be different. It’s VERY difficult to create an example that will work for everyone. Take this as a conceptual overview.

Step 2: Tweak GA Tracking Code

Once we know what differentiates a zero results search page we can add some code that tweaks the data. Remember, we want to modify the data in two ways: 1. by placing it in a special search category and 2. by modifying the search term to indicate it did not yield any results.

To create the category all we need to do is add an extra query string parameter to the URL.

To manipulate the search term we need to split apart the page URL and then put it back together with the phrase no-results.

Here’s the complete code.

<script type='text/javascript'>
var pageTracker = _gat._getTracker("UA-XXXXXX-1");
var content = document.getElementById('content');
if (content.innerHTML.search('No posts found.')) {
     // These lines get the search data from the URL and
     //  deconstruct the URL into parts
     var sn = "s";
     var sr = new RegExp(sn+"=[^\&]+"),
      p = document.location.pathname,
      s = document.location.search,
      sm = s.match(sr).toString(),
      srs = sm.split("="),
      // The next line is where we add the category and add
      // the phrase no-results to the search term.
      sre = sm.replace(sr,srs[0]+"=no-results:
 "+srs[1]+"&cat=no-results"),
      sf = s.replace(sr,sre);
      // Send the data to Google as a Pageview
      pageTracker._trackPageview(p+sf);
} else {
      // If this is a regular page on the site, use the standard GA code.
      pageTracker._trackPageview();
}
</script>

The code starts with the section that identifies a zero result search page.

Then we deconstruct the URL to identify the search term. Finally we add the category named ‘no_results’ and the phrase ‘no-results’ to the search term.

If the code does NOT find the term ‘No posts found.’ then a pageview is created as normal.

That’s it for the coding part (thank goodness!)

Step 3: Configure Site Search Settings

The last step is to add the new category parameter to the Site Search settings so GA can identify the no-results search category. This is easy, it’s in the profile setting section of Google Analytics.

I also like to set the ‘Strip Query Parameter’ to YES. This removes the category parameter after site search is done processing and normalizes your pageview data.

That’s it for the configuration! We’re cleared for insight-hunting!

Analyzing The Data

When a visitor performs a search that yields zero results the search term will be placed in a category named ‘no_results’. To find this data navigate to the Content>Site Search>Categories Report:

Immediately you’ll be able to see what percentage of your searches yield zero results. Hopefully it’s very low! Want to see if this impacts conversions or revenue? Click the Goals or Ecommerce tab to check the conversion rate:

This is a bad picture, but you get the point.

Next you can click on the no-results line in the data and see exactly which search terms yielded zero results.

This is super-actionable data. Now you know where you may be missing content or if your site search engine might be broken. You should be asking yourself, “Why are there no results for these terms? Is there missing content or is there a problem with my site search engine?”

You’ll also notice that the search terms now have ‘no-results’ in them. This provides a lot of flexibility for view the search data other ways. Example, let’s use the Search Terms report:

Here we can see the search terms ranked by searches. What percent of your top 10, 20 or 50 are no-result searches? How is that impacting your bottom line?

This is just the start. You can use other metrics, like %Search Exists to understand if visitors who receive zero results refine their search or exit.

While this is not the easiest thing to configure, I hope you see the value of the data. More so, I hope that all those folks that maintain plugins add this type of feature to their GA plugins. Joost, you listening!?

Tracking Zero Result Searches in Google Analytics is a post from: Analytics Talk by Justin Cutroni

Google Analytics offers many different ways to segment data. Each has pros and cons but there is always a way to get the data you need…. well, almost always.

There are 6 different ways to segment data in Google Analytics:

1. Using certain reports
2. Dimension drop down
3. Report filters
4. Advanced segmentation
5. Custom reports
6. Profile filters

Bet you didn’t think there were SIX ways to segment data. :)

Using Certain Reports

Ok, you may think this form of segmentation is lame, but it’s not!

Many reports in Google Analytics are segmented by some default piece of information. There’s nothing for you to do.

For example, the Browsers report segments your data based on the different web browsers that visitors use to access your site. Google Analytics automatically identifies this information when collecting visitor data.

Other segments that are automatically include in Google Analytics include:

* Visitor type (new and returning)
* Geographic information
* Operating system (and many other “nerd” segments)

Marketing segments are not AUTOMATICALLY segmented. You need to configure Google Analytics to track campaigns (i.e. link tagging) in order to get correct traffic source segmentation.

Pros:
* Easy

Cons:
* You better make sure you’ve got your campaigns tagged correctly ;)

Dimension Drop Down

Many reports have a dimension drop down that allows for segmentation right in the report. This is a handy way to quickly drill down into a piece of data.

For example, let’s say I want to see the most popular landing pages in a particular state. I can navigate to the state in the Visitors > Map Overlay > Regions report, click on the state I’m interested in, and then choose Landing Page from the Dimension drop down.

You can see in the image above that you can segment based on campaign information, some technical information and some visitor information (visitor type, language).

Overall, this is a good way to go when you’re drilling down and want to segment a single data point by some dimension.

Pros:
* Quick for one-off segmentation

Cons:
* Can trigger sampling
* Limited number of dimensions and no metrics
* A pain if you need to segment a lot of things, like top landing pages for every US state

Report Filters

Bet you don’t think of filtering as segmenting, but it is!

Any report displaying tabular data has a filter tool at the bottom of the data. This let’s you quickly view data that matches, or does not match, some condition. The condition is the pattern, or regular expression, that you enter into the filter. Using a regular expression you can add lists to the filter.

Here’s an example. Suppose I want to quickly view traffic coming from the Pacific sales region. I can apply the following filter to the Visitors > Map Overlay > Regions report:

California|Oregon|Washington

[The above is a regular expression matching California OR Oregon OR Washington]

Notice that the Scorecard (the top row of data in the table) indicates how our segment, i.e. the data that matches our filter, compares to the overall site? We can now compare the Pacific sales region to the entire site.

And here’s a neat trick, if you add the filtered report to your dashboard the filter will persist in your dashboard widget. I call it a sticky filter.

Pros:
* Quick and relatively easy
* Can be applied to historical data
* Will not trigger sampling

Cons:
* Restricted to one report and the data in that report
* You should know some basic regular expressions
* Can not be shared easily

Advanced Segments

There has been a lot of conversation over the last few months about Advanced segments and rightly so. This analysis tool is really powerful and let’s you slice the data many different ways using different dimensions and metrics. Want to see all visits that generated more than $100, coming from paid search and occurring after 8 AM? No problem with an advanced segment.

But there are some downsides. First, sampling. Because Advanced segments re-process data in real time there is a sampling algorithm applied to minimize the load on Google’s servers.

You can’t segment more than 200k visits. If sampling is applied you’ll see a confidence interval next to your data.

Again, the problem is that small segments of data will be really inaccurate when the sampling algorithm is applied. There is no way to disable sampling.

The most common ways to get around sampling are segmenting using profile filters or potentially a report filter. It really depends on the exact situation.

The second issue is that not all reports can be segmented. Due to the segmentation technology certain reports can not be segmented, like the Absolute Unique Visitors report and the Funnel visualization report. Those reports can only be segmented with profile filter (see below).

Pros:
* Can be applied to historical data
* LOTS of flexibility, can segment based on a huge number of dimensions and metrics using different combination of both

Cons:
* Sampling will be applied if trying to segment more than 200,000 visits
* Not all reports can be segmented
* Specific to your username, can not be shared with other users

Custom Reports

Another beta feature that can be used for segmentation is the Custom Reporting tool. This tool is more than just pretty reports. It allows you to create 5 levels of segmentation in a report.

In a previous post I talked about segmenting campaigns by time of day to better understand day parting.

We could take that example one step further by adding geographic region to the report. The result would be a report that has Campaigns data that could be segmented by time of day and then by geographic location.

The problem is that not all dimensions can be used together. The reason is that only certain metrics are related in the Google Analytics data architecture. You can find a complete list of combinations in the GA support docs.

Pros:
* 5 levels of segmentation
* Advanced segments can be applied to a custom report
* Can be shared using automated email feature

Cons:
* Can only segment using dimensions, not metrics
* Limited number of dimension combinations
* Can only drill into one data point at a time

Filtered Profiles

Filtered profiles are the nuclear bomb of segmentation. They are permanent, segment every report in a profile, and can easily be shared.

In case you’re not familiar with filtered profiles, you can include and exclude data from a profile using a filter. Google applies the filter during data processing, thus segmenting the data.

Once the data has been processed it can never be changed. This means that you can filter historical data AND if you mess up the configuration of a filter you could have really crappy data.

Another issue with filtered profiles is not all data can be filtered. For example, transactional data is different than pageview data. This can cause some funky information in campaign reports and commerce reports.

If you need to filer pageview data then you’ll need to filter your commerce data with different include or exclude filters. Also note that Event data can not be filtered.

But, on the up side, you can use filters to segment things like Absolute Unique Visitors and the Funnel Visualization report. Neither can be done with an Advanced Segment.

Pros:
* Segmentation of every report in Google Analytics
* Can control access by assigning users to filtered profiles

Cons:
* Only effective from date of implementation forward
* Limited number of dimensions
* Issues with filtering other types of data, like events and transactions

I hope this inspired you to come implement different segments using different techniques. As I said in the beginning, there are a lot of ways to slice data in Google Analytics. Find the technique to suit your needs and start segmenting!

Segmentation Options in Google Analytics is a post from: Analytics Talk by Justin Cutroni

My previous post was based on the old, urchin.js tracking code, and a lot of people have been waiting for an update. It’s taken a while, but here it is.

I will mention that my favorite way to exclude traffic from Google Analytics is using an IP exclude filter. An IP based exclude filter is very accurate unless you having a changing IP. The method below works best if you have a dynamic or changing IP address.

Even if you’re not interested in this post, there is a fun ‘group activity’ below. Please try it!

The old version of this hack method required you to add a new page to your website. That page would set the GA custom segment cookie (named __utmv) on your computer.

This technique works fine, but who wants to add a new page to their site? It can be a pain.

I’ve simplified this technique by removing that page. You can enter the JavaScript directly into your browser.

Step 1: Set Custom Segment Cookie

Go to the site that you are tracking with Google Analytics and view a page.

Copy the code below and paste it into the location bar of your browser and click ‘enter’ on your keyboard.

You should see a message that says, “Custom segment has been set. Time to create a filter.”

Here’s a tip, you can bookmark this JS to make it easy to reset the cookie in the future. I set the cookie every time I fire up my browser.

Step 2: Create Exclude Filter

Next, create an exclude filter in Google Analytics to exclude the user defined segment (i.e. the cookie) you just created:

This filter will exclude anyone with a custom segment cookie with a value of ‘remove-me’.

Remember, cookies are specific to a browser and computer. If you use mulitple browsers or multiple computers you need to set the cookie using all the browsers on all the computers you use.

Having Some Fun With This!

You’ve probbaly figured out that you can set the custom segment cookie on anyone’s website as long as they’re using GA. This means that you can add data to their User Defined report. Let’s try this on my site!

Navigate to www.cutroni.com/blog and place the following code in the location bar of your browser after the page has loaded. Change FOO to whatever you want and press enter on your keyword. That’s it. You’re now in my data.

I’ll post some of the more popular and creative values in Twitter and maybe here at a later date.

Please try to keep it clean. I often review data with my 4 year old son :)

Thoughts on the Old Method

The old version of this technique uses a form to set the custom segment cookie which is pretty handy if you have a lot of people in remote locations that need to be excluded from the data. Just send all your coworkers, contractors, etc. a link to the page and ask them to set the cookie on their computer. It’s a little easier than asking them to paste JS into their browser.

If you’re interested in using this technique here is a new version of the page and the process.

Step 1: Create a new page on your site using the code below.

** Note ** The information below is in an iFrame. If you receive this post via email you may not see the contents.

Step 2: Go to the new page you just added, fill out the form, and click the ‘Create Cookie’ button. Keep track of the value you enter into the form, you need it for step 3.

Step 3: Finally, create an exclude filter in Google Analytics to exclude the value that you entered into the form. Remember, you need to use a regular expression for the filter field. So if you entered ‘remove-me’ in the form, enter ‘remove-me’ as the Filter Field.

That’s it. Sorry for the lame post, but I’m trying to update a lot of the old code and posts on the site.

Count Me Out: GA.JS Version is a post from: Analytics Talk by Justin Cutroni

So here it is, an update. I’m not going to re-do the entire post, just a few key points.

Why Do This?

This entire hack configuration is based on one simple idea: to build a more robust view of customers/prospects/leads/whatever-you-call-them. The more information we know about people that we sell to the more we can adjust our marketing. This technique let’s us combine where the visitor came from (referral, campaign, direct, search engine) and how often they’ve been to the site with CRM data.

How It Works

We’re going to extract data from the GA tracking cookies and add it to a lead generation form. The GA data will be stored in hidden form elements that the visitor can not see. When the visitor submits the form the GA will be connected to the other information that the visitor entered into the form (usually name, contact information, etc.).

Here’s the data that we’re going to pull from the GA cookies:

* Current referral information (i.e. where the visitor came from)
* Custom segment value (if it exists)
* How many times the visitor has been to the site

You’re probably wondering why we’re not extracting the data via the GA API. More on that in a minute.

The Code

Here it is, the updated code:

The new code differs from the original code in three ways:

First, the inclusion of ga.js. No explanation needed there.

The second change is the addition of the _uGC() function. This function was in the original urchin.js, and because I don’t include that file I need to include the code in the script.

The function is used to parse pieces of data and return certain parts. For example, I use to to parse the cookies (which are just a string) and return the value of the campaign cookie (__utmz), the custom segment cookie (_utmv) and the visitor identification cookie (__utma).

Finally, I added some new functionality to include this visitor’s number of visits. This data is pulled from the __utma cookie (which identifies the visitor). The last integer in __utma is actually a visit counter. I think it is interesting to understand behavior based on frequency so I added this nugget of data.

If you want to see the code in action try this:

In my previous post I included a reference section that documents the format of the campaign cookie and the _uGC() function. Check it out if you’re looking for more technical information.

An Alternate Approach

Remember, all the data we’re pulling is in first party cookies. This means that you could extract the info at the server level rather than the browser level (first party cookies are available to server side code).

You don’t need to do this in JavaScript, as I did. You could use ColdFusion, PHP, .NET or some other server side language.

I’m just trying to provide some inspiration here :)

What About the Google Analytics API?

I’m sure there are a lot of people out there wondering about the GA API and why I don’t just use it to pull data out from GA. The reason is the data in GA is all anonymous, aggregated data. There’s no way to reach into GA and say, “tell me where John Doe came from.” That’s why we pull data from the cookie, because we can combine it with a visitor’s info when they supply it.

Sure, it is possible to pull out GA data and place it in a CRM (like traffic from an email campaign, bounce rate from paid search, etc.) but it’s tough to identify individuals in that data.

Is it impossible? No, not from a technical standpoint. You would need to place a unique identifier in GA to link the data.

But we’re getting into a risky area here.

Remember, it is against the GA terms of service to capture data in GA that identifies an individual. This could be an email address or database ID number. Not my rule, Google’s, and they will crack down.

I’d be interested to hear people’s thoughts on this. Feel free to comment!

UPDATED: Integrating Google Analytics with a CRM is a post from: Analytics Talk by Justin Cutroni

I know the past week has been full of Google Analytics news, but I’m excited to tell you about something one of our team members created: Google Analytics Notes.

For a long time we’ve wanted to add business data to GA to help keep track of marketing activities, industry news and GA configuration changes. These things are critical to know when analyzing data as they add more context and help us understand what’s affecting website performance.

We tried using Google Spreadsheets to store business info but it never worked. People did not take the time to open up a spreadsheet and add information. We figured that adding some type of ‘note’ functionality to GA would be the easiest way to change this behavior. That’s how GA Notes was born.

GA Notes is a Firefox extension that lets you add business data to a profile. Notes appear in a concealable table at the top of every report.

Any GA user who views a profile, and has the Firefox extension, will see the notes entered for the profile. You can add notes, edit notes and delete notes. Notes can also be exported in XML format for archival purposes.

Installation

Installing GA Notes is easy. Just download the following file to your computer:

https://ga-notes.appspot.com/ganotes.xpi

Once downloaded double click on the file. Firefox should open and ask if you want to install the extension. Click install and that’s it. You’re ready to start adding notes to your GA data.

Usage

The extension adds a ‘Show Notes’ button in the GA menu bar. Click on the button to view notes for this profile or to add a note or edit/delete an existing note. It’s not that complicated. :) We wanted to keep this easy and flexible.

How it Works

For those of you that are interested, GA Notes runs on Google’s App Engine. No data is stored on your machine or our servers. It’s stored on Google’s servers. The Firefox extension provides the interface to enter and display data. But all of the processing and data storage happens on App Engine. All data sent to App Engine is encrypted prior to transmission.

In a perfect world we would have added notes to the data-over-time graph at the top of each report. However, we can’t get inside that part of GA using a Firefox extensions (or Greasemonkey script). We thought this was a good compromise. If anyone out there knows how to dig into Flash let us know! :)

Road Map

This is obviously a beta version of the software. We have a number of features that we’re working on and hope to have done soon. These include:

• Sorting and searching notes by date
• Excel friendly export
• An admin flag for notes to separate admin changes to your GA account
• Some type of alert to show you how many new notes have been added since your last login
• A more graphical visualization of note

If you have any suggestions or ideas please let us know!

Credit

I don’t have the smarts to build these types of things, I just know enough to be dangerous. Chris, a new member of our team, built GA Notes from the ground up. Thanks Chris for all the hard work.

Adding Business Data to Google Analytics Data is a post from: Analytics Talk by Justin Cutroni

Google Analytics has a metric called $Index to help measure the “value” of site pages. But the problem with $Index is that it is an average, and averages can be skewed very easily. $Index is about the performance of a page, not the content on a page. Also, many people want to know how many times a piece of content directly led to a conversion. We just can’t get that with $Index.

We could view this type of analysis as a navigation analysis. Google Analytics has the All Navigation report and the Initial Navigation report, but these reports track things that happen in under 3 clicks and not everyone converts in 3 clicks.

Rather than tackle this problem using navigational analysis, let’s consider it a content challenge. What we want to do is see if a specific piece of content ultimately lead to conversion.

Given this approach we could use the Site Overlay report, which is supposed to show the performance of each link on a page. But, in my experience, the Site Overlay report is buggy at best (and I’m being nice).

We need is a way to link a piece of content, i.e. a pageview, to a conversion. There’s a very simple way to do this using the Funnel Visualization report.

The Concept

Each funnel has a ‘required step’ setting. When enabled, this setting requires that the visitor views the first step in the funnel prior to conversion. If the visitor does not see the first step then the Funnel Visualization report will not count a conversion. The conversion will still be recorded in all other reports, but not the Funnel Visualization report.

What few people know is that it does not matter when the ‘required step’ is viewed, as long as it is viewed prior to the conversion.

We’re going to use this setting to associate a conversion with the content we want to evaluate.

Example

Let’s say I want to track how many people view the About Me page on this blog before subscribing to my RSS feed. I can create a goal and funnel that links the About Me pageview to the RSS subscription goal.

Step 1: Set up the goal

The first step is to create the goal. Just set up the goal like any other normal goal. Identify the goal URL, give the goal a name and a value (if you so desire).

Step 2: Identify the “required step”

Now let’s turn to the funnel. Remember, step 1 in the funnel, the ‘required step’, is really the piece of content (i.e. the pageview) we want to evaluate in terms of conversions. Simply add the page URL to the Step 1 URL field, give the step a name, and check the “required step” checkbox.

That’s it! There’s nothing else to do. The funnel visualization report, for this specific funnel, will only show a conversion if the visitor views the About Me page at some point prior to conversion. GA doesn’t care when the visitor sees the page, as long as they see the page prior to conversion.

The Data

Here’s a sample Funnel report. We can see that 4 conversions occurred after viewing the about me page. Remember, it does not matter when the About Me page was viewed, as long as it was viewed prior to conversion.

Now, if we compare the number of conversions in the Funnel Visualization report, to the overall number of conversions for this goal, we notice there is a difference.

The difference is the number of visits that did not include the About Me page prior to subscribing to the RSS feed. There were 8 total RSS Subscription conversions, but only 4 of those conversions viewed the About Me page prior to converting. Now we know how effective the About Me page was at driving RSS subscriptions.

Taking it Further

What about associating a set of pages with a conversion activity? No problem, just use a regular expression to define your required step. Here’s the same example, but I’ve tweaked to to track visits that include the About Me page or the All Posts page.

And remember, the pageview you specify for your required step does not need to be a real “pageview.” It can be a virtual pageview, generated with the pageTracker._trackPageview() method. In fact, that’s what I’m doing on the blog. I generate a virtual pageview every time someone clicks on the RSS icon.

This technique is very useful if you want to measure how well a specific piece of content on a page is performing. Generate a pageview when a visitor clicks on the content and use it as step 1 in the funnel.

Think this is a good idea? Got one that’s better? Leave a comment!

Tying clicks & content to conversion in GA is a post from: Analytics Talk by Justin Cutroni

Before I get into the list, I want to thank everyone who reads and contributes to Analytics Talk. 2007 was an incredible year for me, and I really owe a lot to you guys. Thank you for reading, posting questions and helping me learn so much.

1. I will migrate to the new GA.JS tracking code.

Google announced a new version of the tracking code, ga.js, in October 2007 and launched the new code in December. After some minor launch problems things seem to be running smoothly. While you don’t need to migrate to ga.js, you should start to think about it because Google will no longer add features to urchin.js. In my opinion, you should tackle this problem sooner rather than later.

2. I will contemplate Event Tracking and how I can use it.

The reason Google introduced a new version of the tracking code was to enable a powerful new feature called Event Tracking. While most folks might think of event tracking as a ‘web 2.0′ tracking tool geared towards video players and Ajax, it’s really a flexible framework for data collection. I was skeptical at first, but now I’m a convert. All of us can take advantage of this new feature.

I’ll be writing more about Event Tracking and its uses when Google pushes the feature to everyone. In the mean time, check out this series of posts to learn more:

Event Tracking Pt. 1: Overview & Data Model
Event Tracking Pt. 2: Implementation
Event Tracking Pt. 3: Reporting & Analysis

3. I will get creative with profiles.

This is something I’ve been talking about for a while. Profiles are so much more than website data. They’re a collection of data and business rules. Last year, as part of my 2007 resolutions, I mentioned setting up test profiles as a way to insure your configuration settings are correct.

For 2008 I suggest setting up profiles for all major marketing campaigns and mediums. Why? So you can segment reports that normally can not be segmented. Check out Segmenting Visitor Loyalty Reports in GA for more information.

4. I will try some type of ‘advanced’ Google Analytics configuration.

Most of us have a fairly basic implementation of GA. We don’t need to do much more than add the tracking code to our site, set up goals, and configure on site search reporting.

Why not try something new this year? How about using an ‘advanced’ feature like custom segmentation, event tracking or even e-commerce tracking? All of these features can help you learn more about your visitors and what they do. That’s why we use these features and try these hacks: to gain insight and knowledge.

5. I will keep track of website changes and Google Analytics changes.

This is something that I wrote about a long time ago, but it’s still really important. It’s a good idea to keep track of your GA configuration changes so you can better understand the data. Any modifications, like a change to a goal, funnel or filter, should be recorded.

It’s also a good idea to keep track of website changes and online marketing changes. Knowing what’s going to happen with your online business helps drive analysis and you’ll be able to deliver data that will make people happy.

You don’t need anything elaborate, a simple Google Spreadsheet, like this one, will work just fine.

There you have it, a few ideas to spice up your 2008 Google Analytics plans. Got a better idea or think that I missed something? Leave a comment below. And happy new year!

2008 Google Analytics Resolutions is a post from: Analytics Talk by Justin Cutroni

Here are three simple tips that can help make your data more accurate.

1. Eliminate Duplicate Data

Many sites that I work on have duplicate data. The usual cause is mixed case URLs. Google Analytics is case sensitive, it captures the data exactly as it appears in the location bar of the browser. So if a URL is of mixed case in the browser, it will be captured and displayed in mixed case within GA.

It’s very easy to have two URLs, that have the same functional meaning, appear as two line items in GA because they have a different case. Here’s an example:

/worldseries/index.php?year=2007&keyword=lowell
/Worldseries/index.php?year=2007&keyword=Lowell

Both URLs are probably the same, they just appear different because of the case. We want to force both URLs to have the same case and thus make them appear as a single line item in GA. This can be done with a Lowercase or Uppercase filter. I like the lowercase filter, but you could easily use the uppercase filter. It’s a personal preference.

The filter below will force the Request URI to lowercase:

I recommend adding a case changing filter to any data element (i.e. filter field) that could be mixed case. This includes:

• Request URI
• Campaign Name
• Campaign Term
• Campaign Medium
• Campaign Source

Another cause of duplicate data is multiple URLs that display the same content but have a different file extension. Here’s an example:

/champions/redsox.php
/champions/redsox.htm

These URLs may appear different (because of the file extension), but the web server might interpret them as the same file. Please note that not every web server behaves this way. It all depends on your web server. Check with your IT guru if your site has URLs with multiple file extensions.

You should merge duplicates URLs, that have different file extensions, into a single line item. I find the best way to do this is with an advanced filter.

Some may think that a search and replace filter is the best way to remove these duplicates. But you would need to create a search and replace filter for each set of URLs that needs to be merged. An advanced filter, because it uses a regular expression, will change every URL that ends in ‘.htm’ to a ‘.php’ extension.

2. Remove Irrelevant Information

Extra information in the URL can cause big problems in Google Analytics. The reason is that GA will capture all of the data in a URL, which includes the query string parameters. Query string parameters that don’t have a functional meaning should be removed from the URL.

An easy way eliminate these parameters is to collect data for a week and then analyze the top content report. Any query string parameter that does not provide insight into what the visitor sees or does should be eliminated.

To remove a query string parameter from GA simply add it to the ‘Exclude URL Query Parameters’ field in the profile settings:

Enter multiple parameters as a comma separated list.

Be aware that once you remove a query string parameter from GA it is completely eliminated from the system. So any goals, funnels or other filters that use that parameter will no longer work.

Also remember that you should remove any query string parameters that contain personally identifiable information. It is against the GA terms of service to collect PII.

3. Identify Your Segment

I could have easily named this tip ‘exclude internal data’ but I wanted to change the way we all think about profiles and the data that’s in them. I believe we should think of profile data in terms of the segment we want to analyze, not who we want to exclude. I know these statements are very close in meaning, but there is a slight difference. Segmentation is so important to analysis. I believe that every time we create a profile we should consider what segment of data it will contain.

I can think if a few segments of data that I would like to analyze:

• CPC traffic
• New visitors
• Return visitors
• European visitors
• Traffic from a specific marketing campaign
• Non-employee traffic
• Traffic generated by my call center

All of the above segments can be created as different profiles using include filters. Each will provide some insight into that segment. Don’t get me wrong, you’ll probably want to exclude internal traffic from 99% of your profiles. But try to think in broader terms, focus on the segment that you want to analyze.

Creating a profile based on a particular segment of traffic is pretty easy. The first thing you want to do is identify what segment of traffic you want to include in your profile. Then create a filter based on the filter filed that represents that segment.

Let’s say I want to see all traffic generated from visitors performing some type of external search on my name. I could apply the following include filter to a profile:

This filter can easily be modified to include a specific marketing campaign (using the Campaign Name field), a specific country (using the Visitor Country field) or any other segment of data so long as it is represented by one of the filter fields. Please note that this will work even if you’re using AdWords auto tagging on, even though you haven’t done any heavy lifting to define the Campaign Term.

By the way, you will want to exclude internal traffic from many profiles. My favorite way to remove internal traffic from a profile is with an ‘Exclude all traffic from an IP address’. Make sure you use anchors at the beginning and end of the regular expression.

Another good way to exclude internal traffic, especially if you don’t have a static IP address, is to use a little hack called Count Me Out. This hack uses the GA custom segment cookie to identify users.

So remember, yes, you need to exclude internal traffic, but try to take a broad view and think about segmentation when you filter your profiles.

Make GA Data Quality Suck Less! is a post from: Analytics Talk by Justin Cutroni

Let me start by saying that there is no API to Google Analytics. There is no formal way to pull data out and integrate it into some other application. Sure, there are some hacks out there to manipulate the report URLs but, in my opinion, this is a pretty big hack and I don’t recommend it to our clients.

When we talk about integrating Google Analytics with a CRM we’re talking about pulling information about the visitor’s originating source and sending it to a CRM system. We’re not going to pull the visitor’s entire history, just where they came from and attach it to other information that they enter into a form.

Why do this?

Pulling a visitor’s source information is very helpful to a sales team. Image if a sales rep could identify how a sales lead found the website before picking up the phone and contacting them? Remember, a visitor’s source info describes how the visitor found the site. Did they respond to a specific email with a certain offer? Or did they come from search and, if so, what was the keyword they used? This type of info can help a sales team understand the intent of the prospect but where in the buying process they are. That makes life for the team a little easier.

So how do we connect a visitor’s source to a visitor?

Conceptual Overview

Google Analytics stores a visitor’s source data in a cookie. That cookie is named __utmz. The data can be extracted from the cookie and added to a lead generation form. When the visitor submits the form the source information is connected to the other information that the visitor entered into the form (usually her name and other contact information).

If the contact form is integrated with a CRM application, like SalesForce.com or NetSuite, it may be possible to store the marketing information with the individual’s contact information. Direct CRM integration depends on your CRM system. Some systems allow form fields to be pulled directly into the application. Check with your CRM provider for information about your specific system.

I would like to note that you don’t need to use some fancy CRM to take advantage of this technique. You can use the technique below even if your lead form generates an email or dumps the data into a database. The key is that we’re leveraging the data in the Google Analytics cookies and connecting it with information that the visitor sends you.

Detailed Instructions

Ok, so how do you actually do this? It takes some coding, either client side coding (JavaScript) or server side code (PHP, ColdFusion, .NET, Java, etc.). My example uses JavaScript. Here’s a basic explanation of what the code needs to do:

1. Extract the visitor’s source data from the __utmz cookie
2. Manipulate data as needed
3. Place data in hidden form fields

When the visitor submits the form the source data in the hidden form fields will be sent back to the server where it can be used.

The sample code below extracts the source information from the cookie and places it in some hidden form fields. Then, when the form is submitted the information is passed to the server.

<html>
<head>

<script src="http://www.google-analytics.com/urchin.js"></script>

<script>
_uact="XXXXXX-X";
urchinTracker();
</script>

<script>
//
// Get the __utmz cookie value. This is the cookies that
// stores all campaign information.
//
var z = _uGC(document.cookie, '__utmz=', ';');
//
// The cookie has a number of name-value pairs.
// Each identifies an aspect of the campaign.
//
// utmcsr  = campaign source
// utmcmd  = campaign medium
// utmctr  = campaign term (keyword)
// utmcct  = campaign content (used for A/B testing)
// utmccn  = campaign name
// utmgclid = unique identifier used when AdWords auto tagging is enabled
//
// This is very basic code. It separates the campaign-tracking cookie
// and populates a variable with each piece of campaign info.
//
var source  = _uGC(z, 'utmcsr=', '|');
var medium  = _uGC(z, 'utmcmd=', '|');
var term    = _uGC(z, 'utmctr=', '|');
var content = _uGC(z, 'utmcct=', '|');
var campaign = _uGC(z, 'utmccn=', '|');
var gclid   = _uGC(z, 'utmgclid=', '|');
//
// The gclid is ONLY present when auto tagging has been enabled.
// All other variables, except the term variable, will be '(not set)'.
// Because the gclid is only present for Google AdWords we can
// populate some other variables that would normally
// be left blank.
//
if (gclid !="-") {
      source = 'google';
      medium = 'cpc';
}
// Data from the custom segmentation cookie can also be passed
// back to your server via a hidden form field
var csegment = _uGC(document.cookie, '__utmv=', ';');
if (csegment != '-') {
      var csegmentex = /[1-9]*?\.(.*)/;
      csegment    = csegment.match(csegmentex);
      csegment    = csegment[1];
} else {
      csegment = '';
}
function populateHiddenFields(f) {
      f.source.value  = source;
      f.medium.value  = medium;
      f.term.value    = term;
      f.content.value = content;
      f.campaign.value = campaign;
      f.segment.value = csegment;
      return true;
}
</script>
</head>
<body>
<form name='contactform'
onSubmit="javascript:populateHiddenFields(this);">
<input type='hidden' name='source' />
<input type='hidden' name='medium' />
<input type='hidden' name='term' />
<input type='hidden' name='content' />
<input type='hidden' name='campaign' />
<input type='hidden' name='segment' />
</form>
</body>
</html>

Now, if this form is directly connected to a CRM then the data in the hidden form fields will go directly into the CRM along with other form info. That’s the magic. Again, you can use this method to collect source information even if the form is not connected to a CRM. Any type of lead generation form will be more valuable if you use this technique.

How The Code Works

When the above page loads in the browser the JavaScript starts to execute and extracts data from the cookies. First, it extracts the value of the __utmz cookie and stores it in a variable named z. Then it parses the z variable and looks for information about the visitor’s source. The __utmz cookie has a number of name-value pairs separated by a pipe (‘|’) character. Each name=value pair holds a different attribute of the visitor’s source. Here’s an example of the __utmz cookie.

12454562.1193706926.14.5.utmcsr=google|utmccn=(organic)|
utmcmd=organic|utmctr=google%2Banalytics%2Bshortcut

You can see that the name value pairs look very similar to the parameters we use for link tagging. Just by looking at the above cookie you can figure out that the visitor performed an organic search on Google for the term ‘google%2Banalytics%2Bshortcut’ or ‘google analytics shortcut’. That’s the type of information that we want to put in hidden form fields and send back to the server. [You can learn more about the __utmz cookie in the reference section below.]

Getting back to the code, we were talking about how the code extracts the information from the z variable. It uses a function named _uGC(), which is found in the urchin.js JavaScript, to do all of the work. __uGC() extracts the value part of all the name-value pairs in the cookie. We call _uGC() for each name-value pair that exists in the cookie. It parses the cookie and pulls out the information that we want. [If you want to know more about _uGC() please see the reference section at the end of this post.]

Once the information is out of the z variable the populateHiddenFileds() functions puts the data in a series of hidden form fields. Then, when the form is submitted, the data is sent to the server.

You’ll notice a few things about the above code. I’ve added some logic to deal with AdWords auto-tagging. Auto tagging populates part of the cookie with a value named gclid. This variable hides some of the info that we need, like source and medium. The logic in the above code populates data that would otherwise be missing. I’ve also added some code that extracts the custom segment value which is stored in the __utmv cookie. I thought it would be useful to send this info back to the server as well.

Conclusion

Pulling visitor source data and connecting it with a visitor is very valuable. While your implementation will almost certainly be different, the concept illustrated above is the foundation for all implementations. Regardless of your implementation the business use for this data is fantastic.

Good luck!

Reference

About the _uGC() Function

_uGC() takes three arguments:

_uGC(string, start-string, end-string)

• A string to search (target string)
• A start string
• An end string

The function will return the string between start string and end string. If the start string is not found then the function will return a dash (-).

About The _utmz Cookie

The __utmz cookie is the referral-tracking cookie. It tracks all referral information regardless of the referral medium or source. This means that all organic, CPC, campaign, or plain referral information is stored in the __utmz cookie. By default the cookie expires in six months, but that can be customized by changing the tracking code.

Cookie Format:

domain-hash.ctime.nsessions.nresponses.utmcsr= X(|utmccn=X|utmctr=X|utmcmd=X|utmci

Data about the referrer is stored in a number of name-value pairs, one for each attribute of the referral:

utmcsr
Identifies a search engine, newsletter name, or other source specified in the
utm_source query parameter See the “Marketing Campaign Tracking”
section for more information about query parameters.

utmccn
Stores the campaign name or value in the utm_campaign query parameter.

utmctr
Identifies the keywords used in an organic search or the value in the utm_term query parameter.

utmcmd
A campaign medium or value of utm_medium query parameter.

utmcct
Campaign content or the content of a particular ad (used for A/B testing)
The value from utm_content query parameter.

utmgclid
A unique identifier used when AdWords auto tagging is enabled This value
is reconciled during data processing with information from AdWords.

Integrating Google Analytics With a CRM is a post from: Analytics Talk by Justin Cutroni

I’d like to highlight a seemingly minor update to the WO documentation that opened my eyes. Along with the new product features, the WO team published a simple tutorial about how to track time-on-page based conversions. This method can be used to create conversions based on how much time a visitor spends on a page.

Why is this important? Some conversion activities have nothing to do with completing a process. Some conversions measure how engaged a visitor is with a website. While there are many ways to measure engagement, and many different opinions about what engagement is, time spent reading a certain page is one way to measure engagement.

Anyway, the method that the optimizer team published in their support doc can be used in Google Analytics to create time-on-page goals. The secret to the tracking is translating how much time a visitor spends on a page into a pageview. Remember, goal tracking in Google Analytics is based on a pageview. We need to create a pageview that indicates the visitor has been on a page for a certain amount of time.

How it Works

To translate time on page to a pageview we use a nifty JavaScript function called setTimeout(). This function will ‘do something’ after a specified interval of time. We can use setTimeout() to create a pageview after some period of time has elapsed. How do we create pageviews in GA? With urchinTracker().

Here’s the code that will create a pageview after a certain amount of time:

<script>
setTimeout('urchinTracker("/read-pages?page="+
_udl.pathname+_udl.search);', 20000);
</script>

You’ll notice that there are two parts to the setTimeout() function. They’re separated by a comma. The first is urchinTracker(). That’s what will create the pageview after a certain amount of time. The second part is the number 20000. That’s the amount of time that setTimeout() will wait before executing urchinTracker() and thus creating the pageview.

<script>
setTimeout('urchinTracker("/read-pages?page="+
_udl.pathname+_udl.search);', 180000);
</script>

Obviously this technique will work for tracking conversion in Website Optimizer. The implementation is slightly different. You need to include the account number in the SetTimeout() function. The reason is that the GA code might have a different account number than the Website Optimizer.

<script>
setTimeout('_uacct="UA-XXXXXX-X";
urchinTracker("/read-pages?page="+_udl.pathname+_udl.search);',
20000);
</script>

Conclusion

I can’t believe that I didn’t think of this method before. :) Thanks WO team for posting that very cool article.

Now, what about number of number-of-visit goals or time-on-site goals? I’ve got the number of visits goal tracking figured out and I’m working on a generic time on site. Stay tuned.

Time-On-Page Goals in Google Analytics & Website Optimizer is a post from: Analytics Talk by Justin Cutroni