diff --git a/integrations/google-analytics-4/karma.conf-ci.js b/integrations/google-analytics-4/karma.conf-ci.js
new file mode 100644
index 000000000..2ba15b707
--- /dev/null
+++ b/integrations/google-analytics-4/karma.conf-ci.js
@@ -0,0 +1 @@
+module.exports = require('../../karma.conf-ci.js');
diff --git a/integrations/google-analytics-4/karma.conf.js b/integrations/google-analytics-4/karma.conf.js
new file mode 100644
index 000000000..8605180af
--- /dev/null
+++ b/integrations/google-analytics-4/karma.conf.js
@@ -0,0 +1 @@
+module.exports = require('../../karma.conf');
diff --git a/integrations/google-analytics-4/lib/index.js b/integrations/google-analytics-4/lib/index.js
new file mode 100644
index 000000000..5e5ea705b
--- /dev/null
+++ b/integrations/google-analytics-4/lib/index.js
@@ -0,0 +1,309 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+var integration = require('@segment/analytics.js-integration');
+var reject = require('reject');
+
+/**
+ * GA4
+ */
+var GA4 = (module.exports = integration('Google Analytics 4')
+  .global('gtag')
+  .global('ga4DataLayer')
+  .option('measurementIds', [])
+  .option('cookieDomainName', 'auto')
+  .option('cookiePrefix', '_ga')
+  .option('cookieExpiration', 63072000)
+  .option('cookieUpdate', true)
+  .option('cookieFlags', '')
+  .option('sendAutomaticPageViewEvent', false)
+  .option('allowAllAdvertisingFeatures', false)
+  .option('allowAdvertisingPersonalization', false)
+  .option('disableGoogleAnalytics', false)
+  .option('googleReportingIdentity', 'device')
+  .option('userProperties', {})
+  /**
+   * Custom Events and Parameters setting. This setting is used by the track
+   * handler to map Segment events and fields to Google analytics events and parameters.
+   *
+   * Example:
+   * [
+   *   {
+   *     "googleEvent": "new_episode",
+   *     "parameters": [
+   *       {
+   *         "key": "properties.title",
+   *         "value": "title"
+   *       },
+   *       {
+   *         "key": "properties.genre",
+   *         "value": "genre"
+   *       }
+   *     ],
+   *     "segmentEvent": "Started Episode"
+   *   }
+   * ]
+   */
+  .option('customEventsAndParameters', [])
+  .tag(
+    '<script src="//www.googletagmanager.com/gtag/js?id={{ measurementId }}&l=ga4DataLayer">'
+  ));
+
+/**
+ * Initialize.
+ *
+ * https://developers.google.com/analytics/devguides/collection/ga4
+ *
+ * @api public
+ */
+GA4.prototype.initialize = function() {
+  window.ga4DataLayer = window.ga4DataLayer || [];
+  window.gtag = function() {
+    window.ga4DataLayer.push(arguments);
+  };
+
+  /**
+   * This line is in all of the gtag examples but is not well documented. Research
+   * says that it is is related to deduplication.
+   * https://stackoverflow.com/questions/59256532/what-is-the-js-gtags-js-command
+   */
+  window.gtag('js', new Date());
+
+  var opts = this.options;
+  var measurementIds = opts.measurementIds;
+
+  /**
+   * Avoid loading and configuring gtag.js if any are true:
+   *  - Disable Google Analytics setting is enabled
+   *  - No measurement IDs are configured
+   */
+  if (!measurementIds.length || opts.disableGoogleAnalytics) {
+    return;
+  }
+
+  var config = {
+    /**
+     * Disable Google's Automatic Page View Measurement
+     * https://developers.google.com/analytics/devguides/collection/ga4/disable-page-view
+     */
+    send_page_view: opts.sendAutomaticPageViewEvent,
+
+    /**
+     * Cookie Update
+     * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#cookie_update_parameter
+     */
+    cookie_update: opts.cookieUpdate,
+
+    /**
+     * Cookie Domain Name
+     * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#cookie_domain_configuration
+     */
+    cookie_domain: opts.cookieDomainName,
+
+    /**
+     * Cookie Prefix
+     * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#cookie_prefix
+     */
+    cookie_prefix: opts.cookiePrefix,
+
+    /**
+     * Cookie Expiration
+     * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#cookie_expiration
+     */
+    cookie_expires: opts.cookieExpiration,
+  };
+
+  var sets = [
+    /**
+     * Cookie Flags
+     * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#cookie_flags
+     */
+    [{ cookie_flags: opts.cookieFlags }],
+
+    /**
+     * Disable All Advertising
+     * https://developers.google.com/analytics/devguides/collection/ga4/display-features#disable_all_advertising_features
+     */
+    ['allow_google_signals', opts.allowAllAdvertisingFeatures],
+
+    /**
+     * Disable Advertising Personalization
+     * https://developers.google.com/analytics/devguides/collection/ga4/display-features#disable_advertising_personalization
+     */
+    ['allow_ad_personalization_signals', opts.allowAdvertisingPersonalization]
+  ];
+
+  // Load gtag.js using the first measurement ID, then configure using the `config` commands built above.
+  var self = this;
+  this.load({ measurementId: measurementIds[0] }, function() {
+    /**
+     * Measurement IDs.
+     * The same configuration information is shared across all measurement IDs.
+     * https://developers.google.com/analytics/devguides/collection/ga4#add_an_additional_google_analytics_property_to_an_existing_tag
+     */
+    for (var i = 0; i < measurementIds.length; i++) {
+      window.gtag('config', measurementIds[i], config)
+
+    }
+
+    /**
+     * Set persistent values shared across all gtag.js usage.
+     * https://developers.google.com/gtagjs/reference/api#set
+     */
+    for (var i = 0; i < sets.length; i++) {
+      window.gtag.apply(null, sets[i]);
+    }
+
+    self.ready();
+  });
+};
+
+/**
+ * Loaded?
+ *
+ * @api private
+ * @return {boolean}
+ */
+GA4.prototype.loaded = function() {
+  return !!(
+    window.ga4DataLayer && Array.prototype.push !== window.ga4DataLayer.push
+  );
+};
+
+/**
+ * Identify.
+ *
+ * @api public
+ * @param {Facade.Identify} event
+ */
+GA4.prototype.identify = function(identify) {
+  var opts = this.options;
+  var userPropertyMappings = opts.userProperties;
+
+  var userProperties = {};
+
+  // Map all customer-defined user property mappings.
+  for (var eventField in userPropertyMappings) {
+    if (!userPropertyMappings.hasOwnProperty(eventField)) {
+      continue;
+    }
+
+    var userProp = userPropertyMappings[eventField];
+    var value = identify.proxy(eventField);
+
+    userProperties[userProp] = value;
+  }
+
+  /**
+   * Map the user_id property if the Google Reporting Identity is set one of:
+   *   - By User ID, Google signals, then device (userIdSignalsAndDevice)
+   *   - By User ID and Devicea (userIdAndDevice)
+   * 
+   * Google's Reporting Identity: https://support.google.com/analytics/answer/9213390?hl=en
+   * 
+   * Note that the user ID can be appended as part of the user_properties
+   * object instead of being configured by an explicit command.
+   * https://developers.google.com/analytics/devguides/collection/ga4/cookies-user-id#set_user_id
+   */
+  var userId = identify.userId();
+  var validReportingIdentity = opts.googleReportingIdentity === 'userIdSignalsAndDevice' || opts.googleReportingIdentity === 'userIdAndDevice'
+  if (userId && validReportingIdentity) {
+    userProperties.user_id = userId;
+  }
+
+  if (Object.keys(userProperties).length) {
+    window.gtag('set', 'user_properties', userProperties);
+  }
+};
+
+/**
+ * Group
+ *
+ * @api public
+ * @param {Facade.Group} group
+ */
+GA4.prototype.group = function(group) {
+  window.gtag('event', 'join_group', {
+    group_id: group.groupId()
+  });
+};
+
+/**
+ * Page
+ *
+ * @api public
+ * @param {Facade.Page} page
+ */
+GA4.prototype.page = function(page) {
+  // If the Send Google's Automatic Page View Measurement setting is set to true then
+  // don't handle page calls to avoid duplicate page_view events.
+  if (this.options.sendAutomaticPageViewEvent) {
+    return;
+  }
+
+  var props = page.properties();
+  var name = page.fullName();
+
+  var pageLocation = props.url;
+  var pageReferrer = page.referrer();
+  var pageTitle = name || props.title;
+
+  window.gtag('event', 'page_view', {
+    page_location: pageLocation,
+    page_referrer: pageReferrer,
+    page_title: pageTitle
+  });
+};
+
+/**
+ * Track
+ *
+ * @api public
+ * @param {Track} track
+ */
+
+GA4.prototype.track = function(track) {
+
+  var mappings = this.options.customEventsAndParameters;
+
+  for (var i = 0; i < mappings.length; i++) {
+    var mapping = mappings[i];
+    if (typeof mapping !== 'object') {
+      continue;
+    }
+
+    var segmentEvent = mapping.segmentEvent;
+    var googleEvent = mapping.googleEvent;
+  
+    if (!segmentEvent || !googleEvent || segmentEvent !== track.event()) {
+      continue;
+    }
+
+    var parameterMappings = mapping.parameters || [];
+    var parameters = {};
+
+    if (!(parameterMappings instanceof Array)) {
+      continue;
+    }
+
+    // Map Segment event fields to Google Event Parameters.
+    // Text map settings that are nested in a mixed settings take on a different shape
+    // than a top-level text map setting.
+    // eg; [{ key: 'properties.genre', value: 'primary_genre }]
+    //
+    for (var j = 0; j < parameterMappings.length; j++) {
+      var map = parameterMappings[j] || {};
+      if (typeof map !== 'object' || !map.key || !map.value) {
+        continue;
+      }
+
+      var param = map.value;
+      var value = track.proxy(map.key);
+      parameters[param] = value;
+    }
+
+    window.gtag('event', googleEvent, parameters);
+  }
+};
diff --git a/integrations/google-analytics-4/package.json b/integrations/google-analytics-4/package.json
new file mode 100644
index 000000000..9e2368316
--- /dev/null
+++ b/integrations/google-analytics-4/package.json
@@ -0,0 +1,55 @@
+{
+  "name": "@segment/analytics.js-integration-google-analytics-4",
+  "version": "0.0.1",
+  "description": "",
+  "main": "lib/index.js",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "karma start"
+  },
+  "author": "Segment <friends@segment.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://github.com/segmentio/analytics.js-integrations/blob/master/integrations/google-analytics-4#readme",
+  "bugs": {
+    "url": "https://github.com/segmentio/analytics.js-integrations/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/segmentio/analytics.js-integrations.git"
+  },
+  "dependencies": {
+    "@ndhoule/defaults": "^2.0.1",
+    "@segment/analytics.js-integration": "^3.1.0",
+    "component-each": "^0.2.6",
+    "extend": "^3.0.2",
+    "global-queue": "^1.0.1",
+    "is": "^3.1.0",
+    "lodash": "^4.17.4",
+    "obj-case": "^0.2.0",
+    "object-component": "0.0.3",
+    "reject": "0.0.1",
+    "segmentio-facade": "^3.2.7",
+    "use-https": "^0.1.1"
+  },
+  "devDependencies": {
+    "@segment/analytics.js-core": "^3.8.2",
+    "@segment/analytics.js-integration-tester": "^3.1.1",
+    "@segment/clear-env": "^2.1.1",
+    "browserify": "^16.2.3",
+    "eslint": "^5.16.0",
+    "karma": "^4.1.0",
+    "karma-browserify": "^6.0.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-sauce-launcher": "^2.0.2",
+    "karma-spec-reporter": "^0.0.32",
+    "karma-summary-reporter": "^1.6.0",
+    "mocha": "^6.1.4",
+    "to-array": "^0.1.4",
+    "watchify": "^3.7.0"
+  }
+}
diff --git a/integrations/google-analytics-4/test/index.js b/integrations/google-analytics-4/test/index.js
new file mode 100644
index 000000000..d873c8b0c
--- /dev/null
+++ b/integrations/google-analytics-4/test/index.js
@@ -0,0 +1,312 @@
+'use strict';
+
+var Analytics = require('@segment/analytics.js-core').constructor;
+var integration = require('@segment/analytics.js-integration');
+var sandbox = require('@segment/clear-env');
+var tester = require('@segment/analytics.js-integration-tester');
+var GA4 = require('../lib/');
+
+// gtag.js saves arrays as argument objects and assert.deepEquals fails when comparing
+// argument objects against arrays.
+var toArray = require('to-array');
+
+describe('Google Analytics 4', function () {
+    var analytics;
+    var ga4;
+
+    var settings = {
+        measurementIds: ['G-100', 'G-200']
+    };
+
+    beforeEach(function () {
+        analytics = new Analytics();
+        ga4 = new GA4(settings);
+        analytics.use(GA4);
+        analytics.use(tester);
+        analytics.add(ga4);
+    });
+
+    afterEach(function () {
+        analytics.restore();
+        analytics.reset();
+        ga4.reset();
+        sandbox();
+    });
+
+    it('should have the right settings', function () {
+        analytics.compare(
+            GA4,
+            integration('Google Analytics 4')
+                .global('gtag')
+                .global('ga4DataLayer')
+                .option('measurementIds', [])
+                .option('cookieDomainName', 'auto')
+                .option('cookiePrefix', '_ga')
+                .option('cookieExpiration', 63072000)
+                .option('cookieUpdate', true)
+                .option('cookieFlags', '')
+                .option('sendAutomaticPageViewEvent', false)
+                .option('allowAllAdvertisingFeatures', false)
+                .option('allowAdvertisingPersonalization', false)
+                .option('disableGoogleAnalytics', false)
+                .option('googleReportingIdentity', 'device')
+                .option('userProperties', {})
+                .option('customEventsAndParameters', [])
+        );
+    });
+
+    describe('loading', function () {
+        beforeEach(function () {
+            analytics.spy(ga4, 'load');
+        });
+
+        it('should load', function (done) {
+            analytics.load(ga4, done);
+        });
+
+        describe('#initialize', function () {
+            it('should create window.ga4DataLayer', function () {
+                analytics.assert(!window.ga4DataLayer);
+                analytics.initialize();
+                analytics.assert(typeof window.ga4DataLayer === 'object');
+            });
+
+            it('should create window.gtag', function () {
+                analytics.assert(!window.gtag);
+                analytics.initialize();
+                analytics.assert(typeof window.gtag === 'function');
+            });
+
+            it('should not initialize when measurement IDs is empty', function () {
+                ga4.options.measurementIds = [];
+
+                analytics.initialize();
+                analytics.didNotCall(ga4.load)
+            });
+
+            it('should not initialize when Disable Google Analytics is set to true', function () {
+                ga4.options.disableGoogleAnalytics = true;
+
+                analytics.initialize();
+                analytics.didNotCall(ga4.load)
+            });
+
+            it('should load gtag.js with the first measurement ID', function () {
+                analytics.initialize();
+                analytics.called(ga4.load)
+                analytics.loaded('<script src="http://www.googletagmanager.com/gtag/js?id=G-100&l=ga4DataLayer"></script>')
+            });
+        });
+    });
+
+    describe('configuring', function () {
+        beforeEach(function () {
+            // Avoid loading gtag.js so it doesn't process commands sent to
+            // the data layer before we can assert their values.
+            analytics.stub(ga4, 'load', function (args, callback) {
+                callback();
+            });
+        });
+
+        it('should configure all measurement IDs', function () {
+            analytics.initialize();
+            analytics.equal(toArray(window.ga4DataLayer)[1][0], 'config')
+            analytics.equal(toArray(window.ga4DataLayer)[1][1], 'G-100')
+            analytics.equal(toArray(window.ga4DataLayer)[2][0], 'config')
+            analytics.equal(toArray(window.ga4DataLayer)[2][1], 'G-200')
+        });
+
+        it('should disable automatic page view measurement for all measurement IDs', function () {
+            ga4.options.sendAutomaticPageViewEvent = false;
+            analytics.initialize();
+
+            analytics.equal(window.ga4DataLayer[1][2]['send_page_view'], false)
+            analytics.equal(window.ga4DataLayer[2][2]['send_page_view'], false)
+        });
+
+        it('should set cookie related setting for all measurement IDs', function () {
+            ga4.options.cookieUpdate = false;
+            ga4.options.cookieDomainName = 'ajs.test'
+            ga4.options.cookiePrefix = 'test_prefix'
+            ga4.options.cookieExpiration = 21
+            ga4.options.cookieFlags = 'SameSite=None;Secure'
+            analytics.initialize();
+
+            analytics.equal(window.ga4DataLayer[1][2]['cookie_update'], false)
+            analytics.equal(window.ga4DataLayer[2][2]['cookie_update'], false)
+
+            analytics.equal(window.ga4DataLayer[1][2]['cookie_domain'], 'ajs.test')
+            analytics.equal(window.ga4DataLayer[2][2]['cookie_domain'], 'ajs.test')
+
+            analytics.equal(window.ga4DataLayer[1][2]['cookie_prefix'], 'test_prefix')
+            analytics.equal(window.ga4DataLayer[2][2]['cookie_prefix'], 'test_prefix')
+
+            analytics.equal(window.ga4DataLayer[1][2]['cookie_expires'], 21)
+            analytics.equal(window.ga4DataLayer[2][2]['cookie_expires'], 21)
+
+            // cookie_flags uses the `set` command
+            analytics.equal(window.ga4DataLayer[3][0]['cookie_flags'], 'SameSite=None;Secure')
+
+        });
+
+        it('should disable all advertising features', function () {
+            ga4.options.allowAllAdvertisingFeatures = false;
+            analytics.initialize();
+            analytics.deepEqual(toArray(window.ga4DataLayer[4]), ['allow_google_signals', false])
+        });
+
+        it('should disable all advertising features', function () {
+            ga4.options.allowAdvertisingPersonalization = false;
+            analytics.initialize();
+            analytics.deepEqual(toArray(window.ga4DataLayer[5]), ['allow_ad_personalization_signals', false])
+        });
+    });
+
+    describe('after loading', function () {
+        beforeEach(function (done) {
+            analytics.once('ready', done);
+            analytics.initialize();
+        });
+
+        describe('#identify', function () {
+            beforeEach(function () {
+                analytics.stub(window, 'gtag');
+            });
+
+            it('should map configured user properties', function () {
+                ga4.options.userProperties = {
+                    'traits.role': 'role',
+                    'traits.tz': 'timezone'
+                }
+                analytics.identify('user1', {
+                    role: 'tester',
+                    tz: 'TST'
+                });
+                analytics.called(window.gtag, 'set', 'user_properties', {
+                    role: 'tester',
+                    timezone: 'TST'
+                });
+            })
+
+            it('should map the user ID', function () {
+                ga4.options.googleReportingIdentity = 'userIdAndDevice'
+                analytics.identify('user1');
+                analytics.called(window.gtag, 'set', 'user_properties', {
+                    user_id: 'user1'
+                });
+            })
+        });
+
+        describe('#group', function () {
+            beforeEach(function () {
+                analytics.stub(window, 'gtag');
+            });
+
+            it('should send join_group event with group_id', function() {
+                analytics.group('group1');
+                analytics.called(window.gtag, 'event', 'join_group', {
+                    group_id: 'group1'
+                });
+            })
+        });
+
+        describe('#page', function () {
+            beforeEach(function () {
+                analytics.stub(window, 'gtag');
+            });
+
+            it('should send a page_view event with properties', function() {
+                analytics.page('Home', { url: 'url', path: '/path', referrer: 'http://ajs.test' });
+                analytics.called(window.gtag, 'event', 'page_view', {
+                  page_location: 'url',
+                  page_referrer: 'http://ajs.test',
+                  page_title: 'Home'
+                });
+              });
+
+            it('should not send events when disablePageViewMeasurement is disabled', function() {
+                ga4.options.sendAutomaticPageViewEvent = true
+                analytics.page('Home');
+                analytics.didNotCall(window.gtag, 'event', 'page_view')
+            });
+        });
+
+        describe('#track', function () {
+            beforeEach(function () {
+                analytics.stub(window, 'gtag');
+            });
+
+            it('should ignore invalid custom event and parameter configs', function() {
+                ga4.options.customEventsAndParameters = [
+                    {
+                        segmentEvent: '',
+                        googleEvent: 'gevent',
+                        parameters: []
+                    },
+                    {
+                        segmentEvent: 'event1',
+                        googleEvent: '',
+                        parameters: []
+                    }
+                ]
+
+                analytics.track('event1')
+                analytics.didNotCall(window.gtag, 'event')
+
+            });
+
+            it('should map custom events and parameters', function() {
+                ga4.options.customEventsAndParameters = [
+                    {
+                        segmentEvent: 'event1',
+                        googleEvent: 'gevent',
+                        parameters: [{
+                            key: 'properties.state',
+                            value: 'state'
+                        }]
+                    }
+                ]
+
+                analytics.track('event1', {
+                    state: 'playing'
+                })
+                analytics.called(window.gtag, 'event', 'gevent', {
+                    state: 'playing'
+                })
+            });
+
+            it('should ignore invalid parameters', function() {
+                ga4.options.customEventsAndParameters = [
+                    {
+                        segmentEvent: 'event1',
+                        googleEvent: 'gevent',
+                        parameters: [{
+                            key: '',
+                            value: 'state'
+                        }]
+                    },
+                    {
+                        segmentEvent: 'event1',
+                        googleEvent: 'gevent',
+                        parameters: [{
+                            key: 'properties.state',
+                            value: ''
+                        }]
+                    },
+                    {
+                        segmentEvent: 'event1',
+                        googleEvent: 'gevent',
+                        parameters: {
+                            'invalid': 'mapping'
+                        }
+                    }
+                ]
+
+                analytics.track('event1', {
+                    state: 'playing'
+                })
+                analytics.calledTwice(window.gtag, 'event', 'gevent')
+            });
+        });
+    })
+});