diff --git a/modules/adtelligentBidAdapter.js b/modules/adtelligentBidAdapter.js
new file mode 100644
index 00000000000..fcaf09cc496
--- /dev/null
+++ b/modules/adtelligentBidAdapter.js
@@ -0,0 +1,250 @@
+import * as utils from '../src/utils';
+import {registerBidder} from '../src/adapters/bidderFactory';
+import {VIDEO, BANNER} from '../src/mediaTypes';
+import {Renderer} from '../src/Renderer';
+import find from 'core-js/library/fn/array/find';
+
+const URL = 'https://ghb.adtelligent.com/auction/';
+const OUTSTREAM_SRC = 'https://player.adtelligent.com/outstream-unit/2.01/outstream.min.js';
+const BIDDER_CODE = 'adtelligent';
+const OUTSTREAM = 'outstream';
+const DISPLAY = 'display';
+const syncsCache = {};
+
+export const spec = {
+  code: BIDDER_CODE,
+  aliases: ['onefiftytwomedia'],
+  supportedMediaTypes: [VIDEO, BANNER],
+  isBidRequestValid: function (bid) {
+    return !!utils.deepAccess(bid, 'params.aid');
+  },
+  getUserSyncs: function (syncOptions, serverResponses) {
+    const syncs = [];
+
+    function addSyncs(bid) {
+      const uris = bid.cookieURLs;
+      const types = bid.cookieURLSTypes || [];
+
+      if (Array.isArray(uris)) {
+        uris.forEach((uri, i) => {
+          const type = types[i] || 'image';
+
+          if ((!syncOptions.pixelEnabled && type == 'image') ||
+            (!syncOptions.iframeEnabled && type == 'iframe') ||
+            syncsCache[uri]) {
+            return;
+          }
+
+          syncsCache[uri] = true;
+          syncs.push({
+            type: type,
+            url: uri
+          })
+        })
+      }
+    }
+
+    if (syncOptions.pixelEnabled || syncOptions.iframeEnabled) {
+      utils.isArray(serverResponses) && serverResponses.forEach((response) => {
+        if (response.body) {
+          if (utils.isArray(response.body)) {
+            response.body.forEach(b => {
+              addSyncs(b);
+            })
+          } else {
+            addSyncs(response.body)
+          }
+        }
+      })
+    }
+    return syncs;
+  },
+  /**
+   * Make a server request from the list of BidRequests
+   * @param bidRequests
+   * @param bidderRequest
+   */
+  buildRequests: function (bidRequests, bidderRequest) {
+    return {
+      data: bidToTag(bidRequests, bidderRequest),
+      bidderRequest,
+      method: 'GET',
+      url: URL
+    };
+  },
+
+  /**
+   * Unpack the response from the server into a list of bids
+   * @param serverResponse
+   * @param bidderRequest
+   * @return {Bid[]} An array of bids which were nested inside the server
+   */
+  interpretResponse: function (serverResponse, {bidderRequest}) {
+    serverResponse = serverResponse.body;
+    let bids = [];
+
+    if (!utils.isArray(serverResponse)) {
+      return parseRTBResponse(serverResponse, bidderRequest);
+    }
+
+    serverResponse.forEach(serverBidResponse => {
+      bids = utils.flatten(bids, parseRTBResponse(serverBidResponse, bidderRequest));
+    });
+
+    return bids;
+  }
+};
+
+function parseRTBResponse(serverResponse, bidderRequest) {
+  const isInvalidValidResp = !serverResponse || !utils.isArray(serverResponse.bids);
+
+  const bids = [];
+
+  if (isInvalidValidResp) {
+    const extMessage = serverResponse && serverResponse.ext && serverResponse.ext.message ? `: ${serverResponse.ext.message}` : '';
+    const errorMessage = `in response for ${bidderRequest.bidderCode} adapter ${extMessage}`;
+
+    utils.logError(errorMessage);
+
+    return bids;
+  }
+
+  serverResponse.bids.forEach(serverBid => {
+    const request = find(bidderRequest.bids, (bidRequest) => {
+      return bidRequest.bidId === serverBid.requestId;
+    });
+
+    if (serverBid.cpm !== 0 && request !== undefined) {
+      const bid = createBid(serverBid, getMediaType(request));
+
+      bids.push(bid);
+    }
+  });
+
+  return bids;
+}
+
+function bidToTag(bidRequests, bidderRequest) {
+  const tag = {
+    domain: utils.deepAccess(bidderRequest, 'refererInfo.referer')
+  };
+
+  if (utils.deepAccess(bidderRequest, 'gdprConsent.gdprApplies')) {
+    tag.gdpr = 1;
+    tag.gdpr_consent = utils.deepAccess(bidderRequest, 'gdprConsent.consentString');
+  }
+
+  if (utils.deepAccess(bidderRequest, 'bidderRequest.uspConsent')) {
+    tag.us_privacy = bidderRequest.uspConsent;
+  }
+
+  for (let i = 0, length = bidRequests.length; i < length; i++) {
+    Object.assign(tag, prepareRTBRequestParams(i, bidRequests[i]));
+  }
+
+  return tag;
+}
+
+/**
+ * Parse mediaType
+ * @param _index {number}
+ * @param bid {object}
+ * @returns {object}
+ */
+function prepareRTBRequestParams(_index, bid) {
+  const mediaType = utils.deepAccess(bid, 'mediaTypes.video') ? VIDEO : DISPLAY;
+  const index = !_index ? '' : `${_index + 1}`;
+  const sizes = mediaType === VIDEO ? utils.deepAccess(bid, 'mediaTypes.video.playerSize') : utils.deepAccess(bid, 'mediaTypes.banner.sizes');
+  return {
+    ['callbackId' + index]: bid.bidId,
+    ['aid' + index]: bid.params.aid,
+    ['ad_type' + index]: mediaType,
+    ['sizes' + index]: utils.parseSizesInput(sizes).join()
+  };
+}
+
+/**
+ * Prepare all parameters for request
+ * @param bidderRequest {object}
+ * @returns {object}
+ */
+function getMediaType(bidderRequest) {
+  const videoMediaType = utils.deepAccess(bidderRequest, 'mediaTypes.video');
+  const context = utils.deepAccess(bidderRequest, 'mediaTypes.video.context');
+
+  return !videoMediaType ? DISPLAY : context === OUTSTREAM ? OUTSTREAM : VIDEO;
+}
+
+/**
+ * Configure new bid by response
+ * @param bidResponse {object}
+ * @param mediaType {Object}
+ * @returns {object}
+ */
+function createBid(bidResponse, mediaType) {
+  const bid = {
+    requestId: bidResponse.requestId,
+    creativeId: bidResponse.cmpId,
+    height: bidResponse.height,
+    currency: bidResponse.cur,
+    width: bidResponse.width,
+    cpm: bidResponse.cpm,
+    netRevenue: true,
+    mediaType,
+    ttl: 3600
+  };
+
+  if (mediaType === DISPLAY) {
+    return Object.assign(bid, {
+      ad: bidResponse.ad
+    });
+  }
+
+  Object.assign(bid, {
+    vastUrl: bidResponse.vastUrl
+  });
+
+  if (mediaType === OUTSTREAM) {
+    Object.assign(bid, {
+      mediaType: 'video',
+      adResponse: bidResponse,
+      renderer: newRenderer(bidResponse.requestId)
+    });
+  }
+
+  return bid;
+}
+
+/**
+ * Create Adtelligent renderer
+ * @param requestId
+ * @returns {*}
+ */
+function newRenderer(requestId) {
+  const renderer = Renderer.install({
+    id: requestId,
+    url: OUTSTREAM_SRC,
+    loaded: false
+  });
+
+  renderer.setRender(outstreamRender);
+
+  return renderer;
+}
+
+/**
+ * Initialise Adtelligent outstream
+ * @param bid
+ */
+function outstreamRender(bid) {
+  bid.renderer.push(() => {
+    window.VOutstreamAPI.initOutstreams([{
+      width: bid.width,
+      height: bid.height,
+      vastUrl: bid.vastUrl,
+      elId: bid.adUnitCode
+    }]);
+  });
+}
+
+registerBidder(spec);
diff --git a/test/spec/modules/adtelligentBidAdapter_spec.js b/test/spec/modules/adtelligentBidAdapter_spec.js
new file mode 100644
index 00000000000..1787816fac2
--- /dev/null
+++ b/test/spec/modules/adtelligentBidAdapter_spec.js
@@ -0,0 +1,324 @@
+import {expect} from 'chai';
+import {spec} from 'modules/adtelligentBidAdapter';
+import {newBidder} from 'src/adapters/bidderFactory';
+
+const ENDPOINT = 'https://ghb.adtelligent.com/auction/';
+
+const DISPLAY_REQUEST = {
+  'bidder': 'adtelligent',
+  'params': {
+    'aid': 12345
+  },
+  'mediaTypes': {'banner': {'sizes': [300, 250]}},
+  'bidderRequestId': '7101db09af0db2',
+  'auctionId': '2e41f65424c87c',
+  'adUnitCode': 'adunit-code',
+  'bidId': '84ab500420319d',
+};
+
+const VIDEO_REQUEST = {
+  'bidder': 'adtelligent',
+  'mediaTypes': {
+    'video': {
+      'playerSize': [[480, 360], [640, 480]]
+    }
+  },
+  'params': {
+    'aid': 12345
+  },
+  'bidderRequestId': '7101db09af0db2',
+  'auctionId': '2e41f65424c87c',
+  'adUnitCode': 'adunit-code',
+  'bidId': '84ab500420319d'
+};
+
+const SERVER_VIDEO_RESPONSE = {
+  'source': {'aid': 12345, 'pubId': 54321},
+  'bids': [{
+    'vastUrl': 'http://rtb.adtelligent.com/vast/?adid=44F2AEB9BFC881B3',
+    'requestId': '2e41f65424c87c',
+    'url': '44F2AEB9BFC881B3',
+    'creative_id': 342516,
+    'cmpId': 342516,
+    'height': 480,
+    'cur': 'USD',
+    'width': 640,
+    'cpm': 0.9
+  }
+  ]
+};
+
+const SERVER_DISPLAY_RESPONSE = {
+  'source': {'aid': 12345, 'pubId': 54321},
+  'bids': [{
+    'ad': '<!-- Creative -->',
+    'requestId': '2e41f65424c87c',
+    'creative_id': 342516,
+    'cmpId': 342516,
+    'height': 250,
+    'cur': 'USD',
+    'width': 300,
+    'cpm': 0.9
+  }],
+  'cookieURLs': ['link1', 'link2']
+};
+const SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS = {
+  'source': {'aid': 12345, 'pubId': 54321},
+  'bids': [{
+    'ad': '<!-- Creative -->',
+    'requestId': '2e41f65424c87c',
+    'creative_id': 342516,
+    'cmpId': 342516,
+    'height': 250,
+    'cur': 'USD',
+    'width': 300,
+    'cpm': 0.9
+  }],
+  'cookieURLs': ['link3', 'link4'],
+  'cookieURLSTypes': ['image', 'iframe']
+};
+
+const videoBidderRequest = {
+  bidderCode: 'bidderCode',
+  bids: [{mediaTypes: {video: {}}, bidId: '2e41f65424c87c'}]
+};
+
+const displayBidderRequest = {
+  bidderCode: 'bidderCode',
+  bids: [{bidId: '2e41f65424c87c'}]
+};
+
+const displayBidderRequestWithGdpr = {
+  bidderCode: 'bidderCode',
+  bids: [{bidId: '2e41f65424c87c'}],
+  gdprConsent: {
+    gdprApplies: true,
+    consentString: 'test'
+  }
+};
+
+const videoEqResponse = [{
+  vastUrl: 'http://rtb.adtelligent.com/vast/?adid=44F2AEB9BFC881B3',
+  requestId: '2e41f65424c87c',
+  creativeId: 342516,
+  mediaType: 'video',
+  netRevenue: true,
+  currency: 'USD',
+  height: 480,
+  width: 640,
+  ttl: 3600,
+  cpm: 0.9
+}];
+
+const displayEqResponse = [{
+  requestId: '2e41f65424c87c',
+  creativeId: 342516,
+  mediaType: 'display',
+  netRevenue: true,
+  currency: 'USD',
+  ad: '<!-- Creative -->',
+  height: 250,
+  width: 300,
+  ttl: 3600,
+  cpm: 0.9
+}];
+
+describe('adtelligentBidAdapter', function () {
+  const adapter = newBidder(spec);
+
+  describe('user syncs as image', function () {
+    it('should be returned if pixel enabled', function () {
+      const syncs = spec.getUserSyncs({pixelEnabled: true}, [{body: SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS}]);
+
+      expect(syncs.map(s => s.url)).to.deep.equal([SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS.cookieURLs[0]]);
+      expect(syncs.map(s => s.type)).to.deep.equal(['image']);
+    })
+  })
+
+  describe('user syncs as iframe', function () {
+    it('should be returned if iframe enabled', function () {
+      const syncs = spec.getUserSyncs({iframeEnabled: true}, [{body: SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS}]);
+
+      expect(syncs.map(s => s.url)).to.deep.equal([SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS.cookieURLs[1]]);
+      expect(syncs.map(s => s.type)).to.deep.equal(['iframe']);
+    })
+  })
+
+  describe('user sync', function () {
+    it('should not  be returned if passed syncs where already used', function () {
+      const syncs = spec.getUserSyncs({
+        iframeEnabled: true,
+        pixelEnabled: true
+      }, [{body: SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS}]);
+
+      expect(syncs).to.deep.equal([]);
+    })
+  });
+
+  describe('user syncs with both types', function () {
+    it('should be returned if pixel and iframe enabled', function () {
+      const mockedServerResponse = Object.assign({}, SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS, {'cookieURLs': ['link5', 'link6']});
+      const syncs = spec.getUserSyncs({
+        iframeEnabled: true,
+        pixelEnabled: true
+      }, [{body: mockedServerResponse}]);
+
+      expect(syncs.map(s => s.url)).to.deep.equal(mockedServerResponse.cookieURLs);
+      expect(syncs.map(s => s.type)).to.deep.equal(mockedServerResponse.cookieURLSTypes);
+    });
+  });
+
+  describe('user syncs', function () {
+    it('should not be returned if pixel not set', function () {
+      const syncs = spec.getUserSyncs({}, [{body: SERVER_DISPLAY_RESPONSE_WITH_MIXED_SYNCS}]);
+
+      expect(syncs).to.be.empty;
+    });
+  });
+
+  describe('inherited functions', function () {
+    it('exists and is a function', function () {
+      expect(adapter.callBids).to.exist.and.to.be.a('function');
+    });
+  });
+
+  describe('isBidRequestValid', function () {
+    it('should return true when required params found', function () {
+      expect(spec.isBidRequestValid(VIDEO_REQUEST)).to.equal(true);
+    });
+
+    it('should return false when required params are not passed', function () {
+      let bid = Object.assign({}, VIDEO_REQUEST);
+      delete bid.params;
+      expect(spec.isBidRequestValid(bid)).to.equal(false);
+    });
+  });
+
+  describe('buildRequests', function () {
+    let videoBidRequests = [VIDEO_REQUEST];
+    let displayBidRequests = [DISPLAY_REQUEST];
+    let videoAndDisplayBidRequests = [DISPLAY_REQUEST, VIDEO_REQUEST];
+
+    const displayRequest = spec.buildRequests(displayBidRequests, {});
+    const videoRequest = spec.buildRequests(videoBidRequests, {});
+    const videoAndDisplayRequests = spec.buildRequests(videoAndDisplayBidRequests, {});
+
+    it('sends bid request to ENDPOINT via GET', function () {
+      expect(videoRequest.method).to.equal('GET');
+      expect(displayRequest.method).to.equal('GET');
+      expect(videoAndDisplayRequests.method).to.equal('GET');
+    });
+
+    it('sends bid request to correct ENDPOINT', function () {
+      expect(videoRequest.url).to.equal(ENDPOINT);
+      expect(displayRequest.url).to.equal(ENDPOINT);
+      expect(videoAndDisplayRequests.url).to.equal(ENDPOINT);
+    });
+
+    it('sends correct video bid parameters', function () {
+      const bid = Object.assign({}, videoRequest.data);
+      delete bid.domain;
+
+      const eq = {
+        callbackId: '84ab500420319d',
+        ad_type: 'video',
+        aid: 12345,
+        sizes: '480x360,640x480'
+      };
+
+      expect(bid).to.deep.equal(eq);
+    });
+
+    it('sends correct display bid parameters', function () {
+      const bid = Object.assign({}, displayRequest.data);
+      delete bid.domain;
+
+      const eq = {
+        callbackId: '84ab500420319d',
+        ad_type: 'display',
+        aid: 12345,
+        sizes: '300x250'
+      };
+
+      expect(bid).to.deep.equal(eq);
+    });
+
+    it('sends correct video and display bid parameters', function () {
+      const bid = Object.assign({}, videoAndDisplayRequests.data);
+      delete bid.domain;
+
+      const eq = {
+        callbackId: '84ab500420319d',
+        ad_type: 'display',
+        aid: 12345,
+        sizes: '300x250',
+        callbackId2: '84ab500420319d',
+        ad_type2: 'video',
+        aid2: 12345,
+        sizes2: '480x360,640x480'
+      };
+
+      expect(bid).to.deep.equal(eq);
+    });
+  });
+
+  describe('interpretResponse', function () {
+    let serverResponse;
+    let bidderRequest;
+    let eqResponse;
+
+    afterEach(function () {
+      serverResponse = null;
+      bidderRequest = null;
+      eqResponse = null;
+    });
+
+    it('should get correct video bid response', function () {
+      serverResponse = SERVER_VIDEO_RESPONSE;
+      bidderRequest = videoBidderRequest;
+      eqResponse = videoEqResponse;
+
+      bidServerResponseCheck();
+    });
+
+    it('should get correct display bid response', function () {
+      serverResponse = SERVER_DISPLAY_RESPONSE;
+      bidderRequest = displayBidderRequest;
+      eqResponse = displayEqResponse;
+
+      bidServerResponseCheck();
+    });
+
+    it('should set gdpr data correctly', function () {
+      const builtRequestData = spec.buildRequests([DISPLAY_REQUEST], displayBidderRequestWithGdpr);
+
+      expect(builtRequestData.data.gdpr).to.be.equal(1);
+      expect(builtRequestData.data.gdpr_consent).to.be.equal(displayBidderRequestWithGdpr.gdprConsent.consentString);
+    });
+
+    function bidServerResponseCheck() {
+      const result = spec.interpretResponse({body: serverResponse}, {bidderRequest});
+
+      expect(result).to.deep.equal(eqResponse);
+    }
+
+    function nobidServerResponseCheck() {
+      const noBidServerResponse = {bids: []};
+      const noBidResult = spec.interpretResponse({body: noBidServerResponse}, {bidderRequest});
+
+      expect(noBidResult.length).to.equal(0);
+    }
+
+    it('handles video nobid responses', function () {
+      bidderRequest = videoBidderRequest;
+
+      nobidServerResponseCheck();
+    });
+
+    it('handles display nobid responses', function () {
+      bidderRequest = displayBidderRequest;
+
+      nobidServerResponseCheck();
+    });
+  });
+});