[!NOTE] You might not need this package. Please check Third Party Libraries first.

Nextjs Google Analytics

Google Analytics for Next.js

This package optimizes script loading using Next.js Script tag, which means that it will only work on apps using Next.js >= 11.0.0.

Installation

npm install --save nextjs-google-analytics

TL;DR

Add the GoogleAnalytics component with the trackPageViews prop set to true to your custom App file:

1// pages/_app.js
2import { GoogleAnalytics } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  return (
6    <>
7      <GoogleAnalytics trackPageViews />
8      <Component {...pageProps} />
9    </>
10  );
11};
12
13export default App;

You can pass your Google Analytics measurement id by setting it on the NEXT_PUBLIC_GA_MEASUREMENT_ID environment variable or using the gaMeasurementId prop on the GoogleAnalytics component. The environment variable will override the prop if both are set.

Usage

Your Google Analytics measurement id is read from NEXT_PUBLIC_GA_MEASUREMENT_ID environment variable, so make sure it is set in your production environment:

• Vercel
• Netlify

If the variable is not set or is empty, nothing will be loaded, making it safe to work in development.

To load it and test it on development, add:

NEXT_PUBLIC_GA_MEASUREMENT_ID="G-XXXXXXXXXX"

to your .env.local file.

As an alternative, you can use the gaMeasurementId param to pass your Google Analytics measurement id.

The NEXT_PUBLIC_GA_MEASUREMENT_ID environment variable will take precedence over the gaMeasurementId param, so if both are set with different values, the environment variable will override the param.

Scripts

Use the GoogleAnalytics component to load the gtag scripts. You can add it to a custom App component and this will take care of including the necessary scripts for every page (or you could add it on a per page basis if you need more control):

1// pages/_app.js
2import { GoogleAnalytics } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  return (
6    <>
7      <GoogleAnalytics />
8      <Component {...pageProps} />
9    </>
10  );
11};
12
13export default App;

By default, scripts are loaded using the afterInteractive strategy, which means they are injected on the client-side and will run after hydration.

If you need more control, the component exposes the strategy prop to control how the scripts are loaded:

1// pages/_app.js
2import { GoogleAnalytics } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  return (
6    <>
7      <GoogleAnalytics strategy="lazyOnload" />
8      <Component {...pageProps} />
9    </>
10  );
11};
12
13export default App;

also, you can use alternative to default path for googletagmanager script by

1<GoogleAnalytics gtagUrl="/gtag.js" />

Page views

To track page views set the trackPageViews prop of the GoogleAnalytics component to true.

1// pages/_app.js
2import { GoogleAnalytics } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  return (
6    <>
7      <GoogleAnalytics trackPageViews />
8      <Component {...pageProps} />
9    </>
10  );
11};
12
13export default App;

By default it will be trigger on hash changes if trackPageViews is enabled, but you can ignore hash changes by providing an object to the trackPageViews prop:

1// pages/_app.js
2import { GoogleAnalytics } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  return (
6    <>
7      <GoogleAnalytics trackPageViews={{ ignoreHashChange: true }} />
8      <Component {...pageProps} />
9    </>
10  );
11};
12
13export default App;

As an alternative, you can directly call the usePageViews hook inside a custom App component, do not set trackPageViews prop on the GoogleAnalytics component or set it to false (default):

1// pages/_app.js
2import { GoogleAnalytics, usePageViews } from "nextjs-google-analytics";
3
4const App = ({ Component, pageProps }) => {
5  usePageViews(); // IgnoreHashChange defaults to false
6  // usePageViews({ ignoreHashChange: true });
7
8  return (
9    <>
10      <GoogleAnalytics /> {/* or <GoogleAnalytics trackPageViews={false} /> */}
11      <Component {...pageProps} />
12    </>
13  );
14};
15
16export default App;

The module also exports a pageView function that you can use if you need more control.

Custom event

You can use the event function to track a custom event:

