Python is a programming language with virtually limitless functionalities and one of the best languages for working with data. Jupyter Notebooks, on the other hand, is the most popular tool for running and sharing both your Python code and data analysis.

Putting Python and Notebooks together with Google Analytics, the most popular and a really powerful tool for tracking websites, gives you almost like a superpower for doing your analysis.

This is exactly what this post is about. Pulling in and analysing your Google Analytics data using Python and Notebooks.

Oh, and by the way, this blog post itself is a Jupyter Notebook created in Google’s Colab, a version of Jupyter Notebooks that makes it super easy to collaboratively work on and share your Notebooks.

We wrote more on how we managed to turn a Notebook into a WordPress blog post in this article.

Without furder ado, let’s start by loading in some dependencies we are going to need for superfsadfsadfsdfsafasdfsadfpulling data from Google Analytics.

import pandas as pd # Pandas is an open source library providing high-performance, easy-to-use data structures and data analysis tools for Python
import json # JSON encoder and decoder for Python
import requests # Library for sending HTTP requests

There are many ways you can pull data from Google Analytics but one of the simplest is by using the API Query URI that you can grab from the Step 1 – Go to Query Explorer

If you are not familiar with the Query Explorer, this is an official tool from Google that lets

you play with the Core Reporting API by building queries to get data from your Google Analytics views (profiles). You can use these queries in any of the client libraries to build your own tools. In this case, the tool is a Notebook.

Step 2 – Authenticate

Choose the Google Account that has access to the Google Analytics View from which you want to get data.

Step 3 – Build the query

If you know how Google Analytics works, building a query is rather straightforward.

First, choose the right Account, Property and View you want to access.

Then choose the date range. You can use the calendar picker or write dynamic ranges like from 90daysAgo to yesterday.

Next, pick the metrics and dimensions. For example, you might pick metrics ga:sessions and ga:users and a dimension ga:date

.

Finally, you can apply sorting, filtering and segmenting rules as you wish. I’d recommend using them after you feel comfortable with the basics.

Perfect. Now test your query by pressing the “Run Query” button. If everything went as expected, you should see a table with results appear in a few seconds.

Step 4 – Get the API Query URI

Now, copy the API Query URI – we are going to use it for making requests straight from the Notebook.

Other options to pull data from Google Analytics using Python include:

• Using the Google Analytics Reporting API library for Python in your Notebook – based on Google API Client for Python
• Building a custom endpoint for handling your queries using the abovementioned API
• Exporting data from Google Analytics UI into CSV or XLSX and importing using pd.read_csv()

Making the request

Now that we have the API Query URI, we can make our first request using Python in the Notebook.

In this example, we are loading the number of Sessions and Users per day for the last 30 days.

from getpass import getpass # required only for hiding your variables

api_query_uri = getpass('Enter API Query URI here') # get the URI
r = requests.get(api_query_uri) # make the request
data= r.json() # read data from a JSON format
df = pd.DataFrame(data['rows']) # turn data into a Pandas data frame
df = df.rename(columns={0: 'Date', 1: 'Sessions', 2: 'Users'}) # giving the columns some proper titles
df['Sessions'] = df['Sessions'].astype(int) # formatting sessions as ints
df['Users'] = df['Users'].astype(int) # formatting users as ints
df['Date'] = pd.to_datetime(df['Date'])

df.head() # printing the first five rows

Enter API Query URI here··········

	Date	Sessions	Users
0	2019-09-25	64076	83335
1	2019-09-26	74569	103784
2	2019-09-27	59752	77642
3	2019-09-28	57743	76690
4	2019-09-29	63712	82980

Great, so our data is now loaded and formatted for our needs.

Let’s go ahead and try visualizing it. For timeseries data, a line chart should work well.

df.plot.line(x='Date', y=['Sessions', 'Users'], ylim=[0,None], figsize=[10, 6])

<matplotlib.axes._subplots.AxesSubplot at 0x7f3cb89692b0>

That was easy, right?

Now, let’s take a look at a bit more advanced visualization by drawing a population pyramid based on data we are now pulling from Google Analytics.

This is how the query looks like:

dimensions: ga:userAgeBracket, ga:userGender
metrics: ga:sessions

api_query_uri = getpass('Enter API Query URI here') # get the URI
r = requests.get(api_query_uri) # make the request
data= r.json() # read data from a JSON format
df = pd.DataFrame(data['rows']) # turn data into a Pandas data frame
df = df.rename(columns={0: 'Age', 1: 'Gender', 2: 'Sessions'}) # giving the columns some proper titles
df['Sessions'] = df['Sessions'].astype(int) # formatting sessions as ints
df.head()

Enter API Query URI here··········

	Age	Gender	Sessions
0	18-24	female	56244
1	18-24	male	9362
2	25-34	female	228866
3	25-34	male	33987
4	35-44	female	109795

import matplotlib.pyplot as plt # Matplotlib is a popular library for drawing plots in Python
import seaborn as sns # Seaborn is a Python data visualization library based on matplotlib

# Making copy of the dataframe and modifying session values to be negative for females (see chart below to see why)
df['Sessions'] = df.apply(lambda row: row['Sessions'] * -1 if row['Gender'] == 'female' else row['Sessions'], axis=1)

