#30daysago
Explore tagged Tumblr posts
Visit Tumblr Blog
Explore Tumblr blogs with no restrictions, modern design and the best experience.
Last Seen Tumblr Blogs
Fun Fact
Tumblr has 4 main sources of revenue.
Photo
When you watch the last 5 minutes of Super Bowl 52 just before going to bed to relive that glorious moment when your team won the chip. You go to sleep with a big smile... #priceless #eagles #philly #superbowlchamps #30daysago #underdogs #hungrydogsrunfaster (at Oviedo, Florida)
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes
Text
Google Analytics API v4: Histogram Buckets
Google Analytics API v4: Histogram Buckets
Back in April of last year, Google released version 4 of their reporting API. One of the new features they’ve added is the ability to request histogram buckets straight from Google, instead of binning the data yourself. Histograms allow you to examine the underlying frequency distribution of a set of data, which can help you make better decisions with your data. They’re perfect for answering questions like:
Do most sessions take about the same amount of time to complete, or are there distinct groups?
What percentage of page loads happen in under two seconds?
What is the relationship between session count and transactions per user?
Want to see for yourself? We’ve got a handy demo you can use to visualize some of your very own data. To get started, click ‘Connect’ below.
Try It Yourself
We’ve put together a simple demo that you can use to do a little exploring.
How It Really Works
Here’s how to use this new Histogram feature yourself with the API.
Note: we’re assuming you’ve got the technical chops to handle authorizing access to your own data and issuing the requests to the API.
Here’s what a typical query looks like with the new version of the API:
{ "reportRequests": [ { "viewId": "VIEW_ID", "dateRanges": [ { "startDate": "30daysAgo", "endDate": "yesterday" } ], "metrics": [ { "expression": "ga:users" } ], "dimensions": [ { "name": "ga:hour" } ], "orderBys": [ { "fieldName": "ga:hour", "sortOrder": "ASCENDING" } ] } ] }
This query will return a row for each hour, with the number of users that generated a session during that hour for each row; simplified, it’d be something like this:
[ ['0', 100], ['1', 100], ['2', 100], ['3', 110], ['4', 120], ['5', 140], ['6', 220], ['7', 300], ... ]
Wouldn’t this data be more useful if it were dayparted? Let’s use the histogram feature to bucket our data into traditional TV dayparts:
Early Morning 6:00 AM – 10:00 AM Daytime 10:00 AM – 5:00 PM Early Fringe 5:00 PM – 8:00 PM Prime Time 8:00 PM – 11:00 PM Late News 11:00 PM – 12:00 PM Late Fringe 12:00 PM – 1:00 AM Post Late Fringe 1:00 AM – 2:00 AM Graveyard 2:00 AM – 6:00 AM
To request our data be returned in these new buckets, we’ll need to make two modifications to our query from before. The first change we’ll make is to add a histogramBuckets array to the ga:hour object in our dimensions array. We’ll populate this with ["0", "2", "6", "10", "17", "20", "22", "23"]. Each number in this sequence marks the beginning of a new histogram bin.
The end of the bin is inferred by the number that follows it, and if values exist below the first bin’s minimum an additional bin will be tacked on for us at the beginning to contain those values. For example, if we had started our histogramBuckets with “2” instead of “0”, the API would add a new bucket to the beginning named “
http://ift.tt/2fhtBGP
0 notes