diff --git a/modules/contxtfulBidAdapter.js b/modules/contxtfulBidAdapter.js
new file mode 100644
index 00000000000..7f1a8702a3b
--- /dev/null
+++ b/modules/contxtfulBidAdapter.js
@@ -0,0 +1,217 @@
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, NATIVE, VIDEO } from '../src/mediaTypes.js';
+import { _each, buildUrl, isStr, isEmptyStr, logInfo, logError } from '../src/utils.js';
+import { sendBeacon, ajax } from '../src/ajax.js';
+import { config as pbjsConfig } from '../src/config.js';
+import {
+  isBidRequestValid,
+  interpretResponse,
+  getUserSyncs as getUserSyncsLib,
+} from '../libraries/teqblazeUtils/bidderUtils.js';
+import {ortbConverter} from '../libraries/ortbConverter/converter.js';
+
+// Constants
+const BIDDER_CODE = 'contxtful';
+const BIDDER_ENDPOINT = 'prebid.receptivity.io';
+const MONITORING_ENDPOINT = 'monitoring.receptivity.io';
+const DEFAULT_NET_REVENUE = true;
+const DEFAULT_TTL = 300;
+const PREBID_VERSION = '$prebid.version$';
+
+// ORTB conversion
+const converter = ortbConverter({
+  context: {
+    netRevenue: DEFAULT_NET_REVENUE,
+    ttl: DEFAULT_TTL
+  },
+  imp(buildImp, bidRequest, context) {
+    let imp = buildImp(bidRequest, context);
+    return imp;
+  },
+  request(buildRequest, imps, bidderRequest, context) {
+    const reqData = buildRequest(imps, bidderRequest, context);
+    return reqData;
+  },
+  bidResponse(buildBidResponse, bid, context) {
+    const bidResponse = buildBidResponse(bid, context);
+    return bidResponse;
+  }
+});
+
+// Get Bid Floor
+const _getRequestBidFloor = (mediaTypes, paramsBidFloor, bid) => {
+  const bidMediaType = Object.keys(mediaTypes)[0] || 'banner';
+  const bidFloor = { floor: 0, currency: 'USD' };
+
+  if (typeof bid.getFloor === 'function') {
+    const { currency, floor } = bid.getFloor({
+      mediaType: bidMediaType,
+      size: '*'
+    });
+    floor && (bidFloor.floor = floor);
+    currency && (bidFloor.currency = currency);
+  } else if (paramsBidFloor) {
+    bidFloor.floor = paramsBidFloor
+  }
+
+  return bidFloor;
+}
+
+// Get Parameters from the config.
+const extractParameters = (config) => {
+  const version = config?.contxtful?.version;
+  if (!isStr(version) || isEmptyStr(version)) {
+    throw Error(`contxfulBidAdapter: contxtful.version should be a non-empty string`);
+  }
+
+  const customer = config?.contxtful?.customer;
+  if (!isStr(customer) || isEmptyStr(customer)) {
+    throw Error(`contxfulBidAdapter: contxtful.customer should be a non-empty string`);
+  }
+
+  return { version, customer };
+}
+
+// Construct the Payload towards the Bidding endpoint
+const buildRequests = (validBidRequests = [], bidderRequest = {}) => {
+  const ortb2 = converter.toORTB({bidderRequest: bidderRequest, bidRequests: validBidRequests});
+
+  const bidRequests = [];
+  _each(validBidRequests, bidRequest => {
+    const {
+      mediaTypes = {},
+      params = {},
+    } = bidRequest;
+    bidRequest.bidFloor = _getRequestBidFloor(mediaTypes, params.bidfloor, bidRequest);
+    bidRequests.push(bidRequest)
+  });
+  const config = pbjsConfig.getConfig();
+  config.pbjsVersion = PREBID_VERSION;
+  const {version, customer} = extractParameters(config)
+  const adapterUrl = buildUrl({
+    protocol: 'https',
+    host: BIDDER_ENDPOINT,
+    pathname: `/${version}/prebid/${customer}/bid`,
+  });
+
+  // https://docs.prebid.org/dev-docs/bidder-adaptor.html
+  let req = {
+    url: adapterUrl,
+    method: 'POST',
+    data: {
+      ortb2,
+      bidRequests,
+      bidderRequest,
+      config,
+    },
+  };
+
+  return req;
+};
+
+// Prepare a sync object compatible with getUserSyncs.
+const constructUrl = (userSyncsDefault, userSyncServer) => {
+  const urlSyncServer = (userSyncServer?.url ?? '').split('?');
+  const userSyncUrl = userSyncsDefault?.url || '';
+  const baseSyncUrl = urlSyncServer[0] || '';
+
+  let url = `${baseSyncUrl}${userSyncUrl}`;
+
+  if (urlSyncServer.length > 1) {
+    const urlParams = urlSyncServer[1];
+    url += url.includes('?') ? `&${urlParams}` : `?${urlParams}`;
+  }
+
+  return {
+    ...userSyncsDefault,
+    url,
+  };
+};
+
+// Returns the list of user synchronization objects.
+const getUserSyncs = (syncOptions, serverResponses, gdprConsent, uspConsent, gppConsent) => {
+  // Get User Sync Defaults from pbjs lib
+  const userSyncsDefaultLib = getUserSyncsLib('')(syncOptions, null, gdprConsent, uspConsent, gppConsent);
+  const userSyncsDefault = userSyncsDefaultLib?.find(item => item.url !== undefined);
+
+  // Map Server Responses to User Syncs list
+  const serverSyncsData = serverResponses?.flatMap(response => response.body || [])
+    .map(data => data.syncs)
+    .find(syncs => Array.isArray(syncs) && syncs.length > 0) || [];
+  const userSyncs = serverSyncsData
+    .map(sync => constructUrl(userSyncsDefault, sync))
+    .filter(Boolean); // Filter out nulls
+  return userSyncs;
+};
+
+// Retrieve the sampling rate for events
+const getSamplingRate = (bidderConfig, eventType) => {
+  const entry = Object.entries(bidderConfig?.contxtful?.sampling ?? {}).find(([key, value]) => key.toLowerCase() === eventType.toLowerCase());
+  return entry ? entry[1] : 0.001;
+};
+
+// Handles the logging of events
+const logEvent = (eventType, data, options = {}) => {
+  const {
+    samplingEnabled = false,
+  } = options;
+
+  try {
+    // Log event
+    logInfo(BIDDER_CODE, `[${eventType}] ${JSON.stringify(data)}`);
+
+    // Get Config
+    const bidderConfig = pbjsConfig.getConfig();
+    const {version, customer} = extractParameters(bidderConfig);
+
+    // Sampled monitoring
+    if (samplingEnabled) {
+      const shouldSampleDice = Math.random();
+      const samplingRate = getSamplingRate(bidderConfig, eventType);
+      if (shouldSampleDice >= samplingRate) {
+        return; // Don't sample
+      }
+    }
+
+    const payload = { type: eventType, data };
+    const eventUrl = buildUrl({
+      protocol: 'https',
+      host: MONITORING_ENDPOINT,
+      pathname: `/${version}/prebid/${customer}/log/${eventType}`,
+    });
+
+    // Try sending a beacon
+    if (sendBeacon(eventUrl, JSON.stringify(payload))) {
+      logInfo(BIDDER_CODE, `[${eventType}] Logging data sent using Beacon and payload: ${JSON.stringify(data)}`);
+    } else {
+      // Fallback to using ajax
+      ajax(eventUrl, null, JSON.stringify(payload), {
+        method: 'POST',
+        contentType: 'application/json',
+        withCredentials: true,
+      });
+      logInfo(BIDDER_CODE, `[${eventType}] Logging data sent using Ajax and payload: ${JSON.stringify(data)}`);
+    }
+  } catch (error) {
+    logError(BIDDER_CODE, `Failed to log event: ${eventType}`);
+  }
+};
+
+// Bidder public specification
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER, VIDEO, NATIVE],
+
+  isBidRequestValid,
+  buildRequests,
+  interpretResponse,
+  getUserSyncs,
+  onBidWon: function(bid, options) { logEvent('onBidWon', bid, { samplingEnabled: false, ...options }); },
+  onBidBillable: function(bid, options) { logEvent('onBidBillable', bid, { samplingEnabled: false, ...options }); },
+  onAdRenderSucceeded: function(bid, options) { logEvent('onAdRenderSucceeded', bid, { samplingEnabled: false, ...options }); },
+  onSetTargeting: function(bid, options) { },
+  onTimeout: function(timeoutData, options) { logEvent('onTimeout', timeoutData, { samplingEnabled: true, ...options }); },
+  onBidderError: function(args, options) { logEvent('onBidderError', args, { samplingEnabled: true, ...options }); },
+};
+
+registerBidder(spec);
diff --git a/modules/contxtfulBidAdapter.md b/modules/contxtfulBidAdapter.md
new file mode 100644
index 00000000000..87a78c38a85
--- /dev/null
+++ b/modules/contxtfulBidAdapter.md
@@ -0,0 +1,98 @@
+# Overview
+
+```
+Module Name: Contxtful Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: contact@contxtful.com
+```
+
+# Description
+
+The Contxtful Bidder Adapter supports all mediatypes and connects to demand sources for bids.
+ 
+# Configuration
+## Global Configuration
+Contxtful uses the global configuration to store params once instead of duplicating for each ad unit.
+Also, enabling user syncing greatly increases match rates and monetization. 
+Be sure to call `pbjs.setConfig()` only once.
+
+```javascript
+pbjs.setConfig({
+   debug: false,
+   contxtful: {
+      customer: '<contxtful_provided_id>', // Required
+      version: '<contxtful_provided_version>', // Required
+   },
+   userSync: {
+      filterSettings: {
+        iframe: {
+          bidders: ['contxtful'],
+          filter: 'include'
+        }
+      }
+   }
+   // [...]
+});
+```
+
+## Bidder Setting
+Contxtful leverages local storage for user syncing.
+
+```javascript
+pbjs.bidderSettings = {
+   contxtful: {
+      storageAllowed: true
+   }
+}
+```
+
+# Example Ad-units configuration
+```javascript
+var adUnits = [
+   {
+      code: 'adunit1',
+      mediaTypes: {
+         banner: {
+            sizes: [ [300, 250], [320, 50] ],
+         }
+      },
+      bids: [{
+         bidder: 'contxtful',
+      }]
+   },
+   {
+      code: 'addunit2',
+         mediaTypes: {
+            video: {
+               playerSize: [ [640, 480] ],
+               context: 'instream',
+               minduration: 5,
+               maxduration: 60,
+            }
+         },
+         bids: [{
+            bidder: 'contxtful',
+         }]
+   },
+   {
+      code: 'addunit3',
+      mediaTypes: {
+         native: {
+            title: {
+               required: true
+            },
+            body: {
+               required: true
+            },
+            icon: {
+               required: true,
+               size: [64, 64]
+            }
+         }
+      },
+      bids: [{
+         bidder: 'contxtful',
+      }]
+   }
+];
+```
diff --git a/test/spec/modules/contxtfulBidAdapter_spec.js b/test/spec/modules/contxtfulBidAdapter_spec.js
new file mode 100644
index 00000000000..02cb3ccef8a
--- /dev/null
+++ b/test/spec/modules/contxtfulBidAdapter_spec.js
@@ -0,0 +1,496 @@
+import { spec } from 'modules/contxtfulBidAdapter.js';
+import { newBidder } from 'src/adapters/bidderFactory.js';
+import { config } from 'src/config.js';
+import * as ajax from 'src/ajax.js';
+const VERSION = 'v1';
+const CUSTOMER = 'CUSTOMER';
+const BIDDER_ENDPOINT = 'prebid.receptivity.io';
+const RX_FROM_API = { ReceptivityState: 'Receptive', test_info: 'rx_from_engine' };
+
+describe('contxtful bid adapter', function () {
+  const adapter = newBidder(spec);
+  let sandbox;
+
+  beforeEach(function () {
+    sandbox = sinon.sandbox.create();
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  describe('is a functions', function () {
+    it('exists and is a function', function () {
+      expect(adapter.callBids).to.exist.and.to.be.a('function');
+    });
+  });
+
+  describe('valid code', function () {
+    it('should return the bidder code of contxtful', function () {
+      expect(spec.code).to.eql('contxtful');
+    });
+  });
+
+  let bidRequests =
+  [
+    {
+      bidder: 'contxtful',
+      bidId: 'bId1',
+      custom_param_1: 'value_1',
+      transactionId: 'tId1',
+      params: {
+        bcat: ['cat1', 'cat2'],
+        badv: ['adv1', 'adv2'],
+      },
+      mediaTypes: {
+        banner: {
+          sizes: [
+            [300, 250],
+            [300, 600]
+          ]
+        },
+      },
+      ortb2Imp: {
+        ext: {
+          tid: 't-id-test-1',
+          gpid: 'gpid-id-unitest-1'
+        },
+      },
+      schain: {
+        ver: '1.0',
+        complete: 1,
+        nodes: [
+          {
+            asi: 'schain-seller-1.com',
+            sid: '00001',
+            hp: 1,
+          },
+        ],
+      },
+      getFloor: () => ({ currency: 'CAD', floor: 10 }),
+    }
+  ];
+
+  let expectedReceptivityData = {
+    rx: RX_FROM_API,
+    params: {
+      ev: VERSION,
+      ci: CUSTOMER,
+    },
+  };
+
+  let bidderRequest = {
+    refererInfo: {
+      ref: 'https://my-referer-custom.com',
+    },
+    ortb2: {
+      source: {
+        tid: 'auction-id',
+      },
+      property_1: 'string_val_1',
+      regs: {
+        coppa: 1,
+        ext: {
+          us_privacy: '12345'
+        }
+      },
+      user: {
+        data: [
+          {
+            name: 'contxtful',
+            ext: expectedReceptivityData
+          }
+        ],
+        ext: {
+          eids: [
+            {
+              source: 'id5-sync.com',
+              uids: [
+                {
+                  atype: 1,
+                  id: 'fake-id5id',
+                },
+              ]
+            }
+          ]
+        }
+      }
+
+    },
+    timeout: 1234,
+    uspConsent: '12345'
+  };
+
+  describe('valid configuration', function() {
+    const theories = [
+      [
+        null,
+        'contxfulBidAdapter: contxtful.version should be a non-empty string',
+        'null object for config',
+      ],
+      [
+        {},
+        'contxfulBidAdapter: contxtful.version should be a non-empty string',
+        'empty object for config',
+      ],
+      [
+        { customer: CUSTOMER },
+        'contxfulBidAdapter: contxtful.version should be a non-empty string',
+        'customer only in config',
+      ],
+      [
+        { version: VERSION },
+        'contxfulBidAdapter: contxtful.customer should be a non-empty string',
+        'version only in config',
+      ],
+      [
+        { customer: CUSTOMER, version: '' },
+        'contxfulBidAdapter: contxtful.version should be a non-empty string',
+        'empty string for version',
+      ],
+      [
+        { customer: '', version: VERSION },
+        'contxfulBidAdapter: contxtful.customer should be a non-empty string',
+        'empty string for customer',
+      ],
+      [
+        { customer: '', version: '' },
+        'contxfulBidAdapter: contxtful.version should be a non-empty string',
+        'empty string for version & customer',
+      ],
+    ];
+
+    theories.forEach(([params, expectedErrorMessage, description]) => {
+      it('detects invalid configuration and throws the expected error (' + description + ')', () => {
+        config.setConfig({
+          contxtful: params
+        });
+        expect(() => spec.buildRequests(bidRequests, {
+          auctionId: 'new-auction-id'
+        })).to.throw(
+          expectedErrorMessage
+        );
+      });
+    });
+
+    it('uses a valid configuration and returns the right url', () => {
+      config.setConfig({
+        contxtful: {customer: CUSTOMER, version: VERSION}
+      });
+      const bidRequest = spec.buildRequests(bidRequests);
+      expect(bidRequest.url).to.eq('https://' + BIDDER_ENDPOINT + `/${VERSION}/prebid/${CUSTOMER}/bid`)
+    });
+
+    it('will take specific ortb2 configuration parameters and returns it in ortb2 object', () => {
+      config.setConfig({
+        contxtful: {customer: CUSTOMER, version: VERSION},
+      });
+      const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
+      expect(bidRequest.data.ortb2.property_1).to.equal('string_val_1');
+    });
+  });
+
+  describe('valid bid request', function () {
+    config.setConfig({
+      contxtful: {customer: CUSTOMER, version: VERSION},
+    });
+    const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
+
+    it('will return a data property containing properties ortb2, bidRequests, bidderRequest and config', () => {
+      expect(bidRequest.data).not.to.be.undefined;
+      expect(bidRequest.data.ortb2).not.to.be.undefined;
+      expect(bidRequest.data.bidRequests).not.to.be.undefined;
+      expect(bidRequest.data.bidderRequest).not.to.be.undefined;
+      expect(bidRequest.data.config).not.to.be.undefined;
+    });
+
+    it('will take custom parameters in the bid request and within the bidRequests array', () => {
+      expect(bidRequest.data.bidRequests[0].custom_param_1).to.equal('value_1')
+    });
+
+    it('will return any supply chain parameters within the bidRequests array', () => {
+      expect(bidRequest.data.bidRequests[0].schain.ver).to.equal('1.0');
+    });
+
+    it('will return floor request within the bidFloor parameter in the bidRequests array', () => {
+      expect(bidRequest.data.bidRequests[0].bidFloor.currency).to.equal('CAD');
+      expect(bidRequest.data.bidRequests[0].bidFloor.floor).to.equal(10);
+    });
+
+    it('will return the usp string in the uspConsent parameter within the bidderRequest property', () => {
+      expect(bidRequest.data.bidderRequest.uspConsent).to.equal('12345');
+    });
+
+    it('will contains impressions array on ortb2.imp object for all ad units', () => {
+      expect(bidRequest.data.ortb2.imp.length).to.equal(1);
+      expect(bidRequest.data.ortb2.imp[0].id).to.equal('bId1');
+    });
+
+    it('will contains the registration on ortb2.regs object', () => {
+      expect(bidRequest.data.ortb2.regs).not.to.be.undefined;
+      expect(bidRequest.data.ortb2.regs.coppa).to.equal(1);
+      expect(bidRequest.data.ortb2.regs.ext.us_privacy).to.equal('12345')
+    })
+
+    it('will contains the eids modules within the ortb2.user.ext.eids', () => {
+      expect(bidRequest.data.ortb2.user.ext.eids).not.to.be.undefined;
+      expect(bidRequest.data.ortb2.user.ext.eids[0].source).to.equal('id5-sync.com');
+      expect(bidRequest.data.ortb2.user.ext.eids[0].uids[0].id).to.equal('fake-id5id');
+    });
+
+    it('will contains the receptivity value within the ortb2.user.data with contxtful name', () => {
+      let obtained_receptivity_data = bidRequest.data.ortb2.user.data.filter(function(userData) {
+        return userData.name == 'contxtful';
+      });
+      expect(obtained_receptivity_data.length).to.equal(1);
+      expect(obtained_receptivity_data[0].ext).to.deep.equal(expectedReceptivityData);
+    });
+
+    it('will contains ortb2Imp of the bid request within the ortb2.imp.ext', () => {
+      let first_imp = bidRequest.data.ortb2.imp[0];
+      expect(first_imp.ext).not.to.be.undefined;
+      expect(first_imp.ext.tid).to.equal('t-id-test-1');
+      expect(first_imp.ext.gpid).to.equal('gpid-id-unitest-1');
+    });
+  });
+
+  describe('valid bid request with no floor module', () => {
+    let noFloorsBidRequests =
+    [
+      {
+        bidder: 'contxtful',
+        bidId: 'bId1',
+        transactionId: 'tId1',
+        mediaTypes: {
+          banner: {
+            sizes: [
+              [300, 250],
+              [300, 600]
+            ]
+          },
+        },
+      },
+      {
+        bidder: 'contxtful',
+        bidId: 'bId2',
+        transactionId: 'tId2',
+        mediaTypes: {
+          banner: {
+            sizes: [
+              [300, 250],
+              [300, 600]
+            ]
+          },
+        },
+        params: {
+          bidfloor: 54
+        }
+      },
+    ];
+
+    config.setConfig({
+      contxtful: {customer: CUSTOMER, version: VERSION},
+    });
+
+    const bidRequest = spec.buildRequests(noFloorsBidRequests, bidderRequest);
+    it('will contains default value of floor if the bid request do not contains floor function', () => {
+      expect(bidRequest.data.bidRequests[0].bidFloor.currency).to.equal('USD');
+      expect(bidRequest.data.bidRequests[0].bidFloor.floor).to.equal(0);
+    });
+
+    it('will take the param.bidfloor as floor value if possible', () => {
+      expect(bidRequest.data.bidRequests[1].bidFloor.currency).to.equal('USD');
+      expect(bidRequest.data.bidRequests[1].bidFloor.floor).to.equal(54);
+    });
+  });
+
+  describe('valid bid response', () => {
+    const bidResponse = [
+      {
+        'requestId': 'arequestId',
+        'originalCpm': 1.5,
+        'cpm': 1.35,
+        'currency': 'CAD',
+        'width': 300,
+        'height': 600,
+        'creativeId': 'creativeid',
+        'netRevenue': true,
+        'ttl': 300,
+        'ad': '<script src="www.anadscript.com"></script>',
+        'mediaType': 'banner',
+        'syncs': [
+          {
+            'url': 'mysyncurl.com?qparam1=qparamv1&qparam2=qparamv2'
+          }
+        ]
+      }
+    ];
+    config.setConfig({
+      contxtful: {customer: CUSTOMER, version: VERSION},
+    });
+
+    const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
+
+    it('will interpret response correcly', () => {
+      const bids = spec.interpretResponse({ body: bidResponse }, bidRequest);
+      expect(bids).not.to.be.undefined;
+      expect(bids).to.have.lengthOf(1);
+      expect(bids).to.deep.equal(bidResponse);
+    });
+
+    it('will return empty response if bid response is empty', () => {
+      const bids = spec.interpretResponse({ body: [] }, bidRequest);
+      expect(bids).to.have.lengthOf(0);
+    })
+
+    it('will trigger user sync if enable pixel mode', () => {
+      const syncOptions = {
+        pixelEnabled: true
+      };
+
+      const userSyncs = spec.getUserSyncs(syncOptions, [{ body: bidResponse }]);
+      expect(userSyncs).to.deep.equal([
+        {
+          'url': 'mysyncurl.com/image?pbjs=1&coppa=0&qparam1=qparamv1&qparam2=qparamv2',
+          'type': 'image'
+        }
+      ]);
+    });
+
+    it('will trigger user sync if enable iframe mode', () => {
+      const syncOptions = {
+        iframeEnabled: true
+      };
+
+      const userSyncs = spec.getUserSyncs(syncOptions, [{ body: bidResponse }]);
+      expect(userSyncs).to.deep.equal([
+        {
+          'url': 'mysyncurl.com/iframe?pbjs=1&coppa=0&qparam1=qparamv1&qparam2=qparamv2',
+          'type': 'iframe'
+        }
+      ]);
+    });
+
+    describe('no sync option', () => {
+      it('will return image sync if no sync options', () => {
+        const userSyncs = spec.getUserSyncs({}, [{ body: bidResponse }]);
+        expect(userSyncs).to.deep.equal([
+          {
+            'url': 'mysyncurl.com/image?pbjs=1&coppa=0&qparam1=qparamv1&qparam2=qparamv2',
+            'type': 'image'
+          }
+        ]);
+      });
+      it('will return empty value if no server response', () => {
+        const userSyncs = spec.getUserSyncs({}, []);
+        expect(userSyncs).to.have.lengthOf(0);
+        const userSyncs2 = spec.getUserSyncs({}, null);
+        expect(userSyncs2).to.have.lengthOf(0);
+      });
+    });
+
+    it('will return empty value if no server response', () => {
+      const syncOptions = {
+        iframeEnabled: true
+      };
+
+      const userSyncs = spec.getUserSyncs(syncOptions, []);
+      expect(userSyncs).to.have.lengthOf(0);
+      const userSyncs2 = spec.getUserSyncs(syncOptions, null);
+      expect(userSyncs2).to.have.lengthOf(0);
+    });
+
+    describe('on timeout callback', () => {
+      it('will never call server if sampling is 0 with sendBeacon available', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION, 'sampling': {'onTimeout': 0.0}},
+        });
+
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(true);
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        expect(spec.onTimeout({'customData': 'customvalue'})).to.not.throw;
+        expect(beaconStub.called).to.be.false;
+        expect(ajaxStub.called).to.be.false;
+      });
+
+      it('will always call server if sampling is 1 with sendBeacon available', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION, 'sampling': {'onTimeout': 1.0}},
+        });
+
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(true);
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        expect(spec.onTimeout({'customData': 'customvalue'})).to.not.throw;
+        expect(beaconStub.called).to.be.true;
+        expect(ajaxStub.called).to.be.false;
+      });
+
+      it('will always call server if sampling is 1 with sendBeacon not available', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION, 'sampling': {'onTimeout': 1.0}},
+        });
+
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        expect(spec.onTimeout({'customData': 'customvalue'})).to.not.throw;
+        expect(beaconStub.called).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+        expect(ajaxStub.calledOnce).to.be.true;
+      });
+    });
+
+    describe('on onBidderError callback', () => {
+      it('will always call server if sampling is 1', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION, 'sampling': {'onBidderError': 1.0}},
+        });
+
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        spec.onBidderError({'customData': 'customvalue'});
+        expect(ajaxStub.calledOnce).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+      });
+    });
+
+    describe('on onBidWon callback', () => {
+      it('will always call server', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION},
+        });
+
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        spec.onBidWon({'customData': 'customvalue'});
+        expect(ajaxStub.calledOnce).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+      });
+    });
+
+    describe('on onBidBillable callback', () => {
+      it('will always call server', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION},
+        });
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        spec.onBidBillable({'customData': 'customvalue'});
+        expect(ajaxStub.calledOnce).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+      });
+    });
+
+    describe('on onAdRenderSucceeded callback', () => {
+      it('will always call server', () => {
+        config.setConfig({
+          contxtful: {customer: CUSTOMER, version: VERSION},
+        });
+        const ajaxStub = sandbox.stub(ajax, 'ajax');
+        const beaconStub = sandbox.stub(ajax, 'sendBeacon').returns(false);
+        spec.onAdRenderSucceeded({'customData': 'customvalue'});
+        expect(ajaxStub.calledOnce).to.be.true;
+        expect(beaconStub.returned(false)).to.be.true;
+      });
+    });
+  });
+});