# Draw Plot
plt.figure(figsize=(8,5), dpi= 80)
group_col = 'Gender'
order_of_bars = df.Age.unique()[::-1]
colors = [plt.cm.Spectral(i/float(len(df[group_col].unique())-1)) for i in range(len(df[group_col].unique()))]

for c, group in zip(colors, df[group_col].unique()):
    sns.barplot(x='Sessions', y='Age', data=df.loc[df[group_col]==group, :], order=order_of_bars, color=c, label=group)

# Decorations    
plt.xlabel("$Sessions$")
plt.ylabel("Age")
plt.yticks(fontsize=12)
plt.title("Population pyramid of the website visitors", fontsize=16)
plt.legend()
plt.show()

Beautiful, now we know that majority of our audience is younger females.

More custom visualizations

With the wide variety of Python packages available for data visualization, the number of different charts you can use is virtually limitless.

In the next example, let’s try out joy plot. If you don’t know what a joy plot is then you are about to learn it now.

First, let’s install the required Python package.

!pip install joypy # install joypy
import joypy # JoyPy is a one-function Python package based on matplotlib + pandas with a single purpose: drawing joyplots.

Requirement already satisfied: joypy in /usr/local/lib/python3.6/dist-packages (0.2.1)

Now, let’s make the request to load required data. For this example we are using the number of transactions per age bracket and hour of the day for the past 90 days.

api_query_uri = getpass('Enter API Query URI here') # get the URI
r = requests.get(api_query_uri) # make the request
data= r.json() # read data from a JSON format
df = pd.DataFrame(data['rows']) # turn data into a Pandas data frame
df = df.rename(columns={0: 'Hour', 1: 'Age', 2: 'Transactions'}) # giving the columns some proper titles
df['Hour'] = df['Hour'].astype(int) # formatting hours as ints
df['Transactions'] = df['Transactions'].astype(int) # formatting transactions as ints
df.head()

Enter API Query URI here··········

	Hour	Age	Transactions
0	0	18-24	47
1	0	25-34	195
2	0	35-44	32
3	0	45-54	26
4	0	55-64	26

To make our dataframe more suitable for the joy plot, we need to pivot it.

pivot = pd.pivot_table(df, values='Transactions', index=['Hour'],
    columns=['Age'])

pivot = pivot.fillna(0)

pivot.head()

Age	18-24	25-34	35-44	45-54	55-64	65+
Hour
0	47	195	32	26	26	0
1	37	68	37	16	42	0
2	21	16	5	11	5	0
3	0	16	11	0	5	0
4	5	5	5	0	0	0

Now, let’s see how our joy plot looks like by running the following code.

x_range = list(range(24))
fig, axes = joypy.joyplot(pivot, kind="values", x_range=x_range, figsize=(10,8))
axes[-1].set_xticks(x_range);

Looks quite good already. but since most of our customers were in the age bracket 25-34 and we want to visualize the difference in their behavior rather than absolute numbers, let’s normalize the data.

df_norm = (pivot - pivot.min()) / (pivot.max() - pivot.min())
df_norm.head()

Age	18-24	25-34	35-44	45-54	55-64	65+
Hour
0	0.356061	0.313531	0.096429	0.130	0.206349	0.0
1	0.280303	0.103960	0.114286	0.080	0.333333	0.0
2	0.159091	0.018152	0.000000	0.055	0.039683	0.0
3	0.000000	0.018152	0.021429	0.000	0.039683	0.0
4	0.037879	0.000000	0.000000	0.000	0.000000	0.0

Now that the data is normalized, let’s see how a joy plot would look like.

fig, axes = joypy.joyplot(df_norm, kind="values", x_range=x_range, ylim='own', overlap=1.5, figsize=(10,8))
axes[-1].set_xticks(x_range);

Much better in my opinion.

So, what does this joy plot tell us?

• Most transactions are made between 8 AM and 10 PM, almost no one buys between 2 AM and 6 AM.
• Older (65+) people don’t buy after 11 PM while the youngest bracket (18-24) continues buying until 3 AM.

While I agree that this plot didn’t teach us something extremely interesting or new, it is a good example of what’s possible with a few lines of code and Jupyter Notebook (or any other similar tool).

Working with raw hit-level Google Analytics data

While connecting Jupyter Notebooks directly to your Google Analytics view is enough for many use cases, having access to raw hit-level Google Analytics data opens completely new opportunities for more advanced analysis.

To gain access to raw hit-level Google Analytics, one can use a tool like Marketing Data Pipeline to send data into BigQuery. Python has a library for connecting to BigQuery which makes it easy to explore and visualize based on raw data and metrics calculated based on your own criteria.

Besides other use cases, having access to raw hit-level data enables you to get a complete overview of the user journey, calculate metrics like LTV and use your own models for marketing channel attribution (Markov, ML-based, FPA etc.).

Learn more about the benefits of having a marketing data warehouse.

Conclusion

Combining powerful tools like Google Analytics, Python and Jupyter Notebooks gives you the flexibility and options you probably didn’t even dream about. The first time I got to play around with these three together made me feel like a little child, like I had discovered something really-really cool (and it is).

I hope this was enough to get you excited and that you will now go and try doing it on your own. And as always, your comments, questions and suggestions are welcome in the comments below.