1import { useState } from "react";
2import Page from "../components/Page";
3import { event } from "nextjs-google-analytics";
4
5export function Contact() {
6  const [message, setMessage] = useState("");
7
8  const handleInput = (e) => {
9    setMessage(e.target.value);
10  };
11
12  const handleSubmit = (e) => {
13    e.preventDefault();
14
15    event("submit_form", {
16      category: "Contact",
17      label: message,
18    });
19
20    setState("");
21  };
22
23  return (
24    <Page>
25      <h1>This is the Contact page</h1>
26      <form onSubmit={handleSubmit}>
27        <label>
28          <span>Message:</span>
29          <textarea onChange={handleInput} value={message} />
30        </label>
31        <button type="submit">submit</button>
32      </form>
33    </Page>
34  );
35}

For the possible parameters that can be specified in the event, please refer to the event command in the Google tag API reference.

• Google tag API reference - event

Consent

You can use the consent function to update your users' cookie preferences (GDPR).

1 const consentValue: 'denied' | 'granted' = getUserCookiePreferenceFromLocalStorage(); // 'denied' or 'granted'
2 
3 consent({
4    arg: 'update',
5    params: {
6      ad_storage: consentValue,
7      analytics_storage: consentValue,
8      ad_user_data: conentValue,
9      ad_personalization: conentValue
10    },
11 });

For the possible values that can be specified in arg and params, please refer to the consent command in the Google tag API reference.

• Google tag API reference - consent

Web Vitals

To send Next.js web vitals to Google Analytics you can use a custom event on the reportWebVitals function inside a custom App component:

1// pages/_app.js
2import { GoogleAnalytics, event } from "nextjs-google-analytics";
3
4export function reportWebVitals({ id, name, label, value }) {
5  event(name, {
6    category: label === "web-vital" ? "Web Vitals" : "Next.js custom metric",
7    value: Math.round(name === "CLS" ? value * 1000 : value), // values must be integers
8    label: id, // id unique to current page load
9    nonInteraction: true, // avoids affecting bounce rate.
10  });
11}
12
13const App = ({ Component, pageProps }) => {
14  return (
15    <>
16      <GoogleAnalytics />
17      <Component {...pageProps} />
18    </>
19  );
20};
21
22export default App;

If you are using TypeScript, you can import NextWebVitalsMetric from next/app:

1import type { NextWebVitalsMetric } from "next/app";
2
3export function reportWebVitals(metric: NextWebVitalsMetric) {
4  // ...
5}

Using the gaMeasurementId param

All exported components, hooks, and functions, accept an optional gaMeasurementId param that can be used in case no environment variable is provided:

1// pages/_app.js
2import { GoogleAnalytics, event } from "nextjs-google-analytics";
3import { gaMeasurementId } from "./lib/gtag";
4
5export function reportWebVitals({
6  id,
7  name,
8  label,
9  value,
10}: NextWebVitalsMetric) {
11  event(
12    name,
13    {
14      category: label === "web-vital" ? "Web Vitals" : "Next.js custom metric",
15      value: Math.round(name === "CLS" ? value * 1000 : value), // values must be integers
16      label: id, // id unique to current page load
17      nonInteraction: true, // avoids affecting bounce rate.
18    },
19    gaMeasurementId
20  );
21}
22const App = ({ Component, pageProps }) => {
23  usePageViews({ gaMeasurementId });
24
25  return (
26    <>
27      <GoogleAnalytics gaMeasurementId={gaMeasurementId} />
28      <Component {...pageProps} />
29    </>
30  );
31};
32
33export default App;

Debugging you Google Analytics

1. Install the Google Analytics Debugger.

2. Turn it on by clicking its icon to the right of the address bar.

3. Open the Chrome Javascript console to see the messages.

   On Windows and Linux, press Control-Shift-J.

   On Mac, press Command-Option-J.

4. Refresh the page you are on.

TypeScript

The module is written in TypeScript and type definitions are included.

Contributing

Contributions, issues and feature requests are welcome!

Show your support

Give a ⭐️ if you like this project!

LICENSE

MIT