diff --git a/modules/agmaAnalyticsAdapter.js b/modules/agmaAnalyticsAdapter.js
new file mode 100644
index 00000000000..afbc3e771ec
--- /dev/null
+++ b/modules/agmaAnalyticsAdapter.js
@@ -0,0 +1,225 @@
+import { ajax } from '../src/ajax.js';
+import {
+  generateUUID,
+  logInfo,
+  logError,
+  getPerformanceNow,
+  isEmpty,
+  isEmptyStr,
+} from '../src/utils.js';
+import { getGlobal } from '../src/prebidGlobal.js';
+import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import CONSTANTS from '../src/constants.json';
+import adapterManager, { gdprDataHandler } from '../src/adapterManager.js';
+import { getRefererInfo } from '../src/refererDetection.js';
+import { config } from '../src/config.js';
+
+const GVLID = 1122;
+const ModuleCode = 'agma';
+const analyticsType = 'endpoint';
+const scriptVersion = '1.7.0';
+const batchDelayInMs = 1000;
+const agmaURL = 'https://pbc.agma-analytics.de/v1';
+const pageViewId = generateUUID();
+
+const {
+  EVENTS: { AUCTION_INIT },
+} = CONSTANTS;
+
+// Helper functions
+const getScreen = () => {
+  const w = window;
+  const d = document;
+  const e = d.documentElement;
+  const g = d.getElementsByTagName('body')[0];
+  const x = w.innerWidth || e.clientWidth || g.clientWidth;
+  const y = w.innerHeight || e.clientHeight || g.clientHeight;
+  return { x, y };
+};
+
+const getUserIDs = () => {
+  try {
+    return getGlobal().getUserIdsAsEids();
+  } catch (e) {}
+  return [];
+};
+
+export const getOrtb2Data = (options) => {
+  let site = null;
+  let user = null;
+
+  // check if data is provided via config
+  if (options.ortb2) {
+    if (options.ortb2.user) {
+      user = options.ortb2.user;
+    }
+    if (options.ortb2.site) {
+      site = options.ortb2.site;
+    }
+    if (site && user) {
+      return { site, user };
+    }
+  }
+  try {
+    const configData = config.getConfig('agma');
+    // try to fallback to global config
+    if (configData.ortb2) {
+      site = site || configData.ortb2.site;
+      user = user || configData.ortb2.user;
+    }
+  } catch (e) {}
+
+  return { site, user };
+};
+
+export const getTiming = () => {
+  // Timing API V2
+  let ttfb = 0;
+  try {
+    const entry = performance.getEntriesByType('navigation')[0];
+    ttfb = Math.round(entry.responseStart - entry.startTime);
+  } catch (e) {
+    // Timing API V1
+    try {
+      const entry = performance.timing;
+      ttfb = Math.round(entry.responseStart - entry.fetchStart);
+    } catch (e) {
+      // Timing API not available
+      return null;
+    }
+  }
+  const elapsedTime = getPerformanceNow();
+  ttfb = ttfb >= 0 && ttfb <= elapsedTime ? ttfb : 0;
+  return {
+    ttfb,
+    elapsedTime,
+  };
+};
+
+export const getPayload = (auctionIds, options) => {
+  if (!options || !auctionIds || auctionIds.length === 0) {
+    return false;
+  }
+  const consentData = gdprDataHandler.getConsentData();
+  let gdprApplies = true; // we assume gdpr applies
+  let useExtendedPayload = false;
+  if (consentData) {
+    gdprApplies = consentData.gdprApplies;
+    const consents = consentData.vendorData?.vendor?.consents || {};
+    useExtendedPayload = consents[GVLID];
+  }
+  const ortb2 = getOrtb2Data(options);
+  const ri = getRefererInfo() || {};
+
+  let payload = {
+    auctionIds: auctionIds,
+    triggerEvent: options.triggerEvent,
+    pageViewId,
+    domain: ri.domain,
+    gdprApplies,
+    code: options.code,
+    ortb2: { site: ortb2.site },
+    pageUrl: ri.page,
+    prebidVersion: '$prebid.version$',
+    scriptVersion,
+    debug: options.debug,
+    timing: getTiming(),
+  };
+
+  if (useExtendedPayload) {
+    const { x, y } = getScreen();
+    const userIdsAsEids = getUserIDs();
+    payload = {
+      ...payload,
+      ortb2,
+      extended: true,
+      timestamp: Date.now(),
+      gdprConsentString: consentData.consentString,
+      timezoneOffset: new Date().getTimezoneOffset(),
+      language: window.navigator.language,
+      referrer: ri.topmostLocation,
+      pageUrl: ri.page,
+      screenWidth: x,
+      screenHeight: y,
+      userIdsAsEids,
+    };
+  }
+  return payload;
+};
+
+const agmaAnalytics = Object.assign(adapter({ analyticsType }), {
+  auctionIds: [],
+  timer: null,
+  track(data) {
+    const { eventType, args } = data;
+    if (eventType === this.options.triggerEvent && args && args.auctionId) {
+      this.auctionIds.push(args.auctionId);
+      if (this.timer === null) {
+        this.timer = setTimeout(() => {
+          this.processBatch();
+        }, batchDelayInMs);
+      }
+    }
+  },
+  processBatch() {
+    const currentBatch = [...this.auctionIds];
+    const payload = getPayload(currentBatch, this.options);
+    this.auctionIds = [];
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.send(payload);
+  },
+  send(payload) {
+    if (!payload) {
+      return;
+    }
+    return ajax(
+      agmaURL,
+      () => {
+        logInfo(ModuleCode, 'flushed', payload);
+      },
+      JSON.stringify(payload),
+      {
+        contentType: 'text/plain',
+        method: 'POST',
+      }
+    );
+  },
+});
+
+agmaAnalytics.originEnableAnalytics = agmaAnalytics.enableAnalytics;
+agmaAnalytics.enableAnalytics = function (config = {}) {
+  const { options } = config;
+
+  if (isEmpty(options)) {
+    logError(ModuleCode, 'Please set options');
+    return false;
+  }
+
+  if (options.site && !options.code) {
+    logError(ModuleCode, 'Please set `code` - `site` is deprecated');
+    options.code = options.site;
+  }
+
+  if (!options.code || isEmptyStr(options.code)) {
+    logError(ModuleCode, 'Please set `code` option - agma Analytics is disabled');
+    return false;
+  }
+
+  agmaAnalytics.options = {
+    triggerEvent: AUCTION_INIT,
+    ...options,
+  };
+
+  agmaAnalytics.originEnableAnalytics(config);
+};
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: agmaAnalytics,
+  code: ModuleCode,
+  gvlid: GVLID,
+});
+
+export default agmaAnalytics;
diff --git a/modules/agmaAnalyticsAdapter.md b/modules/agmaAnalyticsAdapter.md
new file mode 100644
index 00000000000..30c88fb92ec
--- /dev/null
+++ b/modules/agmaAnalyticsAdapter.md
@@ -0,0 +1,28 @@
+# Overview
+    Module Name: Agma Analytics
+    Module Type: Analytics Adapter
+    Maintainer: [www.agma-mmc.de](https://www.agma-mmc.de)
+    Technical Support: [info@mllrsohn.com](mailto:info@mllrsohn.com)
+
+# Description
+
+Agma Analytics adapter. Please contact [team-internet@agma-mmc.de](mailto:team-internet@agma-mmc.de) for signup and access to [futher documentation](https://docs.agma-analytics.de).
+
+# Usage
+
+Add the `agmaAnalyticsAdapter` to your build:
+
+```
+gulp build --modules=...,agmaAnalyticsAdapter...
+```
+
+Configure the analytics module:
+
+```javascript
+pbjs.enableAnalytics({
+    provider: 'agma',
+    options: {
+        code: 'provided-by-agma'    // change to the code you received from agma
+    }
+});
+```
diff --git a/test/spec/modules/agmaAnalyticsAdapter_spec.js b/test/spec/modules/agmaAnalyticsAdapter_spec.js
new file mode 100644
index 00000000000..ba71624e3b3
--- /dev/null
+++ b/test/spec/modules/agmaAnalyticsAdapter_spec.js
@@ -0,0 +1,388 @@
+import adapterManager from '../../../src/adapterManager.js';
+import agmaAnalyticsAdapter, {
+  getTiming,
+  getOrtb2Data,
+  getPayload,
+} from '../../../modules/agmaAnalyticsAdapter.js';
+import { gdprDataHandler } from '../../../src/adapterManager.js';
+import { expect } from 'chai';
+import * as events from '../../../src/events.js';
+import constants from '../../../src/constants.json';
+import { generateUUID } from '../../../src/utils.js';
+import { server } from '../../mocks/xhr.js';
+import { config } from 'src/config.js';
+
+const INGEST_URL = 'https://pbc.agma-analytics.de/v1';
+const extendedKey = [
+  'auctionIds',
+  'code',
+  'domain',
+  'extended',
+  'gdprApplies',
+  'gdprConsentString',
+  'language',
+  'ortb2',
+  'pageUrl',
+  'pageViewId',
+  'prebidVersion',
+  'referrer',
+  'screenHeight',
+  'screenWidth',
+  'scriptVersion',
+  'timestamp',
+  'timezoneOffset',
+  'timing',
+  'triggerEvent',
+  'userIdsAsEids',
+];
+const nonExtendedKey = [
+  'auctionIds',
+  'code',
+  'domain',
+  'gdprApplies',
+  'ortb2',
+  'pageUrl',
+  'pageViewId',
+  'prebidVersion',
+  'scriptVersion',
+  'timing',
+  'triggerEvent',
+];
+
+describe('AGMA Analytics Adapter', () => {
+  let agmaConfig, sandbox, clock;
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+    clock = sandbox.useFakeTimers();
+    sandbox.stub(events, 'getEvents').returns([]);
+    agmaConfig = {
+      options: {
+        code: 'test',
+      },
+    };
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('configuration', () => {
+    it('registers itself with the adapter manager', () => {
+      const adapter = adapterManager.getAnalyticsAdapter('agma');
+      expect(adapter).to.exist;
+      expect(adapter.gvlid).to.equal(1122);
+    });
+  });
+
+  describe('getPayload', () => {
+    it('should use non extended payload with no consent info', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => null)
+      const payload = getPayload([generateUUID()], {
+        code: 'test',
+      });
+
+      expect(payload).to.have.all.keys([...nonExtendedKey, 'debug']);
+    });
+
+    it('should use non extended payload when agma is not in  the TC String', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => ({
+        vendorData: {
+          vendor: {
+            consents: {
+              1122: false,
+            },
+          },
+        },
+      }));
+      const payload = getPayload([generateUUID()], {
+        code: 'test',
+      });
+      expect(payload).to.have.all.keys([...nonExtendedKey, 'debug']);
+    });
+
+    it('should use extended payload when agma is in the TC String', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => ({
+        vendorData: {
+          vendor: {
+            consents: {
+              1122: true,
+            },
+          },
+        },
+      }));
+      const payload = getPayload([generateUUID()], {
+        code: 'test',
+      });
+      expect(payload).to.have.all.keys([...extendedKey, 'debug']);
+    });
+  });
+
+  describe('getTiming', () => {
+    let originalPerformance;
+    let originalWindowPerformanceNow;
+
+    beforeEach(() => {
+      originalPerformance = global.performance;
+      originalWindowPerformanceNow = window.performance.now;
+    });
+
+    afterEach(() => {
+      global.performance = originalPerformance;
+      window.performance.now = originalWindowPerformanceNow;
+    });
+
+    it('returns TTFB using Timing API V2', () => {
+      global.performance = {
+        getEntriesByType: sinon
+          .stub()
+          .returns([{ responseStart: 100, startTime: 50 }]),
+        now: sinon.stub().returns(150),
+      };
+
+      const result = getTiming();
+
+      expect(result).to.deep.equal({ ttfb: 50, elapsedTime: 150 });
+    });
+
+    it('returns TTFB using Timing API V1 when V2 is not available', () => {
+      global.performance = {
+        getEntriesByType: sinon.stub().throws(),
+        timing: { responseStart: 150, fetchStart: 50 },
+        now: sinon.stub().returns(200),
+      };
+
+      const result = getTiming();
+
+      expect(result).to.deep.equal({ ttfb: 100, elapsedTime: 200 });
+    });
+
+    it('returns null when Timing API is not available', () => {
+      global.performance = {
+        getEntriesByType: sinon.stub().throws(),
+        timing: undefined,
+      };
+
+      const result = getTiming();
+
+      expect(result).to.be.null;
+    });
+
+    it('returns ttfb as 0 if calculated value is negative', () => {
+      global.performance = {
+        getEntriesByType: sinon
+          .stub()
+          .returns([{ responseStart: 50, startTime: 150 }]),
+        now: sinon.stub().returns(200),
+      };
+
+      const result = getTiming();
+
+      expect(result).to.deep.equal({ ttfb: 0, elapsedTime: 200 });
+    });
+
+    it('returns ttfb as 0 if calculated value exceeds performance.now()', () => {
+      global.performance = {
+        getEntriesByType: sinon
+          .stub()
+          .returns([{ responseStart: 50, startTime: 0 }]),
+        now: sinon.stub().returns(40),
+      };
+
+      const result = getTiming();
+
+      expect(result).to.deep.equal({ ttfb: 0, elapsedTime: 40 });
+    });
+  });
+
+  describe('getOrtb2Data', () => {
+    it('returns site and user from options when available', () => {
+      sandbox.stub(config, 'getConfig').callsFake((key) => {
+        return {};
+      });
+
+      const ortb2 = {
+        user: 'user',
+        site: 'site',
+      };
+
+      const result = getOrtb2Data({
+        ortb2,
+      });
+
+      expect(result).to.deep.equal(ortb2);
+    });
+
+    it('returns a combination of data from options and pGlobal.readConfig', () => {
+      sandbox.stub(config, 'getConfig').callsFake((key) => {
+        return {
+          ortb2: {
+            site: {
+              foo: 'bar',
+            },
+          },
+        };
+      });
+
+      const ortb2 = {
+        user: 'user',
+      };
+      const result = getOrtb2Data({
+        ortb2,
+      });
+
+      expect(result).to.deep.equal({
+        site: {
+          foo: 'bar',
+        },
+        user: 'user',
+      });
+    });
+  });
+
+  describe('Event Payload', () => {
+    beforeEach(() => {
+      agmaAnalyticsAdapter.enableAnalytics({
+        ...agmaConfig,
+      });
+      server.respondWith('POST', INGEST_URL, [
+        200,
+        {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+        },
+        '',
+      ]);
+    });
+
+    afterEach(() => {
+      agmaAnalyticsAdapter.auctionIds = [];
+      if (agmaAnalyticsAdapter.timer) {
+        clearTimeout(agmaAnalyticsAdapter.timer);
+      }
+      agmaAnalyticsAdapter.disableAnalytics();
+    });
+
+    it('should only send once per minute', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => ({
+        gdprApplies: true,
+        consentString: 'consentDataString',
+        vendorData: {
+          vendor: {
+            consents: {
+              1122: true,
+            },
+          },
+        },
+      }));
+      const auction = {
+        auctionId: generateUUID(),
+      };
+
+      events.emit(constants.EVENTS.AUCTION_INIT, {
+        auctionId: generateUUID('1'),
+        auction,
+      });
+
+      clock.tick(200);
+
+      events.emit(constants.EVENTS.AUCTION_INIT, {
+        auctionId: generateUUID('2'),
+        auction,
+      });
+      events.emit(constants.EVENTS.AUCTION_INIT, {
+        auctionId: generateUUID('3'),
+        auction,
+      });
+      events.emit(constants.EVENTS.AUCTION_INIT, {
+        auctionId: generateUUID('4'),
+        auction,
+      });
+
+      clock.tick(900);
+
+      const [request] = server.requests;
+      const requestBody = JSON.parse(request.requestBody);
+      expect(request.url).to.equal(INGEST_URL);
+      expect(requestBody).to.have.all.keys(extendedKey);
+      expect(requestBody.triggerEvent).to.equal(constants.EVENTS.AUCTION_INIT);
+      expect(server.requests).to.have.length(1);
+    });
+
+    it('should send the extended payload with consent', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => ({
+        gdprApplies: true,
+        consentString: 'consentDataString',
+        vendorData: {
+          vendor: {
+            consents: {
+              1122: true,
+            },
+          },
+        },
+      }));
+      const auction = {
+        auctionId: generateUUID(),
+      };
+
+      events.emit(constants.EVENTS.AUCTION_INIT, auction);
+      clock.tick(1100);
+
+      const [request] = server.requests;
+      const requestBody = JSON.parse(request.requestBody);
+      expect(request.url).to.equal(INGEST_URL);
+      expect(requestBody).to.have.all.keys(extendedKey);
+      expect(requestBody.triggerEvent).to.equal(constants.EVENTS.AUCTION_INIT);
+      expect(server.requests).to.have.length(1);
+      expect(agmaAnalyticsAdapter.auctionIds).to.have.length(0);
+    });
+
+    it('should send the non extended payload with no explicit consent', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => ({
+        gdprApplies: true,
+        consentString: 'consentDataString',
+      }));
+
+      const auction = {
+        auctionId: generateUUID(),
+      };
+
+      events.emit(constants.EVENTS.AUCTION_INIT, auction);
+      clock.tick(1000);
+
+      const [request] = server.requests;
+      const requestBody = JSON.parse(request.requestBody);
+      expect(request.url).to.equal(INGEST_URL);
+      expect(requestBody.triggerEvent).to.equal(constants.EVENTS.AUCTION_INIT);
+      expect(server.requests).to.have.length(1);
+      expect(agmaAnalyticsAdapter.auctionIds).to.have.length(0);
+    });
+
+    it('should set the trigger Event', () => {
+      sandbox.stub(gdprDataHandler, 'getConsentData').callsFake(() => null);
+      agmaAnalyticsAdapter.disableAnalytics();
+      agmaAnalyticsAdapter.enableAnalytics({
+        provider: 'agma',
+        options: {
+          code: 'test',
+          triggerEvent: constants.EVENTS.AUCTION_END
+        },
+      });
+      const auction = {
+        auctionId: generateUUID(),
+      };
+
+      events.emit(constants.EVENTS.AUCTION_INIT, auction);
+      events.emit(constants.EVENTS.AUCTION_END, auction);
+      clock.tick(1000);
+
+      const [request] = server.requests;
+      const requestBody = JSON.parse(request.requestBody);
+      expect(request.url).to.equal(INGEST_URL);
+      expect(requestBody.auctionIds).to.have.length(1);
+      expect(requestBody.triggerEvent).to.equal(constants.EVENTS.AUCTION_END);
+      expect(server.requests).to.have.length(1);
+      expect(agmaAnalyticsAdapter.auctionIds).to.have.length(0);
+    });
+  });
+});