The post Working with Google Analytics Data Using Python and Jupyter Notebooks appeared first on Reflective Data.

Visualizing data is all about parsing it and presenting it in a fashion that reveals the underlying trends, turning those raw metrics into meaningful stats and patterns. It’s valuable in many ways, but something you may not have considered is the extent to which it can better equip a brand to provide exceptional customer experiences.

How exactly does it have this effect? Allow me to explain. Let’s take a look at 6 ways in which data visualization can help brands improve their customer experiences:

It can make reports more impactful

SaaS brands don’t just sell their products or services and move on — they’re in the business of helping their clients achieve things, and since many of those clients have their own clients to deal with, providing robust reporting functionality is essential for any large-scale software solution (ecommerce and social media tools are obvious examples). Of course, there are always third-party reporting solutions to fill in any gaps.

If you’re running a retail business and you’re trying to make a case for further investment (or trying to negotiate a deal with a potential supplier), which is going to prove more effective: offering up a dry set of your top metrics, or presenting a clear and crisp visualization of your long-term performance? The better a brand can support its clients in creating clear reports, the better it can make its customer experiences.

It can cut through junk metrics

Make no mistake: the more data you collect, the more junk metrics you’ll end up with. The more you stare at static, the more likely you are to start seeing patterns that don’t mean anything, and it’s frustrating when reviewing data to know that much of what you’re seeing is meaningless. Visualization is extremely useful for looking past those junk metrics and finding what matters.

How does this work? Well, in essence, visualization requires you to select primary metrics (or small sets of metrics), forcing you to be selective — and if you use junk metrics, you’ll end up with a comical visualization that starkly shows how useless that view really is. Help your customers cut through the noise and they’ll appreciate it.

It can assist with telling stories

Crafting a narrative with data can be extremely useful, whether you’re pitching to a prospective supplier, trying to raise morale in your team, or attempting to steadily build an impressive brand. Put together a strong case to show that your business is moving in the right direction, and you’ll have people eating out of the palm of your hand.

Of course, data is finicky at the best of times, and it tends to be opaque and confusing at first glance. Visual storytelling is massively more powerful than its textual equivalent, and composing a creative animated infographic can drive a point home with real aplomb. Think of how charities compose social media graphics to give poverty and disease statistics the gravitas they warrant. Offer that kind of functionality to your customers, and you’ll earn plaudits.

It can help show how customer shopping channels interact

Following up on the ecommerce example, retail data doesn’t stem from isolated channels for typical storefronts. Instead, it’s fed through multiple channels — social media platforms, advertising campaigns, SEO traffic, and even offline marketing. Understanding how the numerous distinct elements are interacting is key to improving the overall strategy.

To achieve this, an ecommerce business needs a CMS capable of multi-channel commerce and intelligible visualization, such as Shopify (it happens to have a fairly comprehensive set of best practices), plus every potential traffic source or action tracked and tagged suitably. That data can then be visualized to clarify the wider context and more usefully highlight the most significant areas for improvement.

It can cater to those lacking technical skills

Imagine the first-time software user trying to make their way in a comprehensive suite with more functions and metrics than they can usefully fathom. Trying to figure out how things are going, they stumble into the reporting section and immediately hit a wall upon seeing massive tables of identical-looking data. It’s a tough learning experience.

When dealing with non-technical customers, using data visualization is a great way to ease them into more complicated functions without asking them to handle anything excessively complex. It’s also excellent for providing intuitive controls (more on that next).

It can better suit touchscreen interfaces

These days, we do so much of our online work using mobile devices that old-fashioned menu systems just don’t fit most circumstances. As noted previously, data visualization doesn’t need to be non-interactive: you can use it to devise a fresh control system using drag-and-drop and connective lines to make it clear how different elements fit together.

Imagine someone with limited technical knowledge being able to compose a strong report regardless through using an intuitive touch-based design. That’s what UX can achieve today (as seen on kiosks across the world through companies such as InTouch), and to make it a CX reality, you need only put in the effort to make it happen.

Making data accessible

In the end, this is what data visualization is about: taking complex and tricky data and making it useful and meaningful for any and all audiences. For the 6 established reasons, it can be a powerful tool for improving customer experiences, so don’t overlook it.

The post 6 Ways Data Visualization Can Help Brands Improve Customer Experience appeared first on Reflective Data.

Creating these visuals on your own can take more time than reading through the slog of information. The good news is that technology has created data visualization tools for marketers to easily pour their data into and create the visuals for them.

There are open-source data visualization software, apps for mobile devices, tools available for free and much more when you start finding the need to get your hands on one of these programs. If you’re currently shopping around, here are a few of the best ones available.

1. FusionCharts

FusionCharts is entirely JavaScript-based, with availability on mobile devices. Since it shares a customer base with Apple, Google, Facebook, Intel and other giant companies, you’ll have access to direct support from the developers and comprehensive tutorials. FusionCharts is even available through an indefinite free trial for developmental reasons.

2. Tableau

Tableau is one of the most powerful, secure and flexible analytics platforms in the industry. Available in mobile apps, desktop programs, servers and everything in between, Tableau has been in this game long enough to know what marketers need. They use proprietary programs to identify all the problems marketers face firsthand. Tableau’s server option starts at $12 a month, but the desktop program is available for $70 a month. They also offer a 14-day free trial.

