diff --git a/modules/parrableIdSystem.js b/modules/parrableIdSystem.js
index 75f89fffc14..2d6a2d6d6e5 100644
--- a/modules/parrableIdSystem.js
+++ b/modules/parrableIdSystem.js
@@ -113,6 +113,51 @@ function migrateLegacyCookies(parrableId) {
   }
 }
 
+function shouldFilterImpression(configParams, parrableId) {
+  const config = configParams.timezoneFilter;
+
+  if (!config) {
+    return false;
+  }
+
+  if (parrableId) {
+    return false;
+  }
+
+  const offset = (new Date()).getTimezoneOffset() / 60;
+  const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+  function isAllowed() {
+    if (utils.isEmpty(config.allowedZones) &&
+      utils.isEmpty(config.allowedOffsets)) {
+      return true;
+    }
+    if (utils.contains(config.allowedZones, zone)) {
+      return true;
+    }
+    if (utils.contains(config.allowedOffsets, offset)) {
+      return true;
+    }
+    return false;
+  }
+
+  function isBlocked() {
+    if (utils.isEmpty(config.blockedZones) &&
+      utils.isEmpty(config.blockedOffsets)) {
+      return false;
+    }
+    if (utils.contains(config.blockedZones, zone)) {
+      return true;
+    }
+    if (utils.contains(config.blockedOffsets, offset)) {
+      return true;
+    }
+    return false;
+  }
+
+  return !isAllowed() || isBlocked();
+}
+
 function fetchId(configParams) {
   if (!isValidConfig(configParams)) return;
 
@@ -122,6 +167,10 @@ function fetchId(configParams) {
     migrateLegacyCookies(parrableId);
   }
 
+  if (shouldFilterImpression(configParams, parrableId)) {
+    return null;
+  }
+
   const eid = (parrableId) ? parrableId.eid : null;
   const refererInfo = getRefererInfo();
   const uspString = uspDataHandler.getConsentData();
diff --git a/test/spec/modules/parrableIdSystem_spec.js b/test/spec/modules/parrableIdSystem_spec.js
index 7db22af82ab..1cc89240bc3 100644
--- a/test/spec/modules/parrableIdSystem_spec.js
+++ b/test/spec/modules/parrableIdSystem_spec.js
@@ -75,113 +75,116 @@ function removeParrableCookie() {
 }
 
 describe('Parrable ID System', function() {
-  describe('parrableIdSystem.getId() callback', function() {
-    let logErrorStub;
-    let callbackSpy = sinon.spy();
+  describe('parrableIdSystem.getId()', function() {
+    describe('response callback function', function() {
+      let logErrorStub;
+      let callbackSpy = sinon.spy();
+
+      beforeEach(function() {
+        logErrorStub = sinon.stub(utils, 'logError');
+        callbackSpy.resetHistory();
+        writeParrableCookie({ eid: P_COOKIE_EID });
+      });
 
-    beforeEach(function() {
-      logErrorStub = sinon.stub(utils, 'logError');
-      callbackSpy.resetHistory();
-      writeParrableCookie({ eid: P_COOKIE_EID });
-    });
+      afterEach(function() {
+        removeParrableCookie();
+        logErrorStub.restore();
+      })
 
-    afterEach(function() {
-      removeParrableCookie();
-      logErrorStub.restore();
-    })
+      it('creates xhr to Parrable that synchronizes the ID', function() {
+        let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
 
-    it('creates xhr to Parrable that synchronizes the ID', function() {
-      let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
+        getIdResult.callback(callbackSpy);
 
-      getIdResult.callback(callbackSpy);
+        let request = server.requests[0];
+        let queryParams = utils.parseQS(request.url.split('?')[1]);
+        let data = JSON.parse(atob(queryParams.data));
 
-      let request = server.requests[0];
-      let queryParams = utils.parseQS(request.url.split('?')[1]);
-      let data = JSON.parse(atob(queryParams.data));
+        expect(getIdResult.callback).to.be.a('function');
+        expect(request.url).to.contain('h.parrable.com');
 
-      expect(getIdResult.callback).to.be.a('function');
-      expect(request.url).to.contain('h.parrable.com');
+        expect(queryParams).to.not.have.property('us_privacy');
+        expect(data).to.deep.equal({
+          eid: P_COOKIE_EID,
+          trackers: P_CONFIG_MOCK.params.partner.split(','),
+          url: getRefererInfo().referer
+        });
 
-      expect(queryParams).to.not.have.property('us_privacy');
-      expect(data).to.deep.equal({
-        eid: P_COOKIE_EID,
-        trackers: P_CONFIG_MOCK.params.partner.split(','),
-        url: getRefererInfo().referer
-      });
+        server.requests[0].respond(200,
+          { 'Content-Type': 'text/plain' },
+          JSON.stringify({ eid: P_XHR_EID })
+        );
 
-      server.requests[0].respond(200,
-        { 'Content-Type': 'text/plain' },
-        JSON.stringify({ eid: P_XHR_EID })
-      );
+        expect(callbackSpy.lastCall.lastArg).to.deep.equal({
+          eid: P_XHR_EID
+        });
 
-      expect(callbackSpy.lastCall.lastArg).to.deep.equal({
-        eid: P_XHR_EID
+        expect(storage.getCookie(P_COOKIE_NAME)).to.equal(
+          encodeURIComponent('eid:' + P_XHR_EID)
+        );
       });
 
-      expect(storage.getCookie(P_COOKIE_NAME)).to.equal(
-        encodeURIComponent('eid:' + P_XHR_EID)
-      );
-    });
-
-    it('xhr passes the uspString to Parrable', function() {
-      let uspString = '1YNN';
-      uspDataHandler.setConsentData(uspString);
-      parrableIdSubmodule.getId(
-        P_CONFIG_MOCK.params,
-        null,
-        null
-      ).callback(callbackSpy);
-      uspDataHandler.setConsentData(null);
-      expect(server.requests[0].url).to.contain('us_privacy=' + uspString);
-    });
+      it('xhr passes the uspString to Parrable', function() {
+        let uspString = '1YNN';
+        uspDataHandler.setConsentData(uspString);
+        parrableIdSubmodule.getId(
+          P_CONFIG_MOCK.params,
+          null,
+          null
+        ).callback(callbackSpy);
+        uspDataHandler.setConsentData(null);
+        expect(server.requests[0].url).to.contain('us_privacy=' + uspString);
+      });
 
-    it('should log an error and continue to callback if ajax request errors', function () {
-      let callBackSpy = sinon.spy();
-      let submoduleCallback = parrableIdSubmodule.getId({partner: 'prebid'}).callback;
-      submoduleCallback(callBackSpy);
-      let request = server.requests[0];
-      expect(request.url).to.contain('h.parrable.com');
-      request.respond(
-        503,
-        null,
-        'Unavailable'
-      );
-      expect(logErrorStub.calledOnce).to.be.true;
-      expect(callBackSpy.calledOnce).to.be.true;
+      it('should log an error and continue to callback if ajax request errors', function () {
+        let callBackSpy = sinon.spy();
+        let submoduleCallback = parrableIdSubmodule.getId({partner: 'prebid'}).callback;
+        submoduleCallback(callBackSpy);
+        let request = server.requests[0];
+        expect(request.url).to.contain('h.parrable.com');
+        request.respond(
+          503,
+          null,
+          'Unavailable'
+        );
+        expect(logErrorStub.calledOnce).to.be.true;
+        expect(callBackSpy.calledOnce).to.be.true;
+      });
     });
-  });
 
-  describe('parrableIdSystem.getId() id', function() {
-    it('provides the stored Parrable values if a cookie exists', function() {
-      writeParrableCookie({ eid: P_COOKIE_EID });
-      let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
-      removeParrableCookie();
+    describe('response id', function() {
+      it('provides the stored Parrable values if a cookie exists', function() {
+        writeParrableCookie({ eid: P_COOKIE_EID });
+        let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
+        removeParrableCookie();
 
-      expect(getIdResult.id).to.deep.equal({
-        eid: P_COOKIE_EID
+        expect(getIdResult.id).to.deep.equal({
+          eid: P_COOKIE_EID
+        });
       });
-    });
 
-    it('provides the stored legacy Parrable ID values if cookies exist', function() {
-      let oldEid = '01.111.old-eid';
-      let oldEidCookieName = '_parrable_eid';
-      let oldOptoutCookieName = '_parrable_optout';
+      it('provides the stored legacy Parrable ID values if cookies exist', function() {
+        let oldEid = '01.111.old-eid';
+        let oldEidCookieName = '_parrable_eid';
+        let oldOptoutCookieName = '_parrable_optout';
 
-      storage.setCookie(oldEidCookieName, oldEid);
-      storage.setCookie(oldOptoutCookieName, 'true');
+        storage.setCookie(oldEidCookieName, oldEid);
+        storage.setCookie(oldOptoutCookieName, 'true');
 
-      let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
-      expect(getIdResult.id).to.deep.equal({
-        eid: oldEid,
-        ibaOptout: true
-      });
+        let getIdResult = parrableIdSubmodule.getId(P_CONFIG_MOCK.params);
+        expect(getIdResult.id).to.deep.equal({
+          eid: oldEid,
+          ibaOptout: true
+        });
 
-      // The ID system is expected to migrate old cookies to the new format
-      expect(storage.getCookie(P_COOKIE_NAME)).to.equal(
-        encodeURIComponent('eid:' + oldEid + ',ibaOptout:1')
-      );
-      expect(storage.getCookie(oldEidCookieName)).to.equal(null);
-      expect(storage.getCookie(oldOptoutCookieName)).to.equal(null);
+        // The ID system is expected to migrate old cookies to the new format
+        expect(storage.getCookie(P_COOKIE_NAME)).to.equal(
+          encodeURIComponent('eid:' + oldEid + ',ibaOptout:1')
+        );
+        expect(storage.getCookie(oldEidCookieName)).to.equal(null);
+        expect(storage.getCookie(oldOptoutCookieName)).to.equal(null);
+        removeParrableCookie();
+      });
     });
   });
 
@@ -199,6 +202,181 @@ describe('Parrable ID System', function() {
     });
   });
 
+  describe('timezone filtering', function() {
+    before(function() {
+      sinon.stub(Intl, 'DateTimeFormat');
+    });
+
+    after(function() {
+      Intl.DateTimeFormat.restore();
+    });
+
+    it('permits an impression when no timezoneFilter is configured', function() {
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+      })).to.have.property('callback');
+    });
+
+    it('permits an impression from a blocked timezone when a cookie exists', function() {
+      const blockedZone = 'Antarctica/South_Pole';
+      const resolvedOptions = sinon.stub().returns({ timeZone: blockedZone });
+      Intl.DateTimeFormat.returns({ resolvedOptions });
+
+      writeParrableCookie({ eid: P_COOKIE_EID });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedZones: [ blockedZone ]
+        }
+      })).to.have.property('callback');
+      expect(resolvedOptions.called).to.equal(false);
+
+      removeParrableCookie();
+    })
+
+    it('permits an impression from an allowed timezone', function() {
+      const allowedZone = 'America/New_York';
+      const resolvedOptions = sinon.stub().returns({ timeZone: allowedZone });
+      Intl.DateTimeFormat.returns({ resolvedOptions });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          allowedZones: [ allowedZone ]
+        }
+      })).to.have.property('callback');
+      expect(resolvedOptions.called).to.equal(true);
+    });
+
+    it('permits an impression from a timezone that is not blocked', function() {
+      const blockedZone = 'America/New_York';
+      const resolvedOptions = sinon.stub().returns({ timeZone: 'Iceland' });
+      Intl.DateTimeFormat.returns({ resolvedOptions });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedZones: [ blockedZone ]
+        }
+      })).to.have.property('callback');
+      expect(resolvedOptions.called).to.equal(true);
+    });
+
+    it('does not permit an impression from a blocked timezone', function() {
+      const blockedZone = 'America/New_York';
+      const resolvedOptions = sinon.stub().returns({ timeZone: blockedZone });
+      Intl.DateTimeFormat.returns({ resolvedOptions });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedZones: [ blockedZone ]
+        }
+      })).to.equal(null);
+      expect(resolvedOptions.called).to.equal(true);
+    });
+
+    it('does not permit an impression from a blocked timezone even when also allowed', function() {
+      const timezone = 'America/New_York';
+      const resolvedOptions = sinon.stub().returns({ timeZone: timezone });
+      Intl.DateTimeFormat.returns({ resolvedOptions });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          allowedZones: [ timezone ],
+          blockedZones: [ timezone ]
+        }
+      })).to.equal(null);
+      expect(resolvedOptions.called).to.equal(true);
+    });
+  });
+
+  describe('timezone offset filtering', function() {
+    before(function() {
+      sinon.stub(Date.prototype, 'getTimezoneOffset');
+    });
+
+    afterEach(function() {
+      Date.prototype.getTimezoneOffset.reset();
+    })
+
+    after(function() {
+      Date.prototype.getTimezoneOffset.restore();
+    });
+
+    it('permits an impression from a blocked offset when a cookie exists', function() {
+      const blockedOffset = -4;
+      Date.prototype.getTimezoneOffset.returns(blockedOffset * 60);
+
+      writeParrableCookie({ eid: P_COOKIE_EID });
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedOffsets: [ blockedOffset ]
+        }
+      })).to.have.property('callback');
+
+      removeParrableCookie();
+    });
+
+    it('permits an impression from an allowed offset', function() {
+      const allowedOffset = -5;
+      Date.prototype.getTimezoneOffset.returns(allowedOffset * 60);
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          allowedOffsets: [ allowedOffset ]
+        }
+      })).to.have.property('callback');
+      expect(Date.prototype.getTimezoneOffset.called).to.equal(true);
+    });
+
+    it('permits an impression from an offset that is not blocked', function() {
+      const allowedOffset = -5;
+      const blockedOffset = 5;
+      Date.prototype.getTimezoneOffset.returns(allowedOffset * 60);
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedOffsets: [ blockedOffset ]
+        }
+      })).to.have.property('callback');
+      expect(Date.prototype.getTimezoneOffset.called).to.equal(true);
+    });
+
+    it('does not permit an impression from a blocked offset', function() {
+      const blockedOffset = -5;
+      Date.prototype.getTimezoneOffset.returns(blockedOffset * 60);
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          blockedOffsets: [ blockedOffset ]
+        }
+      })).to.equal(null);
+      expect(Date.prototype.getTimezoneOffset.called).to.equal(true);
+    });
+
+    it('does not permit an impression from a blocked offset even when also allowed', function() {
+      const offset = -5;
+      Date.prototype.getTimezoneOffset.returns(offset * 60);
+
+      expect(parrableIdSubmodule.getId({
+        partner: 'prebid-test',
+        timezoneFilter: {
+          allowedOffset: [ offset ],
+          blockedOffsets: [ offset ]
+        }
+      })).to.equal(null);
+      expect(Date.prototype.getTimezoneOffset.called).to.equal(true);
+    });
+  });
+
   describe('userId requestBids hook', function() {
     let adUnits;