3. Sisense

Sisense is an outstanding analytics platform for big businesses. Working with NBC, General Electric, Rolls-Royce and many more, they offer powerful reporting and fast dashboards. The interface is easy to learn and use while remaining flexible. However, the price is a little costly. You can only get a real price through a quote based on your specific needs, but one can expect $160 a month at most.

4. IBM Cognos Analytics

IBM is known worldwide for being a technological innovator. Their analytics program is entirely self-service, allowing you the freedom to complete any task at your pace. Uniquely, Cognos Analytics uses artificial intelligence to make everything even smoother. Pricing starts at $70 a month.

5. Grow BI Dashboard

Grow Business Intelligence Dashboard is all about self-serving analytics and reports for their customers without being expensive. Recommended with five stars from GetApp, Capterra and other review sites, Grow can help centralize data in real time. What’s more, as of right now, Grow is free. You can either opt to get the demo version or jump straight into the indefinite free trial.

6. Nexla

Nexla puts a focus on API integration, database connections and FTP servers. They allow data sharing rather than focusing solely on the organizational aspect, yet remain secure the entire time. Nexla is flexible, but easy to use, making it an excellent all-around visualization tool. The free trial lasts for 15 days, after which users can request a customized price quote.

7. Corporator

Corporator differs from the others on this list because of how straightforward it is. The interface is flexible enough without making anything complicated. Corporator focuses on strategic management and key performance indicators to get their mission across. They offer a free trial upon request, as well as quotes based on your business.

Benefits of Visual Tools

Some of the benefits for using visualization tools in business for data may be obvious, but if you’re on the fence about whether or not you need one, here are some things to think about. For instance, 84 percent of businesses find data integral to their core operations, while 95 percent of United States organizations use data for decision-making. Without visualization tools, most of the data will be too comprehensive to be useful.

Even if you are using data without visual aids, you may find they’ll work wonders in propelling your business forward. One customer mapping image could be the foundation of a sales plan, communications improvements, managing referrals in call centers, or any number of things you can imagine.

If you can create a dream with data, you can follow through with visualization tools.

The Future of Visualization

While some may find typical pie charts obvious, other businesses may not know they need such tools until it’s too late in the game. Regardless, the advancement of visual tools doesn’t stop here.

As technology advances, so do businesses. Even touchscreens have completely changed the game on data visualization. Whatever’s coming next, whether it’s an advancement related to instant 5G or the rise of personalized advertising, we’ll know soon enough.

The post 7 Best Data Visualization Tools in 2019 appeared first on Reflective Data.

Therefore, based on my own experience, I will do my best to make the choosing process a bit easier for you. Here’s a list of criteria which I based my suggestions on.

• Number of different charts available
• Flexibility, configurations
• Default styling
• Ease of implementation and use
• Popularity, community
• Free & open source

Projects are very different, in this article we are referring to our experiences building data analytics platform (Reflective Data user behavior analysis dashboard) but most of the thoughts are applicable everywhere.

While YOU have to find the right library for your project, my top is here – first being my favourite for most projects.

Apex Charts

Apex Charts is definitely the newest and least known libraries in this list. And even though it doesn’t have a very large community yet, its beautiful out-of-the-box design and easy setup definitely make up for it.

For several projects, Apex has been our go-to charting library. Definitely worth giving it a try.

Pros

• Beautiful design
• Easy to setup
• Open source

Cons

• Smaller community
• Fewer options than in some larger libraries

Website

Chart.js

Chart.js is one good-looking Javascript charting library that is flexible and easy to use. It used to be our go-to library for many projects before switching to Apex Charts, mostly because of the looks and a few extra features.

Pros

• Looks good out-of-the-box
• Open source
• Easy to setup
• Good community

Cons

• Fewer options than in some larger libraries

Website

Google Charts

Google Charts is a good option if open source is not a must. It is especially good if you are making a tool that should look familiar to Google Products’ (Google Analytics, Data Studio etc.) to users .

Pros

• Nice Material theme
• A lot of options
• Large options

Cons

• Free but not open source
• Can be slower than others

Website

ECharts

ECharts is a powerful Javascript charting library that can meet the needs of a more advanced user. While it’s an overkill for most simpler visualizations, it is definitely worth checking it out to see all of its great features.

The very first version of Reflective Data platform used ECharts as its core charting library.

Pros

• Lots of different charts
• Many options
• Active community
• Open sourced under Apache License

Cons

• Some materials are Chinese only
• Too big for basic projects

Website

Conclusion

No other person can say what is the right solution for your project. The best thing I can recommend is to pick your top three and then build a quick MVP with each of them. This way you can see which one you like the best both in terms of looks and development.

At Reflective Data, we continue using Apex Charts for most of our projects. This said, we still have 5-6 different libraries currently in production, including some paid ones.

Feel free to share your thoughts in the comments below.

The post Top Javascript Charting Libraries appeared first on Reflective Data.

The main difference between the two is that while Query Explorer is built on top of Reporting API v3 the Request Composer has v4 under the hood.

The v3 of Reporting API is still perfectly supported by Google but they recommend using v4 for all new developments, this is also what Google itself claims to be doing. They also have a very detailed guide for migrating from v3 to v4.

But before you start migrating, let’s use Google Analytics Request Composer to see what’s new in v4 (there are some pretty neat new features).

Here’s a quick overview of the new features in v4

• Metric expressionsThe API allows you to request not only built-in metrics but also a combination of metrics expressed in mathematical operations. For example, you can use the expression ga:goal1completions/ga:sessions to request the goal completions per number of sessions.
• Multiple date rangesThe API allows you in a single request to get data in two date ranges.
• Cohorts and Lifetime valueThe API has a rich vocabulary to request Cohort and Lifetime value reports.
• Multiple segmentsThe API enables you to get multiple segments in a single request.

Google Analytics Request Composer

Just like Query Explorer, Request Composer also lets you play around with Google Analytics Reporting API. Super useful whenever working with the API. If you haven’t tried Query Explorer yet, I recommend you check it out first. This way you can get a better overview of what each of the tools is good for.

So, now that you know that the Query Explorer lets you run queries against your Google Analytics account, including all the metrics and dimensions available in the GUI as well as the filters and segments, let’s see why they had to build another tool.

Histogram Request

One of the features the Reporting API v4 introduced is requesting histograms straight from the API. Let’s take a closer look.

Required input:

• startDate
• endDate
• metrics
• Histogram dimension
• Buckets

Example input:

Example output:

As you can see, with the Histogram Query you can define custom buckets. In our example, we divided 24 hours into 6 equal buckets. For more detailed information about the histogram buckets, take a look at this page.

Pivot Request

Another useful feature exclusively available in the Reporting API v4 is Pivot Request.

Required input:

• startDate
• endDate
• metrics
• dimensions
• pivot metrics
• pivot dimensions

Example input:

Example output:

Pivot Query in Reporting API v4 is a super useful feature and we managed to find a few good insights just by playing with it in the Request Composer. Go ahead, see what you can find from your data.

Cohort Request

A cohort is a group of users who share a common characteristic. For example, all users with the same Acquisition Date belong to the same cohort. The cohort analysis report lets you isolate and analyze cohort behavior.

While this feature is still in beta and you can only choose cohorts based on the acquisition date, some users already say it’s the single most useful feature of Google Analytics.

Required input:

• startDate
• endDate
• cohort metrics
• cohort size

Example input:

Example output:

While acquisition date based cohorts are useful, I personally can’t wait for this feature to allow creating cohorts based on other dimensions, such as device category and custom dimensions.

Metric Expression

A metric expression is a mathematical expression you define on existing metrics; it operates like a dynamic calculated metric. You can also define aliases to represent the metric expressions.

Required input:

• startDate
• endDate
• metric expressions

Example input:

Example output:

Just like with other new features the v4 API introduced, making calculations with metrics was possible before but required some extra coding. Having the ability to do it on the query level makes things both faster and clearer.

Conclusion

While Google Analytics Reporting API v3 is still more popular than its successor, the new feature can really make a difference. I definitely recommend you explore what v4 has to offer and Request Composer is by far the best option for getting started.

Let us know in the comments below what are your thoughts on both v4 and Request Composer, should you have any questions just post them, too.

Google Analytics Request Composer

The post Your Guide to Google Analytics Request Composer appeared first on Reflective Data.

At Reflective Data, we are using Apache Superset to monitor all data going through our platform with minimum latency. This allows us to easily combine data from different databases and every analyst can build their own dashboards.

In this article, we are giving a quick overview of what Superset is, what it’s good for and how to get started (installing).

Key Features

• A rich set of data visualizations
• An easy-to-use interface for exploring and visualizing data
• Create and share dashboards
• Enterprise-ready authentication with integration with major authentication providers (database, OpenID, LDAP, OAuth & REMOTE_USER through Flask AppBuilder)
• An extensible, high-granularity security/permission model allowing intricate rules on who can access individual features and the dataset
• A simple semantic layer, allowing users to control how data sources are displayed in the UI by defining which fields should show up in which drop-down and which aggregation and function metrics are made available to the user
• Integration with most SQL-speaking RDBMS through SQLAlchemy
• Deep integration with Druid.io

(Source: https://superset.incubator.apache.org)

Screenshots

(Source: https://superset.incubator.apache.org)

Installing Apache Superset

This tutorial describes the simplest and fastest solution for getting Apache Superset up and running in development. In this article, Ubuntu 16.04 is being used as the platform. For other platforms, custom integrations and production installations, please refer to the official documentation.

Step 1 – Install Dependencies

Apache Superset has some OS-level dependencies, the following

sudo apt-get install build-essential libssl-dev libffi-dev python-dev python-pip libsasl2-dev libldap2-dev

On Ubuntu 16.04 If you have python3.5 installed alongside with python2.7, as is default on Ubuntu 16.04 LTS, run this command also

sudo apt-get install build-essential libssl-dev libffi-dev python3.5-dev python-pip libsasl2-dev libldap2-dev

Step 2 – Python’s setup tools and pip

Get the latest version of pip and setuptools libraries

pip install --upgrade setuptools pip

Step 3 – Install and initialize Apache Superset

Follow these few simple steps to install Superset

# Install superset
pip install superset

# Create an admin user (you will be prompted to set username, first and last name before setting a password)
fabmanager create-admin --app superset

# Initialize the database
superset db upgrade

# Load some data to play with
superset load_examples

# Create default roles and permissions
superset init

# To start a development web server on port 8088, use -p to bind to another port
superset runserver -d

If everything went well, you should be able to go to http://localhost:8088 in your browser, log in using the credentials you entered while creating the admin account. You will have some sample data waiting for you that you can use to play around with different visualizations and dashboards.

Step 4 – Connect your database

While playing around with sample data is fun, connecting your own data source gives Apache Superset a whole new meaning.

As Apache Superset doesn’t ship with database connectors, you will need to install this first. This depends on the type of database you are going to connect to. For MySQL, you’d have to install pip install mysqlclient.

Superset is using SqlAlchemy for connecting to databases.

After logging in to Apache Superset, click on “Sources” and choose “Databases”. There you can add a new connection. All you have to provide is a name and SQLAlchemy URI. The URI will look something like this:

mysql://root:XXXXXXXXXX@104.198.32.xxx:3306/rd_demo_db

After clicking on “Test connection” you should see the list of tables in your database.

Step 5 – Creating your first report

After successfully connecting your first data source, navigate to “tables”. There you can add new tables, based on the tables you have in your database. After adding a table, click on its name and a data explorer with the data from this table will show up.

Try playing with different metrics, dimensions, time-frames and visualizations. I bet you will be surprised by how easy yet flexible the tool is.

After creating a visualization you like, you can simply add to one of the dashboards. Or create a new one if you like.

Getting data into Apache Superset

While Apache Superset can connect to numerous data sources, one of the most common ones is a data warehouse that combines data from various sources (CMS, CRM, analytics, social etc.).

To get data into a data warehouse, companies usually go for a data pipeline that can either stream or batch load data from different tools and other sources into a data warehouse.

One of the most common data warehouses on the market is Google BigQuery which connects easily with Apache Superset. To get data into BigQuery, we recommend using a Marketing Data Pipeline from Reflective Data.

Conclusion

Apache Superset is a powerful business intelligence tool that has flexible data visualization options and is ready for enterprise usage.

As you saw in this article, getting it up and running in your development environment is fast and easy. If you have any interest in business intelligence and data visualization I strongly recommend giving Superset a try.

In case you have already used Apache Superset or if you have any questions, feel free to share in the comments below.

The post Getting Started with Apache Superset, an Enterprise-Ready Business Intelligence Platform appeared first on Reflective Data.

Recently, Google made it even easier to get started with connecting the two, Google Analytics and Data Studio, by giving us three nice-looking yet insightful reports. Even better, you can customize the reports in any way you wish.

Getting started

We expect you already have a Google Analytics account and some data in there. Knowing Data Studio is not needed.

Google Data Studio is an amazing tool and I definitely recommend everyone to play around with sample reports available, try connecting them with your real data and customize them to show the information you care about the most.

Now, to see those three new reports I was talking about you’d have to go to Google Analytics. Pick the right account, property, and view (top left) and click on Customization. Then click on Custom Reports.

There you should be able to see a line that says: “See your audiences, acquisitions and behaviors visualized in a brand new way. Try Google Data Studio now!”. <– you can also click on these links to see the reports.

Now, all you have to do is to click on one of these links. Try all of them to see which one is the most useful for you!

I will quickly go through all of these reports and give you an overview of what you’ll find there.

Audience Report

This report gives you a nice overview of who’s visiting your website.

By default, you’ll see users by language, country, city and new vs returning. If this is not enough, you are welcome to add your own dimensions and metrics, the ones that matter the most to you.

Link to audiences report

Acquisition Report

This report is meant to show you how you acquire visitors, it is also comparing how each channel compares to others based on session count, bounce rate, conversion rate etc.

Just like with other Data Studio reports, you are free to modify it in any way you want.

Link to acquisition report

Behaviour Report

Now that you have an overview of who’s visiting your website and how they got there, it’s time to take look at what they are doing while visiting your site.

Behaviour report shows you pageview and bounce rates over time, draws out the top content and even the most popular events and search terms.

Don’t forget that you can make changes to this report to make it meet your needs even better.

Link to behavior report

Raw Hit-Level Data Report

While connecting Google Data Studio directly to your Google Analytics view is enough for most basic use cases, having access to raw hit-level Google Analytics data opens completely new opportunities for more advanced analysis.

To gain access to raw hit-level Google Analytics, one can use a tool like Marketing Data Pipeline to send data into BigQuery. Google Data Studio has a native connector with BigQuery which makes it easy to explore and visualize based on raw data and metrics calculated based on your own criteria.

Besides other use cases, having access to raw hit-level data enables you to get a complete overview of the user journey, calculate metrics like LTV and use your own models for marketing channel attribution (Markov, ML-based, FPA etc.).

Learn more about the benefits of having a marketing data warehouse.

Conclusion

Google Data Studio is a powerful tool, it is still in beta and has been developing a lot over the past 6 months. I can’t wait to see the features they are still to add.

I recommend everyone to take a look at Data Studio, add some data sources (such as Google Analytics) and play around a little. I am pretty sure you’ll find it easy to use and very likely even useful for your business.

The three new reports covered in this article make a perfect starting point for everyone interested in Data Studio.

Already using Data Studio? Let us know in the comments which use cases you find the most useful!

The post Google Analytics Audiences, Acquisition and Behavior Reports Visualized in Data Studio appeared first on Reflective Data.

Being data-driven begins with data, more specifically with collecting data. Having a lot of data is good and all, but without having what it takes to really understand what’s in there, it is pretty much useless for your business.

To really make use of all the data that you are collecting you need to make it tell you something, and as it usually is in the business – the sooner the better.

This is where the dashboards come into play.

Dashboards are in many ways the best option for exploring and understanding the information that’s hidden in the thousands or millions of data points collected over time. That is, considering the dashboard made the way it should be, not some random plug-and-play thingy.

Custom built business dashboards have so many advantages, here are a few to give you an example.

• Dashboards can combine various data sources and types
• Graphs and diagrams will give you a quick overview of what’s happening
• Time-range graphs help you detect trends and bigger changes
• Better dashboards are interactive, letting you filter data by any given dimension

Now, let’s take a look at some of the dashboards every business should have.

General Business Dashboard

Also known as Executive Reporting Dashboard. Here’s a nice example built on Klipfolio.

An executive reporting dashboard is a central monitoring tool for a company’s real-time performance data tailored to the needs of executives.

• Most important KPIs from various departments
• Reliable helper in decision-making process
• Enables general performance monitoring with ease

Such dashboard is essential for every manager but could be insightful for various departments over the company. If your company doesn’t have one, consider getting one ASAP!

Managers that are using these general dashboards built by Reflective Data have told us that they’re using them for making most of their business decisions.

Social Media Dashboard

Social media is a great medium for both finding new customers and keeping in touch with existing ones. It also generates a lot of data, a dashboard will help you cover it all with ease.

• Monitor all the major KPI-s, in all platforms
• Analyze demographic data and get to know your audience like never before

Being active on social media takes time and effort. With this kind of dashboard, you will know exactly which effort is paying off and which not so much.

Based on insights from this dashboard, you can plan your future strategy on social media more accurately and effectively.

Advanced E-Commerce Dashboard

Running an e-commerce business? This is a dashboard you absolutely must have!

Combining data from various sources this report will show exactly what’s going on with your e-commerce store.

• Which traffic is generating the most revenue
• What might hold your visitors from converting
• Combine and compare multiple data sources

AdWords Performance Dashboard

You are paying for ads. It is super important to see exactly where your money goes and what you get for it.

Here’s to give you an example of what kind of questions an AdWords dashboard would help you answer.

• How are your keywords performing on AdWords?
• Where should you invest more/less?
• How does your paid traffic differ from organic and social media traffic?

Based on feedback we’ve gathered, the AdWords dashboards we have built have saved our clients thousands of dollars every month.

Need help building your next dashboard?

Reflective Data has the experts needed for building all sorts of business dashboards. Here’s a step-by-step overview of the process.

1. Working with the analyst

Our analyst will work closely with your team to make sure what kind of dashboard(s) you need.

What data should be in there and what should be excluded, how to visualize it all etc.

2. Getting the design ready

In this step, our analyst will work with one of our professional designers to put it all in a nice and easy to consume format.

We can also make the dashboard to match your brand guidelines.

3. Making the dashboard come to life

In the final step, our developers combine information from the analyst and designer to make a solid product that will please both you and your team.

Our developers have worked with all sorts of charting libraries and API endpoints.

Over the past 3 years, we have built more than 250 custom dashboards for both startups and large enterprises.

Learn more or contact us today.

Thank you for reading this article, you are more than welcome to share your thoughts down in the comments. Here are some ideas to get you started.

• What business dashboards does your company already have?
• Which tools/platforms you recommend for building custom dashboards?

The post Must-Have Dashboards for Every Data-Driven Business appeared first on Reflective Data.

There are hundreds of great tools and frameworks that allow you to create beautiful charts. Having tried tens of them, I finally chose Google Charts as my go-to tool.

At reflective Data, we are obsessed about good data visualization! And whilst we are heavy users of D3.js and other advanced solutions, we also use other easy to implement yet nice to look at tools. Google Charts being one of them, one of the best ones actually.

Here’s why

There are chart creating tools that would outperform Google Charts in some specific criteria, but combining all of them, GC is a clear winner.

• They look good and familiar (Google, you know)
• They work well with Google related data (Google Analytics, Docs, AdWords …)
• Good documentation & started is easy
• Great options for customisation
• It’s free!

Using Google Charts in a WordPress Post

Google Charts are flexible, you can put them everywhere (on the internet) and one of the places you’d like to use them might be your blog. And if your blog happens to run on WordPress, here’s what you need to know.

Pretty much same applies for all websites.

Step 1 – Load the script

There are multiple ways for loading scripts in WordPress, I am covering the two most common ones.

I recommend adding the script for Google Charts in the <head> as opposed to <body> or <footer>.

Option 1. Put it straight in the <head> tag in your WordPress theme files. Normally header.php

<script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>

Option 2. Load the script using wp_enqueue_script

wp_enqueue_script( 'google-charts', get_template_directory_uri() . '/js/google-charts.js', array(), '20151215', false );

Step 2 – Take a look at the Chart Gallery

They have a super nice gallery showing what can be done using Google Charts, including the source code and even a link to JS Fiddle so you could play around on your own.

Here’s the link.

That’s it, pick the chart you like and drop the code into a WordPress post (text mode).

Examples of Google Charts in a WordPress post

Sample 1 – Line Chart

Code:

<div id="chart_div"></div>
<script>
google.charts.load('current', {packages: ['corechart', 'line']});
google.charts.setOnLoadCallback(drawBasic);
function drawBasic() {
      var data = new google.visualization.DataTable();
      data.addColumn('number', 'X');
      data.addColumn('number', 'Users');
      data.addRows([
        [0, 0],   [1, 10],  [2, 23],  [3, 17],  [4, 18],  [5, 9],
        [6, 11],  [7, 27],  [8, 33],  [9, 40],  [10, 32], [11, 35],
        [12, 30], [13, 40], [14, 42], [15, 47], [16, 44], [17, 48],
        [18, 52], [19, 54], [20, 42], [21, 55], [22, 56], [23, 57],
        [24, 60], [25, 50], [26, 52], [27, 51], [28, 49], [29, 53],
        [30, 55], [31, 60], [32, 61], [33, 59], [34, 62], [35, 65],
        [36, 62], [37, 58], [38, 55], [39, 61], [40, 64], [41, 65],
        [42, 63], [43, 66], [44, 67], [45, 69], [46, 69], [47, 70],
        [48, 72], [49, 68], [50, 66], [51, 65], [52, 67], [53, 70],
        [54, 71], [55, 72], [56, 73], [57, 75], [58, 70], [59, 68],
        [60, 64], [61, 60], [62, 65], [63, 67], [64, 68], [65, 69],
        [66, 70], [67, 72], [68, 75], [69, 80]
      ]);
      var options = {
        hAxis: {
          title: 'Time'
        },
        vAxis: {
          title: 'Count'
        }
      };
      var chart = new google.visualization.LineChart(document.getElementById('chart_div'));
      chart.draw(data, options);
    }
</script>

Sample 2 – Pie Chart

Code:

<div id="piechart"></div>
<script>
      google.charts.load('current', {'packages':['corechart']});
      google.charts.setOnLoadCallback(drawChart);

      function drawChart() {

        var data = google.visualization.arrayToDataTable([
          ['Task', 'Hours per Day'],
          ['Work',     11],
          ['Eat',      2],
          ['Commute',  2],
          ['Watch TV', 2],
          ['Sleep',    7]
        ]);

        var options = {
          title: 'My Daily Activities'
        };

        var chart = new google.visualization.PieChart(document.getElementById('piechart'));

        chart.draw(data, options);
      }
</script>

Sample 3 – Combo Chart

Code:

<div id="combo_chart" style="width: 700px; height: 500px;"></div>
<script>
      google.charts.load('current', {'packages':['corechart']});
      google.charts.setOnLoadCallback(drawVisualization);
      function drawVisualization() {
        // Some raw data (not necessarily accurate)
        var data = google.visualization.arrayToDataTable([
         ['Month', 'Bolivia', 'Ecuador', 'Madagascar', 'Papua New Guinea', 'Rwanda', 'Average'],
         ['2005/06',  135,      1120,        599,             1268,          288,      682],
         ['2006/07',  157,      1167,        587,             807,           397,      623],
         ['2007/08',  139,      1110,        615,             968,           215,      609.4],
         ['2008/09',  136,      691,         629,             1026,          366,      569.6]
      ]);
    var options = {
      title : 'Monthly Coffee Production by Country',
      vAxis: {title: 'Cups'},
      hAxis: {title: 'Month'},
      seriesType: 'bars',
      series: {5: {type: 'line'}}
    };
    var chart = new google.visualization.ComboChart(document.getElementById('combo_chart'));
    chart.draw(data, options);
  }
</script>

Why not just use images of charts?

Of course, you could also use some tools that will enable you to create charts as image files that you can later upload to WordPress. Let me tell you why you should consider not to.

• That’s an extra step. You’d still have to insert all the data in there like you do with the Google Charts.
• It’s super easy to update data straight in your post.
• It’s interactive, just move your mouse over the examples above.

Just give it a try and you will see the difference!

Isn’t putting the code in the post a bad idea?

If you are a heavy user of those graphs, I would recommend building a plugin or at least a shortcode for them. But if you only use a few charts once in a while in your posts there’s nothing bad about inserting them in plain code straight into your post.

Should you have any questions about the setup, just ask them in the comments below and we’ll get them answered!

Conclusion

If you are looking for an easy-to-implement charting library that is also nice to look at and has a ton of customization options, I would recommend giving Google Charts a try. Besides everything else, it also has a super nice library and a good community using it.

In case you are looking for a really scalable charting solution with virtually unlimited customization options, look into D3.js.

Get started with Google Charts

Please let us know in the comments which charting library you are using and what are its benefits. Plus if you have any questions about setting up Google Charts, don’t hesitate to ask us.

The post Using Google Charts in a WordPress Post appeared first on Reflective Data.