Introduction

Welcome to the PowerLinks Media documentation portal. This is where you’ll find important information regarding specs, standards, and best practices.

Sell-Side Specifications

PowerLinks Media is fully compliant with the OpenRTB 2.3 specifications and its Native subprotocol. Below you’ll find information regarding PowerLinks’s bid request specifications for sell-side partners.

Supported Objects

Object Name	Supported	Required	Highly Recommended	Optional
Bid Request	Yes	id, imp	site, app, device, user	test, at, tmax, wseat, allimps, cur, bcat, badv, regs, ext
Imp	Yes	id	-	banner, video, native, displaymanager, displaymanagerver, instl, tagid, bidfloor, bidfloorcur, secure, iframebuster, pmp
Banner	Yes	-	w, h	wmax, hmax, wmin, hmin, id, btype, battr, pos, mimes, topframe, expdir, api
Video	Yes	mimes	minduration, maxduration, protocols, w, h, startdelay	linearity, sequence, battr, maxextended, minbitrate, maxbitrate, boxingallowed, playbackmethod, delivery, pos, companionad, api, companiontype
Native	Yes	request	ver	api, battr
Site	Yes	-	id	name, domain, cat, sectioncat, pagecat, page, ref, search, mobile, privacypolicy, publisher, content, keywords
App	Yes	-	id	name, bundle, domain, storeurl, cat, sectioncat, pagecat, ver, privacypolicy, paid, publisher, content, keywords
Publisher	Yes	-	-	id, name, cat, domain
Content	Yes	-	-	id, episode, title, series, season, producer, url, cat, videoquality, context, contentrating, userrating, qagmediarating, keywords, livestream, sourcerelationship, len, language, embeddable
Producer	Yes	-	-	id, name, cat, domain
Device	Yes	-	ua, geo, dnt, lmt, ip	ipv6, devicetype, make, model, os, osv, hwv, h, w, ppi, pxratio,js, flashver, language, carrier, connectiontype, ifa, didsha1, didmd5, dpidsha1, dpidmd5, macsha1, macmd5
Geo	Yes	-	-	lat, lon, type, country, region, regionfips104, metro, city, zip, utcoffset
User	Yes	-	id, buyerid	yob, gender, keywords, customdata, geo, data
Data	Yes	-	-	id, name, segment
Segment	Yes	-	-	id, name, value
Regs	Yes	-	-	coppa
Pmp	Yes	-	-	private_auction, deals
Deal	Yes	id	-	bidfloor, bidfloorcur, at, wseat, wadomain

BidRequest

Field Name	Type	Default	Description
id	string	-	Unique ID of the bid request, provided by the exchange.
imp	object array	-	Array of Imp objects representing the impressions offered. At least 1 Imp object is required
site	object	-	Details via a Site object about the publisher’s website. Only applicable and recommended for websites
app	object	-	Details via an App object about the publisher’s app (i.e., non-browser applications). Only applicable and recommended for apps.
device	object	-	Details via a Device object about the user’s device to which the impression will be delivered.
user	object	-	Details via a User object about the human user of the device; the advertising audience.
test	integer	0	Indicator of test mode in which auctions are not billable, where 0 = live mode, 1 = test mode
at	integer	2	Auction type, where 1 = First Price, 2 = Second Price Plus. Exchange-specific auction types can be defined using values greater than 500.
tmax	integer	-	Maximum time in milliseconds to submit a bid to avoid timeout. This value is commonly communicated offline.
wseat	string array	-	Whitelist of buyer seats allowed to bid on this impression. Seat IDs must be communicated between bidders and the exchange a priori. Omission implies no seat restrictions.
allimps	integer	0	Flag to indicate if Exchange can verify that the impressions offered represent all of the impressions available in context (e.g., all on the web page, all video spots such as pre/mid/post roll) to support road blocking. 0 = no or unknown, 1 = yes, the impressions offered represent all that are available.
cur	string array	-	Array of allowed currencies for bids on this bid request using ISO-4217 alpha codes. Recommended only if the exchange accepts multiple currencies.
bcat	string array	-	Blocked advertiser categories using the IAB content categories.
badv	string array	-	Block list of advertisers by their domains (e.g., “ford.com”)
reqs	object	-	A Regs object (Section 3.2.16) that specifies any industry, legal, or governmental regulations in force for this request.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Imp

Field Name	Type	Default	Description
id	string	-	A unique identifier for this impression within the context of the bid request (typically, starts with 1 and increments.
banner	object	-	A Banner object; required if this impression is offered as a banner ad opportunity.
video	object	-	A Video object (Section 3.2.4); required if this impression is offered as a video ad opportunity
native	object	-	A Native object (Section 3.2.5); required if this impression is offered as a native ad opportunity.
displaymanager	string	-	Name of ad mediation partner, SDK technology, or player responsible for rendering ad (typically video or mobile). Used by some ad servers to customize ad code by partner. Recommended for video and/or apps.
displaymanagerver	string	-	Version of ad mediation partner, SDK technology, or player responsible for rendering ad (typically video or mobile). Used by some ad servers to customize ad code by partner. Recommended for video and/or apps.
instl	integer	0	1 = the ad is interstitial or full screen, 0 = not interstitial.
tagid	string	-	Identifier for specific ad placement or ad tag that was used to initiate the auction. This can be useful for debugging of any issues, or for optimization by the buyer.
bidfloor	float	0	Minimum bid for this impression expressed in CPM.
bidfloorcur	string	USD	Currency specified using ISO-4217 alpha codes. This may be different from bid currency returned by bidder if this is allowed by the exchange.
secure	integer	-	Flag to indicate if the impression requires secure HTTPS URL creative assets and markup, where 0 = non-secure, 1 = secure. If omitted, the secure state is unknown, but non-secure HTTP support can be assumed.
iframebuster	string array	-	Array of exchange-specific names of supported iframe busters.
pmp	string array	-	A Pmp object containing any private marketplace deals in effect for this impression.
ext	string array	-	Placeholder for exchange-specific extensions to OpenRTB.

Banner

Field Name	Type	Default	Description
w	integer	-	Width of the impression in pixels. If neither wmin nor wmax are specified, this value is an exact width requirement. Otherwise it is a preferred width.
h	integer	-	Height of the impression in pixels. If neither hmin nor hmax are specified, this value is an exact height requirement. Otherwise it is a preferred height.
wmax	integer	-	Maximum width of the impression in pixels. If included along with a w value then w should be interpreted as a recommended or preferred width.
hmax	integer	-	Maximum height of the impression in pixels. If included along with an h value then h should be interpreted as a recommended or preferred height.
wmin	integer	-	Minimum width of the impression in pixels. If included along with a w value then w should be interpreted as a recommended or preferred width.
hmin	integer	-	Minimum height of the impression in pixels. If included along with an h value then h should be interpreted as a recommended or preferred height.
id	string	-	Unique identifier for this banner object. Recommended when Banner objects are used with a Video object to represent an array of companion ads. Values usually start at 1 and increase with each object; should be unique within an impression.
btype	integer array	-	Blocked banner ad types.
battr	integer array	-	Blocked creative attributes.
pos	integer	-	Ad position on screen.
mimes	string array	-	Content MIME types supported. Popular MIME types may include “application/x-shockwave-flash”, “image/jpg”, and “image/gif”.
topframe	integer	-	Indicates if the banner is in the top frame as opposed to an iframe, where 0 = no, 1 = yes.
expdir	integer array	-	Directions in which the banner may expand.
api	integer array	-	List of supported API frameworks for this impression. If an API is not explicitly listed, it is assumed not to be supported
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Video

Field Name	Type	Default	Description
mimes	string array	-	Content MIME types supported. Popular MIME types may include “video/x-ms-wmv” for Windows Media and “video/x-flv” for Flash Video.
minduration	integer	-	Minimum video ad duration in seconds.
maxduration	integer	-	Maximum video ad duration in seconds.
protocols	integer array	-	Array of supported video bid response protocols. At least one supported protocol must be specified in either the protocol or protocols attribute.
w	integer	-	Width of video player in pixels.
h	integer	-	Height of video player in pixels.
startdelay	integer	-	Indicates the start delay in seconds for pre-roll, mid-roll, or post-roll ad placements. Refer to List 5.10 for additional generic values.
linearity	integer	-	Indicates if the impression must be linear, nonlinear, etc. If none specified, assume all are allowed.
sequence	integer	-	If multiple ad impressions are offered in the same bid request, the sequence number will allow for the coordinated delivery of multiple creatives.
battr	integer array	-	Blocked creative attributes.
maxextended	integer	-	Maximum extended video ad duration if extension is allowed. If blank or 0, extension is not allowed. If -1, extension is allowed, and there is no time limit imposed. If greater than 0, then the value represents the number of seconds of extended play supported beyond the maxduration value.
minbitrate	integer	-	Minimum bit rate in Kbps. Exchange may set this dynamically or universally across their set of publishers.
maxbitrate	integer	-	Maximum bit rate in Kbps. Exchange may set this dynamically or universally across their set of publishers.
boxingallowed	integer	1	Indicates if letter-boxing of 4:3 content into a 16:9 window is allowed, where 0 = no, 1 = yes.
playbackmethod	integer array	-	Allowed playback methods. If none specified, assume all are allowed.
delivery	integer array	-	Supported delivery methods (e.g., streaming, progressive). If none specified, assume all are supported.
pos	integer	-	Ad position on screen.
companionad	Object array	-	Array of Banner objects if companion ads are available.
api	integer array	-	List of supported API frameworks for this impression. If an API is not explicitly listed, it is assumed not to be supported.
companiontype	integer array	-	List of supported API frameworks for this impression. If an API is not explicitly listed, it is assumed not to be supported.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Native

Field Name	Type	Default	Description
request	string	-	Request payload complying with the Native Ad Specification.
ver	string	-	Version of the Native Ad Specification to which request complies; highly recommended for efficient parsing.
api	integer array	-	List of supported API frameworks for this impression. If an API is not explicitly listed, it is assumed not to be supported.
battr	Integer array	-	Blocked creative attributes.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Site

Field Name	Type	Default	Description
id	string	-	Exchange-specific site ID.
name	string	-	Site name (may be aliased at the publisher’s request).
domain	string	-	Domain of the site (e.g., “mysite.foo.com”).
cat	string array	-	Array of IAB content categories of the site.
sectioncat	string array	-	Array of IAB content categories that describe the current section of the site.
pagecat	string array	-	Array of IAB content categories that describe the current page or view of the site.
page	string	-	URL of the page where the impression will be shown.
ref	string	-	Referrer URL that caused navigation to the current page.
search	string	-	Search string that caused navigation to the current page.
mobile	integer	-	Mobile-optimized signal, where 0 = no, 1 = yes.
privacypolicy	integer	-	Indicates if the site has a privacy policy, where 0 = no, 1 = yes.
publisher	object	-	Details about the Publisher (Section 3.2.8) of the site.
content	object	-	Details about the Content (Section 3.2.9) within the site.
keywords	string	-	Comma separated list of keywords about the site.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

App

Field Name	Type	Default	Description
id	string	-	Exchange-specific app ID.
name	string	-	App name (may be aliased at the publisher’s request).
bundle	string	-	Application bundle or package name (e.g., com.foo.mygame); intended to be a unique ID across exchanges.
domain	string	-	Domain of the app (e.g., “mygame.foo.com”).
storeurl	string	-	App store URL for an installed app; for QAG 1.5 compliance.
cat	string array	-	Array of IAB content categories of the app.
sectioncat	string array	-	Array of IAB content categories that describe the current section of the app.
pagecat	string array	-	Array of IAB content categories that describe the current page or view of the app.
ver	string	-	Application version.
privacypolicy	integer	-	Indicates if the app has a privacy policy, where 0 = no, 1 = yes.
paid	integer	-	0 = app is free, 1 = the app is a paid version.
publisher	object	-	Details about the Publisher of the app.
content	object	-	Details about the Content within the app.
keywords	string	-	Comma separated list of keywords about the app.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Publisher

Field Name	Type	Default	Description
id	string	-	Exchange-specific publisher ID.
name	string	-	Publisher name (may be aliased at the publisher’s request).
cat	string array	-	Array of IAB content categories that describe the publisher.
domain	string	-	Highest level domain of the publisher (e.g., “publisher.com”).
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Content

Field Name	Type	Default	Description
id	string	-	ID uniquely identifying the content.
episode	integer	-	Episode number (typically applies to video content).
title	string	-	Content title. Video Examples: “Search Committee” (television), “A New Hope” (movie), or “Endgame” (made for web). Non-Video Example: “Why an Antarctic Glacier Is Melting So Quickly” (Time magazine article).
series	string	-	Content series. Video Examples: “The Office” (television), “Star Wars” (movie), or “Arby ‘N’ The Chief” (made for web). Non-Video Example: “Ecocentric” (Time Magazine blog).
season	string	-	Content season; typically for video content (e.g., “Season 3”).
producer	object	-	Details about the content Producer (Section 3.2.10).
url	string	-	URL of the content, for buy-side contextualization or review.
cat	string array	-	Array of IAB content categories that describe the content producer.
videoquality	integer	-	Video quality per IAB’s classification.
context	integer	-	Type of content (game, video, text, etc.).
contentrating	string	-	Content rating (e.g., MPAA).
userrating	string	-	User rating of the content (e.g., number of stars, likes, etc.).
qagmediarating	integer	-	Media rating per QAG guidelines.
keywords	string	-	Comma separated list of keywords describing the content.
livestream	integer	-	0 = not live, 1 = content is live (e.g., stream, live blog).
sourcerelationship	integer	-	0 = indirect, 1 = direct.
len	integer	-	Length of content in seconds; appropriate for video or audio.
language	string	-	Content language using ISO-639-1-alpha-2.
embeddable	integer	-	Indicator of whether or not the content is embeddable (e.g., an embeddable video player), where 0 = no, 1 = yes.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Producer

Field Name	Type	Default	Description
id	string	-	Content producer or originator ID. Useful if content is syndicated and may be posted on a site using embed tags.
name	string	-	Content producer or originator name (e.g., “Warner Bros”).
cat	string array	-	Array of IAB content categories that describe the content producer.
domain	string	-	Highest level domain of the content producer (e.g., “producer.com”).
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Device

Field Name	Type	Default	Description
ua	string	-	Browser user agent string.
geo	object	-	Location of the device assumed to be the user’s current location defined by a Geo object.
dnt	integer	-	Standard “Do Not Track” flag as set in the header by the browser, where 0 = tracking is unrestricted, 1 = do not track.
lmt	integer	-	“Limit Ad Tracking” signal commercially endorsed (e.g., iOS, Android), where 0 = tracking is unrestricted, 1 = tracking must be limited per commercial guidelines.
ip	string	-	IPv4 address closest to device.
ipv6	string	-	IP address closest to device as IPv6.
devicetype	integer	-	The general type of device. make string Device make (e.g., “Apple”).
model	string	-	Device model (e.g., “iPhone”).
os	string	-	Device operating system (e.g., “iOS”).
osv	string	-	Device operating system version (e.g., “3.1.2”).
hwv	string	-	Hardware version of the device (e.g., “5S” for iPhone 5S).
h	integer	-	Physical height of the screen in pixels.
w	integer	-	Physical width of the screen in pixels.
ppi	integer	-	Screen size as pixels per linear inch.
pxratio	float	-	The ratio of physical pixels to device independent pixels.
js	integer	-	Support for JavaScript, where 0 = no, 1 = yes.
flashver	string	-	Version of Flash supported by the browser.
language	string	-	Browser language using ISO-639-1-alpha-2.
carrier	string	noen	Carrier or ISP (e.g., “VERIZON”). “WIFI” is often used in mobile to indicate high bandwidth (e.g., video friendly vs. cellular).
connectiontype	integer	-	Network connection type.
ifa	string	-	ID sanctioned for advertiser use in the clear (i.e., not hashed).
didsha1	string	-	Hardware device ID (e.g., IMEI); hashed via SHA1.
didmd5	string	-	Hardware device ID (e.g., IMEI); hashed via MD5.
dpidsha1	string	-	Platform device ID (e.g., Android ID); hashed via SHA1.
dpidmd5	string	-	Platform device ID (e.g., Android ID); hashed via MD5.
macsha1	string	-	MAC address of the device; hashed via SHA1.
macmd5	string	-	MAC address of the device; hashed via MD5.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB

Geo

Field Name	Type	Default	Description
lat	float	-	Latitude from -90.0 to +90.0, where negative is south.
lon	float	-	Longitude from -180.0 to +180.0, where negative is west.
type	integer	-	Source of location data; recommended when passing lat/lon.
country	string	-	Country code using ISO-3166-1-alpha-3.
region	string	-	Region code using ISO-3166-2; 2-letter state code if USA.
regionfips104	string	-	Region of a country using FIPS 10-4 notation. While OpenRTB supports this attribute, it has been withdrawn by NIST in 2008.
metro	string	-	Google metro code; similar to but not exactly Nielsen DMAs.
city	string	-	City using United Nations Code for Trade & Transport Locations.
zip	string	-	Zip or postal code.
utcoffset	integer	-	Local time as the number +/- of minutes from UTC.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

User

Field Name	Type	Default	Description
id	string	-	Exchange-specific ID for the user. At least one of id or buyeruid is recommended.
buyeruid	string	-	Buyer-specific ID for the user as mapped by the exchange for the buyer. At least one of buyeruid or id is recommended.
yob	integer	-	Year of birth as a 4-digit integer.
gender	string	-	Gender, where “M” = male, “F” = female, “O” = known to be other (i.e., omitted is unknown).
keywords	string	-	Comma separated list of keywords, interests, or intent.
customdata	string	-	Optional feature to pass bidder data that was set in the exchange’s cookie. The string must be in base85 cookie safe characters and be in any format. Proper JSON encoding must be used to include “escaped” quotation marks.
geo	object	-	Location of the user’s home base defined by a Geo object. This is not necessarily their current location.
data	object array	-	Additional user data. Each Data object represents a different data source.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Data

Field Name	Type	Default	Description
id	string	-	Exchange-specific ID for the data provider.
name	string	-	Exchange-specific name for the data provider.
segment	object array	-	Array of Segment objects that contain the actual data values.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Segment

Field Name	Type	Default	Description
id	string	-	ID of the data segment specific to the data provider.
name	string	-	Name of the data segment specific to the data provider.
value	string	-	String representation of the data segment value.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Regs

Field Name	Type	Default	Description
coppa	integer	-	Flag indicating if this request is subject to the COPPA regulations established by the USA FTC, where 0 = no, 1 = yes.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Pmp

Field Name	Type	Default	Description
private_auction	integer	-	Indicator of auction eligibility to seats named in the Direct Deals object, where 0 = all bids are accepted, 1 = bids are restricted to the deals specified and the terms thereof.
deals	object array	-	Array of Deal objects that convey the specific deals applicable to this impression.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB.

Deal

Field Name	Type	Default	Description
id	string	-	A unique identifier for the direct deal.
bidfloor	float	0	Minimum bid for this impression expressed in CPM.
bidfloorcur	string	USD	Currency specified using ISO-4217 alpha codes. This may be different from bid currency returned by bidder if this is allowed by the exchange.
at	integer	-	Optional override of the overall auction type of the bid request, where 1 = First Price, 2 = Second Price Plus, 3 = the value passed in bidfloor is the agreed upon deal price. Additional auction types can be defined by the exchange.
wseat	string array	-	Whitelist of buyer seats allowed to bid on this deal. Seat IDs must be communicated between bidders and the exchange a priori. Omission implies no seat restrictions.
wadomain	string array	-	Array of advertiser domains (e.g., advertiser.com) allowed to bid on this deal. Omission implies no advertiser restrictions.
ext	object	-	Placeholder for exchange-specific extensions to OpenRTB

Native Ad Request Markup Details

Native Markup Request Object

Field Name	Scope	Type	Default	Description
ver	optional	string	1	Version of the Native Markup version in use.
layout	recommended	integer	-	The Layout ID of the native ad unit. See the table of Native Layout IDs below.
adunit	recommended	integer	-	The Ad unit ID of the native ad unit. See the Table of Native Ad Unit IDs below for a list of supported core ad units.
plcmtcnt	optional	integer	1	The number of identical placements in this Layout.
seq	optional	integer	0	0 for the first ad, 1 for the second ad, and so on. This is not the sequence number of the content in the stream.
assets	required	array of objects	-	An array of Asset Objects. Any bid must comply with the array of elements expressed by the Exchange.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Asset Object

Field Name	Scope	Type	Default	Description
id	required	integer	-	Unique asset ID, assigned by exchange. Typically a counter for the array.
required	optional	integer	0	Set to 1 if asset is required (exchange will not accept a bid without it)
title	optional	object	-	Title object for title assets.
img	optional	object	-	Image object for image assets.
video	optional	object	-	Video object for video assets. Note that in-stream video ads are not part of Native. Native ads may contain a video as the ad creative itself.
data	optional	object	-	Data object for ratings, prices etc.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Title Object

Field Name	Scope	Type	Default	Description
len	required	integer	-	Maximum length of the text in the title element.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification

Image Object

Field Name	Scope	Type	Default	Description
type	optional	integer	-	Type ID of the image element supported by the publisher. The publisher can display this information in an appropriate format.
w	optional	integer	-	Width of the image in pixels.
wmin	recommended	integer	-	The minimum requested width of the image in pixels. This option should be used for any rescaling of images by the client. Either w or wmin should be transmitted. If only w is included, it should be considered an exact requirement.
h	optional	integer	-	Height of the image in pixels.
hmin	recommended	integer	-	The minimum requested height of the image in pixels. This option should be used for any rescaling of images by the client. Either h or hmin should be transmitted. If only h is included, it should be considered an exact requirement.
mimes	optional	array of strings	All types allowed	Whitelist of content MIME types supported. Popular MIME types include, but are not limited to “image/jpg” “image/gif”. Each implementing Exchange should have their own list of supported types in the integration docs. See Wikipedia’s MIME page for more information and links to all IETF RFCs. If blank, assume all types are allowed.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Video Object

Field Name	Scope	Type	Default	Description
mimes	required	array of strings	-	Content MIME types supported. Popular MIME types include,but are not limited to “video/x-mswmv” for Windows Media, and “video/x-flv” for Flash Video.
minduration	required	integer	-	Minimum video ad duration in seconds.
maxduration	required	integer	-	Maximum video ad duration in seconds.
protocols	required	array of integers	-	An array of video protocols the publisher can accept in the bid response.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Data Object

Field Name	Scope	Type	Default	Description
type	required	integer	-	Type ID of the element supported by the publisher. The publisher can display this information in an appropriate format.
len	optional	integer	-	Maximum length of the text in the element’s response.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Tables 5.16 - 5.18

These tables contain additional information about location and device type

Location Type

Value	Description
1	GPS/Location Services
2	IP Address
3	User provided (e.g. registration data)

Device Type

Value	Description	Notes
1	Mobile/Tablet	Version 2.0
2	Personal Computer	Version 2.0
3	Connected TV	Version 2.0
4	Phone	New for Version 2.2
5	Tablet	New for Version 2.2
6	Connected Device	New for Version 2.2
7	Set Top Box	New for Version 2.2

Connection Type

Value	Description
0	Unknown
1	Ethernet
2	WIFI
3	Cellular Network – Unknown Generation
4	Cellular Network – 2G
5	Cellular Network – 3G
6	Cellular Network – 4G

Buy-Side Specifications

PowerLinks Media is fully compliant with the Open RTB 2.3 specifications and its Native subprotocol. Below you’ll find information regarding PowerLinks’s bid request/response specifications and expectations for buy-side partners.

Example Bid Request

Include an example bid request from a seller. Then include a table that shows what’s required in the bid request, and then also what they should expect (and what’s seller-specific). Always, expected + enhancements, SSP Specific (columns for table)

Supported Objects

Object Name	Supported	Required	Expected
Bid Response	Yes	id	seatbid, bidid, cur, customdata, nbr, ext
SeatBid	Yes	bid	seat, group, ext
Bid	Yes	id, impid, price	adid, nurl, adm, adomain, bundle, iurl, cid, crid, cat, attr, dealid, h, w, ext

BidResponse

Field Name	Type	Default	Description
id	string	-	ID of the bid request to which this is a response.
seatbid	object array	-	Array of seatbid objects; 1+ required if a bid is to be made.
bidid	string	-	Bidder generated response ID to assist with logging/tracking.
cur	string	USD	Bid currency using ISO-4217 alpha codes.
customdata	string	-	Optional feature to allow a bidder to set data in the exchange’s cookie. The string must be in base85 cookie safe characters and be in any format. Proper JSON encoding must be used to include “escaped” quotation marks.
nbr	integer	-	Reason for not bidding. Refer to List 5.19.
ext	object	-	Placeholder for bidder-specific extensions to OpenRTB.

SeatBid

Field Name	Type	Default	Description
bid	object array	-	Array of 1+ Bid objects (Section 4.2.3) each related to an impression. Multiple bids can relate to the same impression.
seat	string	-	ID of the bidder seat on whose behalf this bid is made.
group	integer	0	0 = impressions can be won individually; 1 = impressions must be won or lost as a group.
ext	object	-	Placeholder for bidder-specific extensions to OpenRTB.

Bid

Field Name	Type	Default	Description
id	string	-	Bidder generated bid ID to assist with logging/tracking.
impid	string	-	ID of the Imp object in the related bid request.
price	float	-	Bid price expressed as CPM although the actual transaction is for a unit impression only. Note that while the type indicates float, integer math is highly recommended when handling currencies (e.g., BigDecimal in Java).
adid	string	-	ID of a preloaded ad to be served if the bid wins.
nurl	string	-	Win notice URL called by the exchange if the bid wins; optional means of serving ad markup.
adm	string	-	Optional means of conveying ad markup in case the bid wins; supersedes the win notice if markup is included in both.
adomain	string array	-	Advertiser domain for block list checking (e.g., “ford.com”). This can be an array of for the case of rotating creatives. Exchanges can mandate that only one domain is allowed.
bundle	string	-	Bundle or package name (e.g., com.foo.mygame) of the app being advertised, if applicable; intended to be a unique ID across exchanges.
iurl	string	-	URL without cache-busting to an image that is representative of the content of the campaign for ad quality/safety checking.
cid	string	-	Campaign ID to assist with ad quality checking; the collection of creatives for which iurl should be representative.
crid	string	-	Creative ID to assist with ad quality checking.
cat	string array	-	IAB content categories of the creative. Refer to List 5.1.
attr	integer array	-	Set of attributes describing the creative. Refer to List 5.3.
dealid	string	-	Reference to the deal.id from the bid request if this bid pertains to a private marketplace direct deal.
h	integer	-	Height of the creative in pixels.
w	integer	-	Width of the creative in pixels.
ext	object	-	Placeholder for bidder-specific extensions to OpenRTB.

Native Ad Bid Response Markup

Native Ad Creative JSON

Field Name	Scope	Type	Default	Description
native	required	object	-	Top level Native object

Native

Field Name	Scope	Type	Default	Description
ver	optional	integer	1	Version of the Native Markup version in use.
assets	required	array of objects	-	List of native ad’s assets.
link	required	object	-	Destination Link. This is default link object for the ad. Individual assets can also have a link object which applies if the asset is activated (clicked). If the asset doesn’t have a link object, the parent link object applies.
imptrackers[]	optional	array of strings	-	Array of impression tracking URLs, expected to return a 1x1 image or 204 response - typically only passed when using 3rd party trackers.
jstracker	optional	string	-	Optional JavaScript impression tracker. This is a valid HTML, Javascript is already wrapped in <script> tags. It should be executed at impression time where it can be supported.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification

Asset

Field Name	Scope	Type	Default	Description
id	required	integer	-	Unique asset ID, assigned by exchange, must match one of the asset IDs in request
required	optional	integer	0	Set to 1 if asset is required. (bidder requires it to be displayed).
title	optional	object	-	Title object for title assets.
img	optional	object	-	Image object for image assets.
video	optional	object	-	Video object for video assets. Note that in-stream video ads are not part of Native. Native ads may contain a video as the ad creative itself.
data	optional	object	-	Data object for ratings, prices etc.
link	optional	object	-	Link object for call to actions. The link object applies if the asset item is activated (clicked). If there is no link object on the asset, the parent link object on the bid response applies.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Title

Field Name	Scope	Type	Default	Description
text	required	string	-	The text associated with the text element.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Image

Field Name	Scope	Type	Default	Description
url	required	string	-	URL of the image asset.
w	recommended	integer	-	Width of the image in pixels.
h	recommended	integer	-	Height of the image in pixels.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Data

Field Name	Scope	Type	Default	Description
label	optional	string	-	The optional formatted string name of the data type to be displayed.
value	required	string	-	The formatted string of data to be displayed. Can contain a formatted value such as “5 stars” or “$10” or “3.4 stars out of 5”
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Video

Field Name	Scope	Type	Default	Description
vasttag	required	string	-	VAST xml.

Link

Field Name	Scope	Type	Default	Description
url	required	string	-	Landing URL of the clickable link.
clicktrackers[]	optional	array of strings	-	List of third-party tracker URLs to be fired on click of the URL.
fallback	optional	string (URL)	-	Fallback URL for deeplink. To be used if the URL given in url is not supported by the device.
ext	optional	object	-	This object is a placeholder that may contain custom JSON agreed to by the parties to support flexibility beyond the standard defined in this specification.

Creative Specs

Please find specifications by creative type below.

Search/Content

Asset	Requirements	Scope
Image - Rectangle	1.45 : 1 ratio, 1020 x 700 pixels or larger	Required
Image - Square	1 : 1 ratio, 600 x 600 pixels or larger	Required
Image - Logo	1 : 1 ratio, 100 x 100 pixels or larger	Required
Title (Long)	Min. 10 characters Max. 70 characters	Required
Title (Short)	Min. 10 characters Max. 25 characters	Required
Description (Long)	Max. 140 characters	Optional
Description (Short)	Max. 60 characters	Optional
Brand Name	Max. 30 characters	Required
Display URL	Max. 20 characters	Optional
Call to Action Text	Max. 15 characters	Optional
Click (Tracking) URL	Unlimited	Required
Impression Tracking Pixel	Unlimited	Optional
Javascript Impression Tracker	Unlimited	Optional

App Download

Asset	Requirements	Scope
Image - Rectangle	1.45 : 1 ratio, 1020 x 700 pixels or larger	Required
Image - Square	1 : 1 ratio, 600 x 600 pixels or larger	Required
Image - Logo	1 : 1 ratio, 100 x 100 pixels or larger	Required
Title (Long)	Min. 10 characters Max. 70 characters	Required
Title (Short)	Min. 10 characters Max. 25 characters	Required
Description (Long)	Max. 140 characters	Optional
Description (Short)	Max. 60 characters	Optional
Brand Name	Max. 30 characters	Required
Display URL	Max. 20 characters	Optional
Call to Action Text	Max. 15 characters	Optional
Click (Tracking) URL	Unlimited	Required
Impression Tracking Pixel	Unlimited	Optional
Javascript Impression Tracker	Unlimited	Optional

E-Commerce

Asset	Requirements	Scope
Image - Rectangle	1.45 : 1 ratio, 1020 x 700 pixels or larger	Required
Image - Square	1 : 1 ratio, 600 x 600 pixels or larger	Required
Image - Logo	1 : 1 ratio, 100 x 100 pixels or larger	Required
Title (Long)	Min. 10 characters Max. 70 characters	Required
Title (Short)	Min. 10 characters Max. 25 characters	Required
Description (Long)	Max. 140 characters	Optional
Description (Short)	Max. 60 characters	Optional
Brand Name	Max. 30 characters	Required
Display URL	Max. 20 characters	Optional
Call to Action Text	Max. 15 characters	Optional
Click (Tracking) URL	Unlimited	Required
Impression Tracking Pixel	Unlimited	Optional
Javascript Impression Tracker	Unlimited	Optional

Non-Standard Native API

The PowerLinks Non-Standard Native Api describes how your application can interact directly with the PowerLinks system to conduct a real-time query of Native content.

The PowerLinks Non-Standard Native API can be accessed either from a server, or from a browser. The response can be formatted as either XML or JSON, with XML being the default. In the case of accessing from a browser, both CORS and JSONP are supported. If a callback parameter is present, JSONP is assumed and the response will be wrapped in the callback parameter, formatted as JSON.

For more information, please consider the following resources:

XML: http://www.w3.org/XML/

JSON: http://wwww.json.org/

JSONP: http://json-p.org/

CORS: https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS

All currencies are in USD and all dates and times are relative to UTC.

Request

Overview

All requests made to the PowerLinks System should be done through a single entry point which supports a number of options to allow for the response to be made more contextual. The table below describes these.

Parameter	Type	Required	Description
a	string	Yes	Your PowerLinks account ID
ip	string	Yes	IP (v.4) address of the end user, or the string ‘false’. NOTE: If this is a server-side implementation, please include the IPv4 address. If this is a client-side implementation, please provide a string value of ‘false’ for this parameter. This will tell us that we should be detecting the IP from the request headers.
ua	string	Yes	User agent of the end user
r	string	Yes	URL-encoded HTTP referring URL
au	string	Yes	Native Ad Unit ID. Please find a list of Open RTB Native Ad Unit IDs below.
c	string	No	The Category IDs of the site on which the ad will display, separated by comma. Please find a list of Top Level Categories below. For a more granular list, please ask your PowerLinks account manager.
uid	string	No	User ID
pc	string	No	Placement count. The number of identical placements. This translates to a maximum number of possible ads in the response. Default is 1.
fl	float	No	Floor price, e.g. ’0.01’. Currency is USD.
s	enum (0,1)	No	1 indicates this impression is for a secure page, 0 indicates insecure.
t	enum (0,1)	No	This indicates that the impression supports a Title. 1 means a Title is required in the response, 0 means a Title is optional.
d	enum (0,1)	No	This indicates that the impression supports a Description. 1 means a Description is required in the response, 0 means a Description is optional.
sp	enum (0,1)	No	This indicates that the impression supports a Sponsor or Brand Name. 1 means a Sponsor or Brand Name is required in the response, 0 means a Sponsor or Brand Name is optional.
du	enum (0,1)	No	This indicates that the impression supports a Display URL. 1 means a Display URL is required in the response, 0 means a Display URL is optional.
cta	enum (0,1)	No	This indicates that the impression supports a CTA Text. 1 means a CTA Text is required in the response, 0 means a CTA Text is optional.
tl	integer	No	If a Title is requested, this denotes a maximum character length of the Title text.
dl	integer	No	If a Description is requested, this denotes a maximum character length of the Description text.
spl	integer	No	If a Sponsor or Brand Name is requested, this denotes a maximum character length of the Sponsor or Brand Name text.
dul	integer	No	If a Display URL is requested, this denotes a maximum character length of the Display URL text.
ctal	integer	No	If a CTA Text is requested, this denotes a maximum character length of the CTA Text text.
m	enum (0,1)	No	This indicates that the impression supports a Main Image. 1 means a Main Image is required in the response, 0 means a Main Image is optional.
l	enum (0,1)	No	This indicates that the impression supports a Logo Image. 1 means a Logo Image is required in the response, 0 means a Logo Image is optional.
mw	integer	No	If a Main Image is requested, this denotes the exact desired width of the Main Image.
mh	integer	No	If a Main Image is requested, this denotes the exact desired height of the Main Image.
mmw	integer	No	If a Main Image is requested, this denotes the minimum desired width of the Main Image.
mmh	integer	No	If a Main Image is requested, this denotes the minimum desired height of the Main Image.
lw	integer	No	If a Logo Image is requested, this denotes the exact desired width of the Logo Image.
lh	integer	No	If a Logo Image is requested, this denotes the exact desired height of the Logo Image.
lmw	integer	No	If a Logo Image is requested, this denotes the minimum desired width of the Logo Image.
lmh	integer	No	If a Logo Image is requested, this denotes the minimum desired height of the Logo Image.
subid	string	No	An ID specified by you for extended identification in reporting.
df	string	No	The desired response format, XML, JSON, or JSONP. Default is XML.
callback	string	No	This is strictly for JSONP support. If this parameter is included, the response will be wrapped in the callback, and the format will be JSON, overriding the ‘df’ parameter if present.

Making the request

All requests should be made using the following method

Range Options

GET http://serve.powerlinks.com/rtb/native

Parameters

See above table

Example Request

GET

http://serve.powerlinks.com/rtb/native?a=1&c=IAB1,IAB2&ip=192.168.0.1&ua=Mozilla%2F5.0%20(Windows%20NT%206.3%3B%20WOW64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F39.0.2171.95%20Safari%2F537.36&r=http%3A%2F%2Fwww.examplepage.com%2Fsomepage&au=2&uid=uuid1234567890&pc=1&fl=.2&s=1&t=1&tl=100&d=0&dl=150&m=1&mw=300&mh=300&subid=1234567890&df=json

Native Ad Unit IDs

Ad Unit ID	Description
1	Paid Search Units
2	Recommendation Widgets
3	Promoted Listings
4	In-Ad (IAB Standard) with Native Element Units
5	Custom / “Can’t be Contained”

Content Categories

IAB Category	Description
IAB1	Arts & Entertainment
IAB2	Automotive
IAB3	Business
IAB4	Careers
IAB5	Education
IAB6	Family & Parenting
IAB7	Health & Fitness
IAB8	Food & Drink
IAB9	Hobbies & Interests
IAB10	Home & Garden
IAB11	Law, Government, & Politics
IAB12	News
IAB13	Personal Finance
IAB14	Society
IAB15	Science
IAB16	Pets
IAB17	Sports
IAB18	Style & Fashion
IAB19	Technology & Computing
IAB20	Travel
IAB21	Real Estate
IAB22	Shopping
IAB23	Religion & Sprituality

Response

Structure

If there are no bids, an HTTP Status Code of 204 (No-Content) will be returned with no body.

Successfuly bid responses are returned in the format specified in the request (or XML if not specified). The data returned in the response are described in the following tables:

Parameter	Type	Description
ad	object	The object containing the advert data in successful responses

Ad Object

Parameter	Type	Description
bid	float	The bid value
title	string	The ad’s title
description	string	The ad’s description
sponsored	string	The ad’s sponsor name
displayurl	string	The ad’s display URL
ctatext	string	The ad’s CTA text
main	string	The ad’s main image
logo	string	The ad’s logo image
link	string	The ad’s click through URL
imptrackers	object	An array of impression tracking pixels that must be fired on impression of the ad
clicktrackers	object	An array of click tracking pixels that should be fired on click of the ad

Example Responses: XML

    <?xml version="1.0" encoding="utf-8"?>
    <response>
        <ad>
            <bid>1.00</bid>
            <title>Ad Title</title>
            <description>Ad Description</description>
            <sponsored>Ad Sponsor</sponsor>
            <displayurl>adurl.com</displayurl>
            <ctatext>Read More!</ctatext>
            <main>
                <![CDATA[https://images.powerlinks.com/main.jpg]]>
            </main>
            <logo>
                <![CDATA[https://images.powerlinks.com/logo.jpg]]>
            </logo>
            <link><![CDATA[https://click.powerlinks.com]]></link>
            <imptrackers>
                <item id="0">
                    <![CDATA[https://imptracker1.powerlinks.com]]>
                </item>
                <item id="1">
                    <![CDATA[https://imptracker2.powerlinks.com]]>
                </item>
            </imptrackers>
            <clicktrackers>
                <item id="0">
                    <![CDATA[https://clicktracker1.powerlinks.com]]>
                </item>
                <item id="1">
                    <![CDATA[https://clicktracker2.powerlinks.com]]>
                </item>
            </clicktrackers>
        </ad>
    </response>

Example Responses: JSON

{
    "ad": {
        "bid": "1.00",
        "title": "Ad Title",
        "description": "Ad Description",
        "sponsor": "Ad Sponsor",
        "displayurl": "adurl.com",
        "ctatext": "Read More!",
        "main": "https://images.powerlinks.com/main.jpg",
        "logo": "https://images.powerlinks.com/logo.jpg",
        "link": "https://click.powerlinks.com",
        "imptrackers": [
            "https://imptracker1.powerlinks.com",
            "https://imptracker2.powerlinks.com"
        ],
        "clicktrackers": [
            "https://clicktracker1.powerlinks.com",
            "https://clicktracker2.powerlinks.com"
        ]
    }
}

Example Responses: JSONP

jQuery123({
    "ad": {
        "bid": "1.00",
        "title": "Ad Title",
        "description": "Ad Description",
        "sponsor": "Ad Sponsor",
        "displayurl": "adurl.com",
        "ctatext": "Read More!",
        "main": "https://images.powerlinks.com/main.jpg",
        "logo": "https://images.powerlinks.com/logo.jpg",
        "link": "https://click.powerlinks.com",
        "imptrackers": [
            "https://imptracker1.powerlinks.com",
            "https://imptracker2.powerlinks.com"
        ],
        "clicktrackers": [
            "https://clicktracker1.powerlinks.com",
            "https://clicktracker2.powerlinks.com"
        ]
    }
})

Non-Standard Banner API

The PowerLinks Non-Standard Banner Api describes how your application can interact directly with the PowerLinks system to conduct a real-time query of Banner content.

The PowerLinks Non-Standard Banner API can be accessed either from a server, or from a browser. The response can be formatted as either XML or JSON, with XML being the default. In the case of accessing from a browser, both CORS and JSONP are supported. If a callback parameter is present, JSONP is assumed and the response will be wrapped in the callback parameter, formatted as JSON.

For more information, please consider the following resources:

XML: http://www.w3.org/XML/

JSON: http://wwww.json.org/

JSONP: http://json-p.org/

CORS: https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS

All currencies are in USD and all dates and times are relative to UTC.

Request

Overview

All requests made to the PowerLinks System should be done through a single entry point which supports a number of options to allow for the response to be made more contextual. The table below describes these.

Parameter	Type	Required	Description
a	string	Yes	Your PowerLinks account ID
ip	string	Yes	IP (v.4) address of the end user, or the string ‘false’. NOTE: If this is a server-side implementation, please include the IPv4 address. If this is a client-side implementation, please provide a string value of ‘false’ for this parameter. This will tell us that we should be detecting the IP from the request headers.
ua	string	Yes	User agent of the end user
r	string	Yes	URL-encoded HTTP referring URL
w	string	Yes	Exact width of the banner
h	string	Yes	Exact height of the banner
c	string	No	The Category IDs of the site on which the ad will display, separated by comma. Please find a list of Top Level Categories below. For a more granular list, please ask your PowerLinks account manager.
uid	string	No	User ID
fl	float	No	Floor price, e.g. ’0.01’. Currency is USD.
s	enum (0,1)	No	1 indicates this impression is for a secure page, 0 indicates insecure.
subid	string	No	An ID specified by you for extended identification in reporting.
df	string	No	The desired response format, XML, JSON, or JSONP. Default is XML.
callback	string	No	This is strictly for JSONP support. If this parameter is included, the response will be wrapped in the callback, and the format will be JSON, overriding the ‘df’ parameter if present.

Making the request

All requests should be made using the following method

Range Options

GET http://serve.powerlinks.com/rtb/banner

Parameters

See above table

Example Request

GET

http://serve.powerlinks.com/rtb/banner?a=1&c=IAB1,IAB2&ip=192.168.0.1&ua=Mozilla%2F5.0%20(Windows%20NT%206.3%3B%20WOW64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F39.0.2171.95%20Safari%2F537.36&r=http%3A%2F%2Fwww.examplepage.com%2Fsomepage&uid=uuid1234567890&fl=.2&s=1&w=300&h=250&subid=1234567890&df=json

Content Categories

IAB Category	Description
IAB1	Arts & Entertainment
IAB2	Automotive
IAB3	Business
IAB4	Careers
IAB5	Education
IAB6	Family & Parenting
IAB7	Health & Fitness
IAB8	Food & Drink
IAB9	Hobbies & Interests
IAB10	Home & Garden
IAB11	Law, Government, & Politics
IAB12	News
IAB13	Personal Finance
IAB14	Society
IAB15	Science
IAB16	Pets
IAB17	Sports
IAB18	Style & Fashion
IAB19	Technology & Computing
IAB20	Travel
IAB21	Real Estate
IAB22	Shopping
IAB23	Religion & Sprituality

Response

Structure

If there are no bids, an HTTP Status Code of 204 (No-Content) will be returned with no body.

Successfuly bid responses are returned in the format specified in the request (or XML if not specified). The data returned in the response are described in the following tables:

Parameter	Type	Description
ad	object	The object containing the advert data in successful responses

Ad Object

Parameter	Type	Description
bid	float	The bid value
adm	string	The ad’s markup as XHTML
width	string	The ad’s width
height	string	The ad’s height

Example Responses: XML

    <?xml version="1.0" encoding="utf-8"?>
    <response>
        <ad>
            <bid>1.00</bid>
            <width>300</width>
            <height>250</height>
            <adm>
                <![CDATA[<div>Ad Content</div>
            ]]>
            </adm>
        </ad>
    </response>

Example Responses: JSON

{
    "ad": {
        "bid": 1.00,
        "width": 300,
        "height": 250,
        "adm": "<div>Ad Content</div>"
    }
}

Example Responses: JSONP

jQuery123({
    "ad": {
        "bid": 1.00,
        "width": 300,
        "height": 250,
        "adm": "<div>Ad Content</div>"
    }
})

Dashboard API

API for the dashboard v3

API overview

• Current Version
• HTTP Verbs
• Cross Origin Resource Sharing
• Endpoints
• ApiKey
• Response

HTTP Verbs

The Powerlinks Dashboard API strives to use appropriate HTTP verbs to perform actions on our resources.

verb	description
GET	use to retrieve a resources or collection
POST	use to create a resource or perform a custom action
PUT	use to store an entity under a specific resource
PATCH	use to update an entity or specific resource
DELETE	delete an entity or specific resource

Cross Origin Resource Sharing

We support cross origin resource sharing (CORS). All endpoints return the following header.

Access-Control-Allow-Origin: * Access-Control-Allow-Methods: GET,POST,OPTIONS,PUT,PATCH,DELETE Access-Control-Allow-Headers: ApiKey,Content-Type,Keep-Alive,User-Agent,Cache-Control

Authentication

• API Key
  • Parameter Name: apiKey, in: header.

Unless otherwise stated, authentication is require.

Resource Hierarchy

Buyside

Agency (Optional) -> Advertiser -> Order -> Line Item -> Creative

Endpoints

POST /users/login

Code samples

# You can also use wget
curl -X post //users/login \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //users/login HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/login',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "email": "string",
  "password": "string",
  "company": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//users/login',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//users/login', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/login");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "email": "string",
  "password": "string",
  "company": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» email	body	string	true	length 3-255
» password	body	string	true	length 6-32
» company	body	string	false	length 36-36

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
512	Unknown	Fail	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
apiKey	string	false	No description
expires	integer	false	No description

Response Schema

Status Code 512

Name	Type	Required	Description
message	string	false	No description
status	string	false	No description

POST /users/reset-password

Code samples

# You can also use wget
curl -X post //users/reset-password \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //users/reset-password HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/reset-password',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "email": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/reset-password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//users/reset-password',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//users/reset-password', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/reset-password");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "email": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» email	body	string	true	length 3-255

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
512	Unknown	Fail	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 512

Name	Type	Required	Description
message	string	false	No description
status	string	false	No description

POST /users/update-password

Code samples

# You can also use wget
curl -X post //users/update-password \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //users/update-password HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/update-password',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "token": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/update-password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//users/update-password',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//users/update-password', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/update-password");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "token": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» token	body	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
512	Unknown	Fail	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 512

Name	Type	Required	Description
message	string	false	No description
status	string	false	No description

POST /users/switch-company

Code samples

# You can also use wget
curl -X post //users/switch-company \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //users/switch-company HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/switch-company',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "company": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/switch-company',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//users/switch-company',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//users/switch-company', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/switch-company");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "company": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» company	body	string	false	length 36-36

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
512	Unknown	Fail	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 512

Name	Type	Required	Description
message	string	false	No description
status	string	false	No description

GET /users

Code samples

# You can also use wget
curl -X get //users \
  -H 'Accept: */*'

GET //users HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /users

Code samples

# You can also use wget
curl -X post //users \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //users HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//users', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» email	body	string	true	length 3-255
» password	body	string	true	length 6-32
» firstName	body	string	true	length 1-255
» lastName	body	string	true	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» role	body	integer	true	No description
» advertisers	body	[integer]	false	No description
» agencies	body	[integer]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /users/{id}

Code samples

# You can also use wget
curl -X get //users/{id} \
  -H 'Accept: */*'

GET //users/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /users/{id}

Code samples

# You can also use wget
curl -X patch //users/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //users/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//users/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//users/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description
body	body	Body	true	No description
» email	body	string	false	length 3-255
» password	body	string	false	length 6-32
» firstName	body	string	false	length 1-255
» lastName	body	string	false	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» role	body	integer	false	No description
» advertisers	body	[integer]	false	No description
» agencies	body	[integer]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /users/current

Code samples

# You can also use wget
curl -X get //users/current \
  -H 'Accept: */*'

GET //users/current HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/current',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/current',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/current',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/current', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/current");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

PATCH /users/current

Code samples

# You can also use wget
curl -X patch //users/current \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //users/current HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/current',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/current',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//users/current',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//users/current', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/current");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "email": "string",
  "password": "string",
  "firstName": "string",
  "lastName": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "role": 1,
  "advertisers": [
    1
  ],
  "agencies": [
    1
  ]
}

Parameters

Parameter	In	Type	Required	Description
body	body	Body	true	No description
» email	body	string	false	length 3-255
» password	body	string	false	length 6-32
» firstName	body	string	false	length 1-255
» lastName	body	string	false	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» role	body	integer	false	No description
» advertisers	body	[integer]	false	No description
» agencies	body	[integer]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /agencies/{agencyId}/users

Code samples

# You can also use wget
curl -X get //agencies/{agencyId}/users \
  -H 'Accept: */*'

GET //agencies/{agencyId}/users HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/{agencyId}/users',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies/{agencyId}/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//agencies/{agencyId}/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//agencies/{agencyId}/users', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/{agencyId}/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
agencyId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /advertisers/{advertiserId}/users

Code samples

# You can also use wget
curl -X get //advertisers/{advertiserId}/users \
  -H 'Accept: */*'

GET //advertisers/{advertiserId}/users HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{advertiserId}/users',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{advertiserId}/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/{advertiserId}/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/{advertiserId}/users', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{advertiserId}/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
advertiserId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /companies/{companyId}/users

Code samples

# You can also use wget
curl -X get //companies/{companyId}/users \
  -H 'Accept: */*'

GET //companies/{companyId}/users HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//companies/{companyId}/users',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//companies/{companyId}/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//companies/{companyId}/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//companies/{companyId}/users', params={

}, headers = headers)

print r.json()

URL obj = new URL("//companies/{companyId}/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
companyId	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /users/details

Code samples

# You can also use wget
curl -X get //users/details \
  -H 'Accept: */*'

GET //users/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /companies

Code samples

# You can also use wget
curl -X get //companies \
  -H 'Accept: */*'

GET //companies HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//companies',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//companies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//companies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//companies', params={

}, headers = headers)

print r.json()

URL obj = new URL("//companies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /companies/{id}

Code samples

# You can also use wget
curl -X get //companies/{id} \
  -H 'Accept: */*'

GET //companies/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//companies/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//companies/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//companies/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//companies/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//companies/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /users/{id}/companies

Code samples

# You can also use wget
curl -X get //users/{id}/companies \
  -H 'Accept: */*'

GET //users/{id}/companies HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}/companies',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/{id}/companies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/{id}/companies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/{id}/companies', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}/companies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /roles

Code samples

# You can also use wget
curl -X get //roles \
  -H 'Accept: */*'

GET //roles HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//roles',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//roles',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//roles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//roles', params={

}, headers = headers)

print r.json()

URL obj = new URL("//roles");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /users/{id}/role

Code samples

# You can also use wget
curl -X get //users/{id}/role \
  -H 'Accept: */*'

GET //users/{id}/role HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}/role',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/{id}/role',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/{id}/role',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/{id}/role', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}/role");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /users/roles

Code samples

# You can also use wget
curl -X get //users/roles \
  -H 'Accept: */*'

GET //users/roles HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/roles',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/roles',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/roles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/roles', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/roles");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /companies/{companyId}/users/{userId}/roles

Code samples

# You can also use wget
curl -X get //companies/{companyId}/users/{userId}/roles \
  -H 'Accept: */*'

GET //companies/{companyId}/users/{userId}/roles HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//companies/{companyId}/users/{userId}/roles',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//companies/{companyId}/users/{userId}/roles',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//companies/{companyId}/users/{userId}/roles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//companies/{companyId}/users/{userId}/roles', params={

}, headers = headers)

print r.json()

URL obj = new URL("//companies/{companyId}/users/{userId}/roles");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
companyId	path	string	true	No description
userId	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /users/{userId}/add-role

Code samples

# You can also use wget
curl -X patch //users/{userId}/add-role \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //users/{userId}/add-role HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{userId}/add-role',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "company": "string",
  "role": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/{userId}/add-role',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//users/{userId}/add-role',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//users/{userId}/add-role', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{userId}/add-role");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "company": "string",
  "role": 1
}

Parameters

Parameter	In	Type	Required	Description
userId	path	string	true	No description
body	body	Body2	true	No description
» company	body	string	true	length 36-36
» role	body	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

PATCH /users/{userId}/remove-role

Code samples

# You can also use wget
curl -X patch //users/{userId}/remove-role \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //users/{userId}/remove-role HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{userId}/remove-role',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "company": "string",
  "role": 1
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//users/{userId}/remove-role',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//users/{userId}/remove-role',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//users/{userId}/remove-role', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{userId}/remove-role");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "company": "string",
  "role": 1
}

Parameters

Parameter	In	Type	Required	Description
userId	path	string	true	No description
body	body	Body2	true	No description
» company	body	string	true	length 36-36
» role	body	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /orders

Code samples

# You can also use wget
curl -X get //orders \
  -H 'Accept: */*'

GET //orders HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//orders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//orders', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /orders

Code samples

# You can also use wget
curl -X post //orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //orders HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//orders',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//orders',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//orders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//orders', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» internalId	body	string	false	length 1-255
» advertiser	body	integer	true	No description
» startDate	body	string(date)	true	No description
» endDate	body	string(date)	false	No description
» budget	body	number(float)	true	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» dailyImpressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» billingType	body	integer	false	No description
» billingCategory	body	integer	false	No description
» feeType	body	integer	false	No description
» feeAmount	body	number(float)	false	No description
» isActive	body	boolean	true	No description
» isArchived	body	boolean	false	No description
» conversionTrackers	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» billingType	1
» billingType	2
» billingType	3
» billingType	4
» billingCategory	1
» billingCategory	2
» feeType	1
» feeType	2
» feeType	3
» feeType	4

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /orders/{id}

Code samples

# You can also use wget
curl -X get //orders/{id} \
  -H 'Accept: */*'

GET //orders/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//orders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//orders/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /orders/{id}

Code samples

# You can also use wget
curl -X patch //orders/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //orders/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//orders/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//orders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//orders/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» internalId	body	string	false	length 1-255
» advertiser	body	integer	false	No description
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» budget	body	number(float)	false	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» dailyImpressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» billingType	body	integer	false	No description
» billingCategory	body	integer	false	No description
» feeType	body	integer	false	No description
» feeAmount	body	number(float)	false	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description
» conversionTrackers	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» billingType	1
» billingType	2
» billingType	3
» billingType	4
» billingCategory	1
» billingCategory	2
» feeType	1
» feeType	2
» feeType	3
» feeType	4

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /orders/{id}

Code samples

# You can also use wget
curl -X delete //orders/{id} \
  -H 'Accept: */*'

DELETE //orders/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//orders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//orders/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /advertisers/{advertiserId}/orders

Code samples

# You can also use wget
curl -X get //advertisers/{advertiserId}/orders \
  -H 'Accept: */*'

GET //advertisers/{advertiserId}/orders HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{advertiserId}/orders',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{advertiserId}/orders',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/{advertiserId}/orders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/{advertiserId}/orders', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{advertiserId}/orders");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
advertiserId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

POST /orders/{id}/clone

Code samples

# You can also use wget
curl -X post //orders/{id}/clone \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //orders/{id}/clone HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{id}/clone',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//orders/{id}/clone',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//orders/{id}/clone',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//orders/{id}/clone', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{id}/clone");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "internalId": "string",
  "advertiser": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "dailyImpressionCap": 1,
  "pacing": 1,
  "billingType": 1,
  "billingCategory": 1,
  "feeType": 1,
  "feeAmount": 1,
  "conversionTrackers": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	false	No description
» name	body	string	false	length 1-255
» internalId	body	string	false	length 1-255
» advertiser	body	integer	false	No description
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» budget	body	number(float)	false	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» dailyImpressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» billingType	body	integer	false	No description
» billingCategory	body	integer	false	No description
» feeType	body	integer	false	No description
» feeAmount	body	number(float)	false	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description
» conversionTrackers	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» billingType	1
» billingType	2
» billingType	3
» billingType	4
» billingCategory	1
» billingCategory	2
» feeType	1
» feeType	2
» feeType	3
» feeType	4

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /orders/details

Code samples

# You can also use wget
curl -X get //orders/details \
  -H 'Accept: */*'

GET //orders/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//orders/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//orders/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /line-items

Code samples

# You can also use wget
curl -X get //line-items \
  -H 'Accept: */*'

GET //line-items HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//line-items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//line-items', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /line-items

Code samples

# You can also use wget
curl -X post //line-items \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //line-items HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//line-items',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//line-items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//line-items', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» order	body	integer	true	No description
» internalId	body	string	false	length 1-255
» name	body	string	true	length 1-255
» budget	body	number(float)	true	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» frequencyCaps	body	object	false	No description
»» imps	body	integer	true	No description
»» duration	body	integer	true	No description
» defaultBid	body	number(float)	true	No description
» maxBid	body	number(float)	false	No description
» cpcBid	body	number(float)	false	No description
» optimisation	body	integer	false	No description
» startDate	body	string(date)	true	No description
» endDate	body	string(date)	false	No description
» targeting	body	object	false	No description
»» 1	body	object	false	Ad Unit IDs for targeting
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 2	body	object	false	IAB categories from OpenRTB
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 3	body	object	false	No description
»»» verb	body	string	true	No description
»» 4	body	object	false	No description
»»» verb	body	string	true	No description
»» 5	body	object	false	ISO 3166-1 alpha-3
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 6	body	object	false	City using United Nations Code for Trade & Transport Locations
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 7	body	object	false	Region code using ISO-3166-2; 2-letter state code if USA
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 8	body	object	false	Based on Google’s metro codes, which are similar to Nielsen DMAs
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 9	body	object	false	ZIP
»»» values	body	[string]	false	No description
»» 10	body	object	false	IP address list
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 11	body	object	false	IP address range list
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	string	false	No description
»»»» end	body	string	false	No description
»» 12	body	object	false	Domain lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 13	body	object	false	Deal ID in the format / forexample if the deal_id is foo_bar and it is from inventory_source adx, the deal_id is adx/foo_bar
»»» values	body	[string]	false	No description
»» 14	body	object	false	1 = web, 2 = in-app
»»» values	body	[integer]	false	No description
»» 15	body	object	false	List of SSPs
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 16	body	object	false	Site names in form /
»»» values	body	[string]	false	No description
»» 17	body	object	false	AppBundle lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 18	body	object	false	AppID lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 19	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 20	body	object	false	Device type id as described in OpenRTB section 6.16
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 21	body	object	false	Device make
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 22	body	object	false	Device model as a string, including version number, note OpenRTB keeps the model and the version as separate fields
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 23	body	object	false	Specific OS such as Windows
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 24	body	object	false	Specific OS version such as Windows 7 in the format /
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 25	body	object	false	Browser name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 26	body	object	false	List of mobile carriers by name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 27	body	object	false	Browser Language
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 28	body	object	false	No description
»»» verb	body	string	true	No description
»» 29	body	object	false	Segment keys
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 30	body	object	false	No description
»» 31	body	object	false	Count in minutes from Sunday at midnight (0) to Saturday at 11:59 (10079) in range format [,], Calculation is against EST
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	integer	false	No description
»»»» end	body	integer	false	No description
»» 33	body	object	false	No description
»» 34	body	object	false	No description
»» 35	body	object	false	IAS segments
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 36	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 37	body	object	false	Banner size
»»» values	body	[string]	false	No description
» isActive	body	boolean	true	No description
» isArchived	body	boolean	false	No description
» creatives	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» optimisation	1
» optimisation	2
» optimisation	3
» optimisation	4
» optimisation	5
» optimisation	6
» optimisation	7
» optimisation	8
» optimisation	9
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	I
»»» verb	I
»»» values	1
»»» values	2
»»» values	3
»»» values	4
»»» values	5
»»» values	6
»»» values	7

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /line-items/{id}

Code samples

# You can also use wget
curl -X get //line-items/{id} \
  -H 'Accept: */*'

GET //line-items/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//line-items/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//line-items/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /line-items/{id}

Code samples

# You can also use wget
curl -X patch //line-items/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //line-items/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//line-items/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//line-items/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//line-items/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» order	body	integer	false	No description
» internalId	body	string	false	length 1-255
» name	body	string	false	length 1-255
» budget	body	number(float)	false	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» frequencyCaps	body	object	false	No description
»» imps	body	integer	true	No description
»» duration	body	integer	true	No description
» defaultBid	body	number(float)	false	No description
» maxBid	body	number(float)	false	No description
» cpcBid	body	number(float)	false	No description
» optimisation	body	integer	false	No description
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» targeting	body	object	false	No description
»» 1	body	object	false	Ad Unit IDs for targeting
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 2	body	object	false	IAB categories from OpenRTB
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 3	body	object	false	No description
»»» verb	body	string	true	No description
»» 4	body	object	false	No description
»»» verb	body	string	true	No description
»» 5	body	object	false	ISO 3166-1 alpha-3
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 6	body	object	false	City using United Nations Code for Trade & Transport Locations
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 7	body	object	false	Region code using ISO-3166-2; 2-letter state code if USA
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 8	body	object	false	Based on Google’s metro codes, which are similar to Nielsen DMAs
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 9	body	object	false	ZIP
»»» values	body	[string]	false	No description
»» 10	body	object	false	IP address list
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 11	body	object	false	IP address range list
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	string	false	No description
»»»» end	body	string	false	No description
»» 12	body	object	false	Domain lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 13	body	object	false	Deal ID in the format / forexample if the deal_id is foo_bar and it is from inventory_source adx, the deal_id is adx/foo_bar
»»» values	body	[string]	false	No description
»» 14	body	object	false	1 = web, 2 = in-app
»»» values	body	[integer]	false	No description
»» 15	body	object	false	List of SSPs
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 16	body	object	false	Site names in form /
»»» values	body	[string]	false	No description
»» 17	body	object	false	AppBundle lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 18	body	object	false	AppID lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 19	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 20	body	object	false	Device type id as described in OpenRTB section 6.16
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 21	body	object	false	Device make
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 22	body	object	false	Device model as a string, including version number, note OpenRTB keeps the model and the version as separate fields
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 23	body	object	false	Specific OS such as Windows
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 24	body	object	false	Specific OS version such as Windows 7 in the format /
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 25	body	object	false	Browser name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 26	body	object	false	List of mobile carriers by name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 27	body	object	false	Browser Language
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 28	body	object	false	No description
»»» verb	body	string	true	No description
»» 29	body	object	false	Segment keys
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 30	body	object	false	No description
»» 31	body	object	false	Count in minutes from Sunday at midnight (0) to Saturday at 11:59 (10079) in range format [,], Calculation is against EST
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	integer	false	No description
»»»» end	body	integer	false	No description
»» 33	body	object	false	No description
»» 34	body	object	false	No description
»» 35	body	object	false	IAS segments
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 36	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 37	body	object	false	Banner size
»»» values	body	[string]	false	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description
» creatives	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» optimisation	1
» optimisation	2
» optimisation	3
» optimisation	4
» optimisation	5
» optimisation	6
» optimisation	7
» optimisation	8
» optimisation	9
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	I
»»» verb	I
»»» values	1
»»» values	2
»»» values	3
»»» values	4
»»» values	5
»»» values	6
»»» values	7

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /line-items/{id}

Code samples

# You can also use wget
curl -X delete //line-items/{id} \
  -H 'Accept: */*'

DELETE //line-items/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//line-items/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//line-items/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /orders/{campaignId}/line-items

Code samples

# You can also use wget
curl -X get //orders/{campaignId}/line-items \
  -H 'Accept: */*'

GET //orders/{campaignId}/line-items HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{campaignId}/line-items',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders/{campaignId}/line-items',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//orders/{campaignId}/line-items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//orders/{campaignId}/line-items', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{campaignId}/line-items");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
campaignId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

POST /line-items/{id}/clone

Code samples

# You can also use wget
curl -X post //line-items/{id}/clone \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //line-items/{id}/clone HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{id}/clone',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//line-items/{id}/clone',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//line-items/{id}/clone',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//line-items/{id}/clone', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{id}/clone");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "order": 1,
  "internalId": "string",
  "name": "string",
  "budget": 1,
  "dailyBudget": 1,
  "impressionCap": 1,
  "pacing": 1,
  "frequencyCaps": {
    "imps": 1,
    "duration": 1
  },
  "defaultBid": 1,
  "maxBid": 1,
  "cpcBid": 1,
  "optimisation": 1,
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "targeting": {
    "1": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "2": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "3": {
      "verb": "E",
      "values": []
    },
    "4": {
      "verb": "E",
      "values": []
    },
    "5": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "6": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "7": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "8": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "9": {
      "values": [
        "string"
      ]
    },
    "10": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "11": {
      "verb": "ER",
      "values": {
        "start": "string",
        "end": "string"
      }
    },
    "12": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "13": {
      "values": [
        "string"
      ]
    },
    "14": {
      "values": [
        1
      ]
    },
    "15": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "16": {
      "values": [
        "string"
      ]
    },
    "17": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "18": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "19": {
      "verb": "I",
      "values": 1
    },
    "20": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "21": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "22": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "23": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "24": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "25": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "26": {
      "verb": "E",
      "values": [
        1
      ]
    },
    "27": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "28": {
      "verb": "E",
      "values": []
    },
    "29": {
      "verb": "E",
      "values": [
        "string"
      ]
    },
    "30": {
      "values": []
    },
    "31": {
      "verb": "ER",
      "values": {
        "start": 1,
        "end": 1
      }
    },
    "33": {},
    "34": {},
    "35": {
      "verb": "I",
      "values": [
        "string"
      ]
    },
    "36": {
      "verb": "I",
      "values": 1
    },
    "37": {
      "values": [
        "string"
      ]
    }
  },
  "creatives": [
    1
  ],
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	false	No description
» order	body	integer	false	No description
» internalId	body	string	false	length 1-255
» name	body	string	false	length 1-255
» budget	body	number(float)	false	No description
» dailyBudget	body	number(float)	false	No description
» impressionCap	body	integer	false	No description
» pacing	body	integer	false	No description
» frequencyCaps	body	object	false	No description
»» imps	body	integer	true	No description
»» duration	body	integer	true	No description
» defaultBid	body	number(float)	false	No description
» maxBid	body	number(float)	false	No description
» cpcBid	body	number(float)	false	No description
» optimisation	body	integer	false	No description
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» targeting	body	object	false	No description
»» 1	body	object	false	Ad Unit IDs for targeting
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 2	body	object	false	IAB categories from OpenRTB
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 3	body	object	false	No description
»»» verb	body	string	true	No description
»» 4	body	object	false	No description
»»» verb	body	string	true	No description
»» 5	body	object	false	ISO 3166-1 alpha-3
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 6	body	object	false	City using United Nations Code for Trade & Transport Locations
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 7	body	object	false	Region code using ISO-3166-2; 2-letter state code if USA
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 8	body	object	false	Based on Google’s metro codes, which are similar to Nielsen DMAs
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 9	body	object	false	ZIP
»»» values	body	[string]	false	No description
»» 10	body	object	false	IP address list
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 11	body	object	false	IP address range list
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	string	false	No description
»»»» end	body	string	false	No description
»» 12	body	object	false	Domain lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 13	body	object	false	Deal ID in the format / forexample if the deal_id is foo_bar and it is from inventory_source adx, the deal_id is adx/foo_bar
»»» values	body	[string]	false	No description
»» 14	body	object	false	1 = web, 2 = in-app
»»» values	body	[integer]	false	No description
»» 15	body	object	false	List of SSPs
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 16	body	object	false	Site names in form /
»»» values	body	[string]	false	No description
»» 17	body	object	false	AppBundle lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 18	body	object	false	AppID lists
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 19	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 20	body	object	false	Device type id as described in OpenRTB section 6.16
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 21	body	object	false	Device make
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 22	body	object	false	Device model as a string, including version number, note OpenRTB keeps the model and the version as separate fields
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 23	body	object	false	Specific OS such as Windows
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 24	body	object	false	Specific OS version such as Windows 7 in the format /
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 25	body	object	false	Browser name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 26	body	object	false	List of mobile carriers by name
»»» verb	body	string	true	No description
»»» values	body	[integer]	false	No description
»» 27	body	object	false	Browser Language
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 28	body	object	false	No description
»»» verb	body	string	true	No description
»» 29	body	object	false	Segment keys
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 30	body	object	false	No description
»» 31	body	object	false	Count in minutes from Sunday at midnight (0) to Saturday at 11:59 (10079) in range format [,], Calculation is against EST
»»» verb	body	string	true	No description
»»» values	body	object	true	No description
»»»» start	body	integer	false	No description
»»»» end	body	integer	false	No description
»» 33	body	object	false	No description
»» 34	body	object	false	No description
»» 35	body	object	false	IAS segments
»»» verb	body	string	true	No description
»»» values	body	[string]	false	No description
»» 36	body	object	false	No description
»»» verb	body	string	true	No description
»»» values	body	integer	true	No description
»» 37	body	object	false	Banner size
»»» values	body	[string]	false	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description
» creatives	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» pacing	1
» pacing	2
» optimisation	1
» optimisation	2
» optimisation	3
» optimisation	4
» optimisation	5
» optimisation	6
» optimisation	7
» optimisation	8
» optimisation	9
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	E
»»» verb	I
»»» verb	ER
»»» verb	IR
»»» verb	I
»»» verb	I
»»» values	1
»»» values	2
»»» values	3
»»» values	4
»»» values	5
»»» values	6
»»» values	7

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /line-items/details

Code samples

# You can also use wget
curl -X get //line-items/details \
  -H 'Accept: */*'

GET //line-items/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//line-items/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//line-items/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /line-items/{id}/targetings/{targetingId}

Code samples

# You can also use wget
curl -X get //line-items/{id}/targetings/{targetingId} \
  -H 'Accept: */*'

GET //line-items/{id}/targetings/{targetingId} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{id}/targetings/{targetingId}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items/{id}/targetings/{targetingId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//line-items/{id}/targetings/{targetingId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//line-items/{id}/targetings/{targetingId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{id}/targetings/{targetingId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
targetingId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /creatives

Code samples

# You can also use wget
curl -X get //creatives \
  -H 'Accept: */*'

GET //creatives HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//creatives',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//creatives',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//creatives', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /creatives

Code samples

# You can also use wget
curl -X post //creatives \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //creatives HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//creatives',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//creatives',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//creatives', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» advertiser	body	integer	true	No description
» name	body	string	true	length 1-255
» type	body	integer	true	No description
» link	body	object	false	No description
»» url	body	string	true	length 1-2000
»» fallbackUrl	body	string	false	length 1-2000
»» clickTrackers	body	[string]	false	No description
» impressionTrackers	body	object	false	No description
»» value	body	string	true	length 1-2000
»» type	body	integer	true	No description
» isArchived	body	boolean	false	No description
» dataAssets	body	object	false	No description
» imgAssets	body	object	true	No description
» categories	body	[string]	false	No description

Enumerated Values

Parameter	Value
»» type	1
»» type	2

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /creatives/{id}

Code samples

# You can also use wget
curl -X get //creatives/{id} \
  -H 'Accept: */*'

GET //creatives/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//creatives/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//creatives/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//creatives/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /creatives/{id}

Code samples

# You can also use wget
curl -X patch //creatives/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //creatives/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "advertiser": 1,
  "name": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//creatives/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//creatives/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//creatives/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "advertiser": 1,
  "name": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» advertiser	body	integer	false	No description
» name	body	string	false	length 1-255
» link	body	object	false	No description
»» url	body	string	true	length 1-2000
»» fallbackUrl	body	string	false	length 1-2000
»» clickTrackers	body	[string]	false	No description
» impressionTrackers	body	object	false	No description
»» value	body	string	true	length 1-2000
»» type	body	integer	true	No description
» isArchived	body	boolean	false	No description
» dataAssets	body	object	false	No description
» imgAssets	body	object	false	No description
» categories	body	[string]	false	No description

Enumerated Values

Parameter	Value
»» type	1
»» type	2

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /creatives/{id}

Code samples

# You can also use wget
curl -X delete //creatives/{id} \
  -H 'Accept: */*'

DELETE //creatives/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//creatives/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//creatives/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//creatives/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /line-items/{lineItemId}/creatives

Code samples

# You can also use wget
curl -X get //line-items/{lineItemId}/creatives \
  -H 'Accept: */*'

GET //line-items/{lineItemId}/creatives HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//line-items/{lineItemId}/creatives',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//line-items/{lineItemId}/creatives',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//line-items/{lineItemId}/creatives',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//line-items/{lineItemId}/creatives', params={

}, headers = headers)

print r.json()

URL obj = new URL("//line-items/{lineItemId}/creatives");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
lineItemId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /advertisers/{advertiserId}/creatives

Code samples

# You can also use wget
curl -X get //advertisers/{advertiserId}/creatives \
  -H 'Accept: */*'

GET //advertisers/{advertiserId}/creatives HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{advertiserId}/creatives',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{advertiserId}/creatives',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/{advertiserId}/creatives',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/{advertiserId}/creatives', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{advertiserId}/creatives");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
advertiserId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

POST /creatives/{id}/clone

Code samples

# You can also use wget
curl -X post //creatives/{id}/clone \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //creatives/{id}/clone HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives/{id}/clone',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//creatives/{id}/clone',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//creatives/{id}/clone',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//creatives/{id}/clone', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives/{id}/clone");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	false	No description
» advertiser	body	integer	false	No description
» name	body	string	false	length 1-255
» type	body	integer	false	No description
» link	body	object	false	No description
»» url	body	string	true	length 1-2000
»» fallbackUrl	body	string	false	length 1-2000
»» clickTrackers	body	[string]	false	No description
» impressionTrackers	body	object	false	No description
»» value	body	string	true	length 1-2000
»» type	body	integer	true	No description
» isArchived	body	boolean	false	No description
» dataAssets	body	object	false	No description
» imgAssets	body	object	false	No description
» categories	body	[string]	false	No description

Enumerated Values

Parameter	Value
»» type	1
»» type	2

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /creatives/details/{id}

Code samples

# You can also use wget
curl -X get //creatives/details/{id} \
  -H 'Accept: */*'

GET //creatives/details/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//creatives/details/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//creatives/details/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//creatives/details/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//creatives/details/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//creatives/details/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /conversion-trackers

Code samples

# You can also use wget
curl -X get //conversion-trackers \
  -H 'Accept: */*'

GET //conversion-trackers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-trackers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-trackers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-trackers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /conversion-trackers

Code samples

# You can also use wget
curl -X post //conversion-trackers \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //conversion-trackers HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "advertiser": 1,
  "name": "string",
  "implementationType": 1,
  "attributionType": 1,
  "window": 1,
  "aggregationType": 1,
  "type": 1,
  "defaultValue": 1,
  "marginPercentage": 1,
  "marginValue": 1,
  "totalOrderRevenue": 1,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//conversion-trackers',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//conversion-trackers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//conversion-trackers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "advertiser": 1,
  "name": "string",
  "implementationType": 1,
  "attributionType": 1,
  "window": 1,
  "aggregationType": 1,
  "type": 1,
  "defaultValue": 1,
  "marginPercentage": 1,
  "marginValue": 1,
  "totalOrderRevenue": 1,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» advertiser	body	integer	true	No description
» name	body	string	true	length 1-255
» implementationType	body	integer	true	No description
» attributionType	body	integer	true	No description
» window	body	integer	true	No description
» aggregationType	body	integer	true	No description
» type	body	integer	true	No description
» defaultValue	body	number(float)	false	length 1-255
» marginPercentage	body	number(float)	false	No description
» marginValue	body	number(float)	false	No description
» totalOrderRevenue	body	number(float)	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» implementationType	1
» implementationType	2
» attributionType	1
» attributionType	2
» aggregationType	1
» aggregationType	2
» type	1
» type	2
» type	3
» type	4
» type	5
» type	6
» type	7
» type	8
» type	9

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /conversion-trackers/{id}

Code samples

# You can also use wget
curl -X get //conversion-trackers/{id} \
  -H 'Accept: */*'

GET //conversion-trackers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-trackers/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-trackers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-trackers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /conversion-trackers/{id}

Code samples

# You can also use wget
curl -X patch //conversion-trackers/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //conversion-trackers/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "advertiser": 1,
  "name": "string",
  "implementationType": 1,
  "attributionType": 1,
  "window": 1,
  "aggregationType": 1,
  "type": 1,
  "defaultValue": 1,
  "marginPercentage": 1,
  "marginValue": 1,
  "totalOrderRevenue": 1,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//conversion-trackers/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//conversion-trackers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//conversion-trackers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "advertiser": 1,
  "name": "string",
  "implementationType": 1,
  "attributionType": 1,
  "window": 1,
  "aggregationType": 1,
  "type": 1,
  "defaultValue": 1,
  "marginPercentage": 1,
  "marginValue": 1,
  "totalOrderRevenue": 1,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» advertiser	body	integer	false	No description
» name	body	string	false	length 1-255
» implementationType	body	integer	false	No description
» attributionType	body	integer	false	No description
» window	body	integer	false	No description
» aggregationType	body	integer	false	No description
» type	body	integer	false	No description
» defaultValue	body	number(float)	false	length 1-255
» marginPercentage	body	number(float)	false	No description
» marginValue	body	number(float)	false	No description
» totalOrderRevenue	body	number(float)	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» implementationType	1
» implementationType	2
» attributionType	1
» attributionType	2
» aggregationType	1
» aggregationType	2
» type	1
» type	2
» type	3
» type	4
» type	5
» type	6
» type	7
» type	8
» type	9

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /conversion-trackers/{id}

Code samples

# You can also use wget
curl -X delete //conversion-trackers/{id} \
  -H 'Accept: */*'

DELETE //conversion-trackers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-trackers/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//conversion-trackers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//conversion-trackers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /orders/{campaignId}/conversion-trackers

Code samples

# You can also use wget
curl -X get //orders/{campaignId}/conversion-trackers \
  -H 'Accept: */*'

GET //orders/{campaignId}/conversion-trackers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//orders/{campaignId}/conversion-trackers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//orders/{campaignId}/conversion-trackers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//orders/{campaignId}/conversion-trackers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//orders/{campaignId}/conversion-trackers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//orders/{campaignId}/conversion-trackers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
campaignId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /advertisers/{advertiserId}/conversion-trackers

Code samples

# You can also use wget
curl -X get //advertisers/{advertiserId}/conversion-trackers \
  -H 'Accept: */*'

GET //advertisers/{advertiserId}/conversion-trackers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{advertiserId}/conversion-trackers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{advertiserId}/conversion-trackers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/{advertiserId}/conversion-trackers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/{advertiserId}/conversion-trackers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{advertiserId}/conversion-trackers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
advertiserId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /conversion-trackers/details

Code samples

# You can also use wget
curl -X get //conversion-trackers/details \
  -H 'Accept: */*'

GET //conversion-trackers/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-trackers/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-trackers/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-trackers/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-trackers/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-trackers/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /images

Code samples

# You can also use wget
curl -X post //images \
  -H 'Content-Type: application/octet-stream' \
  -H 'Accept: */*'

POST //images HTTP/1.1
Host: null
Content-Type: application/octet-stream
Accept: */*

var headers = {
  'Content-Type':'application/octet-stream',
  'Accept':'*/*'

};

$.ajax({
  url: '//images',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = ''string'';
const headers = {
  'Content-Type':'application/octet-stream',
  'Accept':'*/*'

};

fetch('//images',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/octet-stream',
  'Accept' => '*/*'
}

result = RestClient.post '//images',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/octet-stream',
  'Accept': '*/*'
}

r = requests.post('//images', params={

}, headers = headers)

print r.json()

URL obj = new URL("//images");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

string

Parameters

Parameter	In	Type	Required	Description
body	body	string(binary)	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /images/{id}

Code samples

# You can also use wget
curl -X get //images/{id} \
  -H 'Accept: */*'

GET //images/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//images/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//images/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//images/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//images/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//images/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /images/{id}

Code samples

# You can also use wget
curl -X patch //images/{id} \
  -H 'Accept: */*'

PATCH //images/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//images/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//images/{id}',
{
  method: 'PATCH',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.patch '//images/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.patch('//images/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//images/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /images/{id}

Code samples

# You can also use wget
curl -X delete //images/{id} \
  -H 'Accept: */*'

DELETE //images/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//images/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//images/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//images/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//images/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//images/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /images/details

Code samples

# You can also use wget
curl -X get //images/details \
  -H 'Accept: */*'

GET //images/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//images/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//images/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//images/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//images/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//images/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /agencies

Code samples

# You can also use wget
curl -X get //agencies \
  -H 'Accept: */*'

GET //agencies HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//agencies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//agencies', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /agencies

Code samples

# You can also use wget
curl -X post //agencies \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //agencies HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "advertisers": [
    1
  ],
  "users": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//agencies',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//agencies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//agencies', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "advertisers": [
    1
  ],
  "users": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» isArchived	body	boolean	false	No description
» advertisers	body	[integer]	false	No description
» users	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /agencies/{id}

Code samples

# You can also use wget
curl -X get //agencies/{id} \
  -H 'Accept: */*'

GET //agencies/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//agencies/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//agencies/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /agencies/{id}

Code samples

# You can also use wget
curl -X patch //agencies/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //agencies/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "advertisers": [
    1
  ],
  "users": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//agencies/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//agencies/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//agencies/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "advertisers": [
    1
  ],
  "users": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» isArchived	body	boolean	false	No description
» advertisers	body	[integer]	false	No description
» users	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /agencies/{id}

Code samples

# You can also use wget
curl -X delete //agencies/{id} \
  -H 'Accept: */*'

DELETE //agencies/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//agencies/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//agencies/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /users/{id}/agencies

Code samples

# You can also use wget
curl -X get //users/{id}/agencies \
  -H 'Accept: */*'

GET //users/{id}/agencies HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}/agencies',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/{id}/agencies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/{id}/agencies',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/{id}/agencies', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}/agencies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /agencies/details

Code samples

# You can also use wget
curl -X get //agencies/details \
  -H 'Accept: */*'

GET //agencies/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//agencies/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//agencies/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /advertisers

Code samples

# You can also use wget
curl -X get //advertisers \
  -H 'Accept: */*'

GET //advertisers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /advertisers

Code samples

# You can also use wget
curl -X post //advertisers \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //advertisers HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "agency": 1,
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "billingType": 1,
  "feeType": 1,
  "feeAmount": 1,
  "users": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//advertisers',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//advertisers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//advertisers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "agency": 1,
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "billingType": 1,
  "feeType": 1,
  "feeAmount": 1,
  "users": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» agency	body	integer	false	No description
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» billingType	body	integer	false	No description
» feeType	body	integer	false	No description
» feeAmount	body	number(float)	false	No description
» isArchived	body	boolean	false	No description
» users	body	[string]	false	No description

Enumerated Values

Parameter	Value
» billingType	1
» billingType	2
» billingType	3
» billingType	4
» feeType	1
» feeType	2
» feeType	3
» feeType	4

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /advertisers/{id}

Code samples

# You can also use wget
curl -X get //advertisers/{id} \
  -H 'Accept: */*'

GET //advertisers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /advertisers/{id}

Code samples

# You can also use wget
curl -X patch //advertisers/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //advertisers/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "agency": 1,
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "billingType": 1,
  "feeType": 1,
  "feeAmount": 1,
  "users": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//advertisers/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//advertisers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//advertisers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "agency": 1,
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "billingType": 1,
  "feeType": 1,
  "feeAmount": 1,
  "users": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» agency	body	integer	false	No description
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» billingType	body	integer	false	No description
» feeType	body	integer	false	No description
» feeAmount	body	number(float)	false	No description
» isArchived	body	boolean	false	No description
» users	body	[string]	false	No description

Enumerated Values

Parameter	Value
» billingType	1
» billingType	2
» billingType	3
» billingType	4
» feeType	1
» feeType	2
» feeType	3
» feeType	4

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /advertisers/{id}

Code samples

# You can also use wget
curl -X delete //advertisers/{id} \
  -H 'Accept: */*'

DELETE //advertisers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//advertisers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//advertisers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /agencies/{agencyId}/advertisers

Code samples

# You can also use wget
curl -X get //agencies/{agencyId}/advertisers \
  -H 'Accept: */*'

GET //agencies/{agencyId}/advertisers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//agencies/{agencyId}/advertisers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//agencies/{agencyId}/advertisers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//agencies/{agencyId}/advertisers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//agencies/{agencyId}/advertisers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//agencies/{agencyId}/advertisers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
agencyId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /users/{id}/advertisers

Code samples

# You can also use wget
curl -X get //users/{id}/advertisers \
  -H 'Accept: */*'

GET //users/{id}/advertisers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//users/{id}/advertisers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//users/{id}/advertisers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//users/{id}/advertisers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//users/{id}/advertisers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//users/{id}/advertisers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /advertisers/details

Code samples

# You can also use wget
curl -X get //advertisers/details \
  -H 'Accept: */*'

GET //advertisers/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//advertisers/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//advertisers/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//advertisers/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//advertisers/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//advertisers/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /publishers

Code samples

# You can also use wget
curl -X get //publishers \
  -H 'Accept: */*'

GET //publishers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /publishers

Code samples

# You can also use wget
curl -X post //publishers \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //publishers HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "categories": [
    "string"
  ],
  "ssps": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//publishers',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//publishers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//publishers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "categories": [
    "string"
  ],
  "ssps": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» ssps	body	object	false	No description
»» id	body	integer	true	No description
»» publisher_ssp_id	body	string	false	length 1-255
» isArchived	body	boolean	false	No description
» categories	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /publishers/{id}

Code samples

# You can also use wget
curl -X get //publishers/{id} \
  -H 'Accept: */*'

GET //publishers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /publishers/{id}

Code samples

# You can also use wget
curl -X patch //publishers/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //publishers/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "categories": [
    "string"
  ],
  "ssps": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//publishers/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//publishers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//publishers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "categories": [
    "string"
  ],
  "ssps": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» ssps	body	object	false	No description
»» id	body	integer	true	No description
»» publisher_ssp_id	body	string	false	length 1-255
» isArchived	body	boolean	false	No description
» categories	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /publishers/{id}

Code samples

# You can also use wget
curl -X delete //publishers/{id} \
  -H 'Accept: */*'

DELETE //publishers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//publishers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//publishers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /publishers/details

Code samples

# You can also use wget
curl -X get //publishers/details \
  -H 'Accept: */*'

GET //publishers/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /publishers/{publisherId}/sites

Code samples

# You can also use wget
curl -X get //publishers/{publisherId}/sites \
  -H 'Accept: */*'

GET //publishers/{publisherId}/sites HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{publisherId}/sites',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/{publisherId}/sites',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers/{publisherId}/sites',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers/{publisherId}/sites', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{publisherId}/sites");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
publisherId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /publishers/{publisherId}/apps

Code samples

# You can also use wget
curl -X get //publishers/{publisherId}/apps \
  -H 'Accept: */*'

GET //publishers/{publisherId}/apps HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{publisherId}/apps',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/{publisherId}/apps',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers/{publisherId}/apps',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers/{publisherId}/apps', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{publisherId}/apps");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
publisherId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /publishers/{publisherId}/tags

Code samples

# You can also use wget
curl -X get //publishers/{publisherId}/tags \
  -H 'Accept: */*'

GET //publishers/{publisherId}/tags HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//publishers/{publisherId}/tags',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//publishers/{publisherId}/tags',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//publishers/{publisherId}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//publishers/{publisherId}/tags', params={

}, headers = headers)

print r.json()

URL obj = new URL("//publishers/{publisherId}/tags");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
publisherId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /ssps

Code samples

# You can also use wget
curl -X get //ssps \
  -H 'Accept: */*'

GET //ssps HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ssps',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ssps',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ssps', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /ssps

Code samples

# You can also use wget
curl -X post //ssps \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //ssps HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "publishers": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//ssps',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//ssps',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//ssps', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "publishers": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» publishers	body	object	false	No description
»» id	body	integer	true	No description
»» publisher_ssp_id	body	string	false	length 1-255
» isArchived	body	boolean	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /ssps/{id}

Code samples

# You can also use wget
curl -X get //ssps/{id} \
  -H 'Accept: */*'

GET //ssps/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ssps/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ssps/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ssps/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /ssps/{id}

Code samples

# You can also use wget
curl -X patch //ssps/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //ssps/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "publishers": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//ssps/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//ssps/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//ssps/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "address1": "string",
  "address2": "string",
  "city": "string",
  "state": "string",
  "country": "string",
  "postalCode": "string",
  "phoneNumber": "string",
  "domain": "string",
  "publishers": {
    "id": 1,
    "publisher_ssp_id": "string"
  },
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» address1	body	string	false	length 1-255
» address2	body	string	false	length 1-255
» city	body	string	false	length 1-255
» state	body	string	false	length 1-255
» country	body	string	false	length 1-255
» postalCode	body	string	false	length 1-255
» phoneNumber	body	string	false	length 1-255
» domain	body	string	false	length 1-255
» publishers	body	object	false	No description
»» id	body	integer	true	No description
»» publisher_ssp_id	body	string	false	length 1-255
» isArchived	body	boolean	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /ssps/{id}

Code samples

# You can also use wget
curl -X delete //ssps/{id} \
  -H 'Accept: */*'

DELETE //ssps/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ssps/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//ssps/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//ssps/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /ssps/details

Code samples

# You can also use wget
curl -X get //ssps/details \
  -H 'Accept: */*'

GET //ssps/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ssps/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ssps/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ssps/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ssps/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ssps/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /sites

Code samples

# You can also use wget
curl -X post //sites \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //sites HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//sites',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//sites',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//sites',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//sites', params={

}, headers = headers)

print r.json()

URL obj = new URL("//sites");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	Body3	true	No description
» publisher	body	integer	true	No description
» name	body	string	true	length 1-255

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

PATCH /sites/{id}

Code samples

# You can also use wget
curl -X patch //sites/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //sites/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//sites/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//sites/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//sites/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//sites/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//sites/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string"
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	Body4	true	No description
» publisher	body	integer	false	No description
» name	body	string	false	length 1-255

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /sites/{id}

Code samples

# You can also use wget
curl -X get //sites/{id} \
  -H 'Accept: */*'

GET //sites/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//sites/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//sites/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//sites/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//sites/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//sites/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /sites/details

Code samples

# You can also use wget
curl -X get //sites/details \
  -H 'Accept: */*'

GET //sites/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//sites/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//sites/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//sites/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//sites/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//sites/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /apps

Code samples

# You can also use wget
curl -X post //apps \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //apps HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//apps',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//apps',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//apps',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//apps', params={

}, headers = headers)

print r.json()

URL obj = new URL("//apps");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	Body3	true	No description
» publisher	body	integer	true	No description
» name	body	string	true	length 1-255

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

PATCH /apps/{id}

Code samples

# You can also use wget
curl -X patch //apps/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //apps/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//apps/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//apps/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//apps/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//apps/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//apps/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string"
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	Body4	true	No description
» publisher	body	integer	false	No description
» name	body	string	false	length 1-255

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /apps/{id}

Code samples

# You can also use wget
curl -X get //apps/{id} \
  -H 'Accept: */*'

GET //apps/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//apps/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//apps/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//apps/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//apps/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//apps/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /apps/details

Code samples

# You can also use wget
curl -X get //apps/details \
  -H 'Accept: */*'

GET //apps/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//apps/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//apps/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//apps/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//apps/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//apps/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /tags

Code samples

# You can also use wget
curl -X get //tags \
  -H 'Accept: */*'

GET //tags HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//tags',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//tags',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//tags', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /tags

Code samples

# You can also use wget
curl -X post //tags \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //tags HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//tags',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string",
  "adFormat": 1,
  "placement": 1,
  "contentType": 1,
  "contentSubtype": 1,
  "isNative": 1,
  "isDisplay": 1,
  "isSecure": 1,
  "bidFloor": 1,
  "isCpc": 1,
  "isCpm": 1,
  "passback": "string",
  "enableThirdParty": 1,
  "dealId": "string",
  "dealAuctionType": 1,
  "blockedCategories": [
    "string"
  ],
  "blockedAdvertisers": [
    1
  ],
  "fillNetworks": [
    1
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//tags',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//tags', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string",
  "adFormat": 1,
  "placement": 1,
  "contentType": 1,
  "contentSubtype": 1,
  "isNative": 1,
  "isDisplay": 1,
  "isSecure": 1,
  "bidFloor": 1,
  "isCpc": 1,
  "isCpm": 1,
  "passback": "string",
  "enableThirdParty": 1,
  "dealId": "string",
  "dealAuctionType": 1,
  "blockedCategories": [
    "string"
  ],
  "blockedAdvertisers": [
    1
  ],
  "fillNetworks": [
    1
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» publisher	body	integer	true	No description
» name	body	string	true	length 1-255
» adFormat	body	integer	true	No description
» placement	body	integer	true	No description
» contentType	body	integer	true	No description
» contentSubtype	body	integer	true	No description
» isNative	body	integer	true	No description
» isDisplay	body	integer	true	No description
» isSecure	body	integer	true	No description
» bidFloor	body	number(float)	false	No description
» isCpc	body	integer	true	No description
» isCpm	body	integer	true	No description
» passback	body	string	false	length 1-500
» enableThirdParty	body	integer	true	No description
» dealId	body	string	false	length 1-255
» dealAuctionType	body	integer	true	No description
» isArchived	body	boolean	false	No description
» blockedCategories	body	[string]	false	No description
» blockedAdvertisers	body	[integer]	false	No description
» fillNetworks	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» adFormat	1
» adFormat	2
» adFormat	3
» adFormat	4
» adFormat	5
» placement	1
» placement	2
» placement	3
» placement	4
» contentType	1
» contentType	2
» contentType	3
» contentSubtype	10
» contentSubtype	11
» contentSubtype	12
» contentSubtype	13
» contentSubtype	14
» contentSubtype	15
» contentSubtype	20
» contentSubtype	21
» contentSubtype	22
» contentSubtype	30
» contentSubtype	31
» contentSubtype	32
» isNative	0
» isNative	1
» isDisplay	0
» isDisplay	1
» isSecure	0
» isSecure	1
» isCpc	0
» isCpc	1
» isCpm	0
» isCpm	1
» enableThirdParty	0
» enableThirdParty	1
» dealAuctionType	1
» dealAuctionType	2
» dealAuctionType	3

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /tags/{id}

Code samples

# You can also use wget
curl -X get //tags/{id} \
  -H 'Accept: */*'

GET //tags/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//tags/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//tags/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//tags/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//tags/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /tags/{id}

Code samples

# You can also use wget
curl -X patch //tags/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //tags/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//tags/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "publisher": 1,
  "name": "string",
  "adFormat": 1,
  "placement": 1,
  "contentType": 1,
  "contentSubtype": 1,
  "isNative": 1,
  "isDisplay": 1,
  "isSecure": 1,
  "bidFloor": 1,
  "isCpc": 1,
  "isCpm": 1,
  "passback": "string",
  "enableThirdParty": 1,
  "dealId": "string",
  "dealAuctionType": 1,
  "blockedCategories": [
    "string"
  ],
  "blockedAdvertisers": [
    1
  ],
  "fillNetworks": [
    1
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//tags/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//tags/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//tags/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "publisher": 1,
  "name": "string",
  "adFormat": 1,
  "placement": 1,
  "contentType": 1,
  "contentSubtype": 1,
  "isNative": 1,
  "isDisplay": 1,
  "isSecure": 1,
  "bidFloor": 1,
  "isCpc": 1,
  "isCpm": 1,
  "passback": "string",
  "enableThirdParty": 1,
  "dealId": "string",
  "dealAuctionType": 1,
  "blockedCategories": [
    "string"
  ],
  "blockedAdvertisers": [
    1
  ],
  "fillNetworks": [
    1
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» publisher	body	integer	false	No description
» name	body	string	false	length 1-255
» adFormat	body	integer	false	No description
» placement	body	integer	false	No description
» contentType	body	integer	false	No description
» contentSubtype	body	integer	false	No description
» isNative	body	integer	false	No description
» isDisplay	body	integer	false	No description
» isSecure	body	integer	false	No description
» bidFloor	body	number(float)	false	No description
» isCpc	body	integer	false	No description
» isCpm	body	integer	false	No description
» passback	body	string	false	length 1-500
» enableThirdParty	body	integer	false	No description
» dealId	body	string	false	length 1-255
» dealAuctionType	body	integer	false	No description
» isArchived	body	boolean	false	No description
» blockedCategories	body	[string]	false	No description
» blockedAdvertisers	body	[integer]	false	No description
» fillNetworks	body	[integer]	false	No description

Enumerated Values

Parameter	Value
» adFormat	1
» adFormat	2
» adFormat	3
» adFormat	4
» adFormat	5
» placement	1
» placement	2
» placement	3
» placement	4
» contentType	1
» contentType	2
» contentType	3
» contentSubtype	10
» contentSubtype	11
» contentSubtype	12
» contentSubtype	13
» contentSubtype	14
» contentSubtype	15
» contentSubtype	20
» contentSubtype	21
» contentSubtype	22
» contentSubtype	30
» contentSubtype	31
» contentSubtype	32
» isNative	0
» isNative	1
» isDisplay	0
» isDisplay	1
» isSecure	0
» isSecure	1
» isCpc	0
» isCpc	1
» isCpm	0
» isCpm	1
» enableThirdParty	0
» enableThirdParty	1
» dealAuctionType	1
» dealAuctionType	2
» dealAuctionType	3

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /tags/{id}

Code samples

# You can also use wget
curl -X delete //tags/{id} \
  -H 'Accept: */*'

DELETE //tags/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//tags/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//tags/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//tags/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//tags/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /tags/details

Code samples

# You can also use wget
curl -X get //tags/details \
  -H 'Accept: */*'

GET //tags/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//tags/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//tags/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//tags/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//tags/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//tags/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /custom-lists

Code samples

# You can also use wget
curl -X get //custom-lists \
  -H 'Accept: */*'

GET //custom-lists HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-lists',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//custom-lists',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//custom-lists', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /custom-lists

Code samples

# You can also use wget
curl -X post //custom-lists \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //custom-lists HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//custom-lists',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//custom-lists',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//custom-lists', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	Body5	true	No description
» name	body	string	true	length 1-255
» type	body	integer	true	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» type	1
» type	2

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /custom-lists/{id}

Code samples

# You can also use wget
curl -X get //custom-lists/{id} \
  -H 'Accept: */*'

GET //custom-lists/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-lists/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//custom-lists/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//custom-lists/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /custom-lists/{id}

Code samples

# You can also use wget
curl -X patch //custom-lists/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //custom-lists/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//custom-lists/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//custom-lists/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//custom-lists/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» type	body	integer	false	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» type	1
» type	2

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /custom-lists/{id}

Code samples

# You can also use wget
curl -X delete //custom-lists/{id} \
  -H 'Accept: */*'

DELETE //custom-lists/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-lists/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//custom-lists/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//custom-lists/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /custom-lists/details

Code samples

# You can also use wget
curl -X get //custom-lists/details \
  -H 'Accept: */*'

GET //custom-lists/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-lists/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//custom-lists/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//custom-lists/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /custom-lists/{customListId}/items

Code samples

# You can also use wget
curl -X get //custom-lists/{customListId}/items \
  -H 'Accept: */*'

GET //custom-lists/{customListId}/items HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{customListId}/items',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-lists/{customListId}/items',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//custom-lists/{customListId}/items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//custom-lists/{customListId}/items', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{customListId}/items");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
customListId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

POST /custom-lists/{customListId}/items

Code samples

# You can also use wget
curl -X post //custom-lists/{customListId}/items \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //custom-lists/{customListId}/items HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{customListId}/items',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//custom-lists/{customListId}/items',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//custom-lists/{customListId}/items',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//custom-lists/{customListId}/items', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{customListId}/items");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
customListId	path	integer	true	No description
body	body	Body5	true	No description
» name	body	string	true	length 1-255
» type	body	integer	true	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» type	1
» type	2

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

POST /custom-lists/{customListId}/items/upload

Code samples

# You can also use wget
curl -X post //custom-lists/{customListId}/items/upload \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //custom-lists/{customListId}/items/upload HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-lists/{customListId}/items/upload',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//custom-lists/{customListId}/items/upload',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//custom-lists/{customListId}/items/upload',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//custom-lists/{customListId}/items/upload', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-lists/{customListId}/items/upload");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "type": 1,
  "isActive": true,
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
customListId	path	integer	true	No description
body	body	Body5	true	No description
» name	body	string	true	length 1-255
» type	body	integer	true	No description
» isActive	body	boolean	false	No description
» isArchived	body	boolean	false	No description

Enumerated Values

Parameter	Value
» type	1
» type	2

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /scheduled-reports

Code samples

# You can also use wget
curl -X get //scheduled-reports \
  -H 'Accept: */*'

GET //scheduled-reports HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//scheduled-reports',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//scheduled-reports',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//scheduled-reports',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//scheduled-reports', params={

}, headers = headers)

print r.json()

URL obj = new URL("//scheduled-reports");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /scheduled-reports

Code samples

# You can also use wget
curl -X post //scheduled-reports \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //scheduled-reports HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//scheduled-reports',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "range": "string",
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "from": "2017-09-26",
  "to": "2017-09-26",
  "utc_offset": 1,
  "interval": "string",
  "emails": [
    "string"
  ],
  "metrics": [
    "string"
  ],
  "dimensions": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//scheduled-reports',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//scheduled-reports',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//scheduled-reports', params={

}, headers = headers)

print r.json()

URL obj = new URL("//scheduled-reports");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "range": "string",
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "from": "2017-09-26",
  "to": "2017-09-26",
  "utc_offset": 1,
  "interval": "string",
  "emails": [
    "string"
  ],
  "metrics": [
    "string"
  ],
  "dimensions": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	true	length 1-255
» range	body	string	true	length 1-255
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» from	body	string(date)	false	No description
» to	body	string(date)	false	No description
» utc_offset	body	integer	false	No description
» interval	body	string	true	length 1-255
» isArchived	body	boolean	false	No description
» emails	body	[string]	false	No description
» metrics	body	[string]	false	No description
» dimensions	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /scheduled-reports/{id}

Code samples

# You can also use wget
curl -X get //scheduled-reports/{id} \
  -H 'Accept: */*'

GET //scheduled-reports/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//scheduled-reports/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//scheduled-reports/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//scheduled-reports/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//scheduled-reports/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//scheduled-reports/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /scheduled-reports/{id}

Code samples

# You can also use wget
curl -X patch //scheduled-reports/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //scheduled-reports/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//scheduled-reports/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "range": "string",
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "from": "2017-09-26",
  "to": "2017-09-26",
  "utc_offset": 1,
  "interval": "string",
  "emails": [
    "string"
  ],
  "metrics": [
    "string"
  ],
  "dimensions": [
    "string"
  ],
  "isArchived": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//scheduled-reports/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//scheduled-reports/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//scheduled-reports/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//scheduled-reports/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "range": "string",
  "startDate": "2017-09-26",
  "endDate": "2017-09-26",
  "from": "2017-09-26",
  "to": "2017-09-26",
  "utc_offset": 1,
  "interval": "string",
  "emails": [
    "string"
  ],
  "metrics": [
    "string"
  ],
  "dimensions": [
    "string"
  ],
  "isArchived": true
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-255
» range	body	string	false	length 1-255
» startDate	body	string(date)	false	No description
» endDate	body	string(date)	false	No description
» from	body	string(date)	false	No description
» to	body	string(date)	false	No description
» utc_offset	body	integer	false	No description
» interval	body	string	false	length 1-255
» isArchived	body	boolean	false	No description
» emails	body	[string]	false	No description
» metrics	body	[string]	false	No description
» dimensions	body	[string]	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

DELETE /scheduled-reports/{id}

Code samples

# You can also use wget
curl -X delete //scheduled-reports/{id} \
  -H 'Accept: */*'

DELETE //scheduled-reports/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//scheduled-reports/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//scheduled-reports/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.delete '//scheduled-reports/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.delete('//scheduled-reports/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//scheduled-reports/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

GET /billing-types

Code samples

# You can also use wget
curl -X get //billing-types \
  -H 'Accept: */*'

GET //billing-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//billing-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//billing-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//billing-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//billing-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//billing-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /billing-categories

Code samples

# You can also use wget
curl -X get //billing-categories \
  -H 'Accept: */*'

GET //billing-categories HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//billing-categories',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//billing-categories',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//billing-categories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//billing-categories', params={

}, headers = headers)

print r.json()

URL obj = new URL("//billing-categories");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /ad-formats

Code samples

# You can also use wget
curl -X get //ad-formats \
  -H 'Accept: */*'

GET //ad-formats HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ad-formats',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ad-formats',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ad-formats',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ad-formats', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ad-formats");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /fee-types

Code samples

# You can also use wget
curl -X get //fee-types \
  -H 'Accept: */*'

GET //fee-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//fee-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//fee-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//fee-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//fee-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//fee-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /pacings

Code samples

# You can also use wget
curl -X get //pacings \
  -H 'Accept: */*'

GET //pacings HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//pacings',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//pacings',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//pacings',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//pacings', params={

}, headers = headers)

print r.json()

URL obj = new URL("//pacings");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /optimisations

Code samples

# You can also use wget
curl -X get //optimisations \
  -H 'Accept: */*'

GET //optimisations HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//optimisations',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//optimisations',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//optimisations',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//optimisations', params={

}, headers = headers)

print r.json()

URL obj = new URL("//optimisations");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /placements

Code samples

# You can also use wget
curl -X get //placements \
  -H 'Accept: */*'

GET //placements HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//placements',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//placements',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//placements',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//placements', params={

}, headers = headers)

print r.json()

URL obj = new URL("//placements");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /content-types

Code samples

# You can also use wget
curl -X get //content-types \
  -H 'Accept: */*'

GET //content-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//content-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//content-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//content-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//content-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//content-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /content-subtypes

Code samples

# You can also use wget
curl -X get //content-subtypes \
  -H 'Accept: */*'

GET //content-subtypes HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//content-subtypes',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//content-subtypes',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//content-subtypes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//content-subtypes', params={

}, headers = headers)

print r.json()

URL obj = new URL("//content-subtypes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /categories

Code samples

# You can also use wget
curl -X get //categories \
  -H 'Accept: */*'

GET //categories HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//categories',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//categories',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//categories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//categories', params={

}, headers = headers)

print r.json()

URL obj = new URL("//categories");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /ias-segments

Code samples

# You can also use wget
curl -X get //ias-segments \
  -H 'Accept: */*'

GET //ias-segments HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ias-segments',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ias-segments',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ias-segments',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ias-segments', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ias-segments");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /ias-traq-options

Code samples

# You can also use wget
curl -X get //ias-traq-options \
  -H 'Accept: */*'

GET //ias-traq-options HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ias-traq-options',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ias-traq-options',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ias-traq-options',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ias-traq-options', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ias-traq-options");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /ias-vtop-options

Code samples

# You can also use wget
curl -X get //ias-vtop-options \
  -H 'Accept: */*'

GET //ias-vtop-options HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//ias-vtop-options',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//ias-vtop-options',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//ias-vtop-options',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//ias-vtop-options', params={

}, headers = headers)

print r.json()

URL obj = new URL("//ias-vtop-options");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /countries

Code samples

# You can also use wget
curl -X get //countries \
  -H 'Accept: */*'

GET //countries HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//countries',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//countries',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//countries',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//countries', params={

}, headers = headers)

print r.json()

URL obj = new URL("//countries");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /countries/detected

Code samples

# You can also use wget
curl -X get //countries/detected \
  -H 'Accept: */*'

GET //countries/detected HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//countries/detected',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//countries/detected',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//countries/detected',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//countries/detected', params={

}, headers = headers)

print r.json()

URL obj = new URL("//countries/detected");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /countries/{id}/regions

Code samples

# You can also use wget
curl -X get //countries/{id}/regions \
  -H 'Accept: */*'

GET //countries/{id}/regions HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//countries/{id}/regions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//countries/{id}/regions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//countries/{id}/regions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//countries/{id}/regions', params={

}, headers = headers)

print r.json()

URL obj = new URL("//countries/{id}/regions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /regions/{countrySubdivisionId}/cities

Code samples

# You can also use wget
curl -X get //regions/{countrySubdivisionId}/cities \
  -H 'Accept: */*'

GET //regions/{countrySubdivisionId}/cities HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//regions/{countrySubdivisionId}/cities',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//regions/{countrySubdivisionId}/cities',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//regions/{countrySubdivisionId}/cities',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//regions/{countrySubdivisionId}/cities', params={

}, headers = headers)

print r.json()

URL obj = new URL("//regions/{countrySubdivisionId}/cities");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
countrySubdivisionId	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /regions

Code samples

# You can also use wget
curl -X get //regions \
  -H 'Accept: */*'

GET //regions HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//regions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//regions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//regions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//regions', params={

}, headers = headers)

print r.json()

URL obj = new URL("//regions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /cities

Code samples

# You can also use wget
curl -X get //cities \
  -H 'Accept: */*'

GET //cities HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//cities',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//cities',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//cities',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//cities', params={

}, headers = headers)

print r.json()

URL obj = new URL("//cities");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /languages

Code samples

# You can also use wget
curl -X get //languages \
  -H 'Accept: */*'

GET //languages HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//languages',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//languages',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//languages',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//languages', params={

}, headers = headers)

print r.json()

URL obj = new URL("//languages");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /timezones

Code samples

# You can also use wget
curl -X get //timezones \
  -H 'Accept: */*'

GET //timezones HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//timezones',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//timezones',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//timezones',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//timezones', params={

}, headers = headers)

print r.json()

URL obj = new URL("//timezones");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /device-types

Code samples

# You can also use wget
curl -X get //device-types \
  -H 'Accept: */*'

GET //device-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//device-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//device-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//device-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//device-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//device-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /device-makes

Code samples

# You can also use wget
curl -X get //device-makes \
  -H 'Accept: */*'

GET //device-makes HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//device-makes',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//device-makes',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//device-makes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//device-makes', params={

}, headers = headers)

print r.json()

URL obj = new URL("//device-makes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /device-makes/{makeId}/models

Code samples

# You can also use wget
curl -X get //device-makes/{makeId}/models \
  -H 'Accept: */*'

GET //device-makes/{makeId}/models HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//device-makes/{makeId}/models',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//device-makes/{makeId}/models',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//device-makes/{makeId}/models',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//device-makes/{makeId}/models', params={

}, headers = headers)

print r.json()

URL obj = new URL("//device-makes/{makeId}/models");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
makeId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /device-models

Code samples

# You can also use wget
curl -X get //device-models \
  -H 'Accept: */*'

GET //device-models HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//device-models',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//device-models',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//device-models',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//device-models', params={

}, headers = headers)

print r.json()

URL obj = new URL("//device-models");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /devices/platforms

Code samples

# You can also use wget
curl -X get //devices/platforms \
  -H 'Accept: */*'

GET //devices/platforms HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//devices/platforms',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//devices/platforms',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//devices/platforms',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//devices/platforms', params={

}, headers = headers)

print r.json()

URL obj = new URL("//devices/platforms");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /browsers

Code samples

# You can also use wget
curl -X get //browsers \
  -H 'Accept: */*'

GET //browsers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//browsers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//browsers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//browsers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//browsers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//browsers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /conversion-tracker-aggregation-types

Code samples

# You can also use wget
curl -X get //conversion-tracker-aggregation-types \
  -H 'Accept: */*'

GET //conversion-tracker-aggregation-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-tracker-aggregation-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-tracker-aggregation-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-tracker-aggregation-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-tracker-aggregation-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-tracker-aggregation-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /conversion-tracker-attribution-types

Code samples

# You can also use wget
curl -X get //conversion-tracker-attribution-types \
  -H 'Accept: */*'

GET //conversion-tracker-attribution-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-tracker-attribution-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-tracker-attribution-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-tracker-attribution-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-tracker-attribution-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-tracker-attribution-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /conversion-tracker-implementation-types

Code samples

# You can also use wget
curl -X get //conversion-tracker-implementation-types \
  -H 'Accept: */*'

GET //conversion-tracker-implementation-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-tracker-implementation-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-tracker-implementation-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-tracker-implementation-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-tracker-implementation-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-tracker-implementation-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /conversion-tracker-tag-types

Code samples

# You can also use wget
curl -X get //conversion-tracker-tag-types \
  -H 'Accept: */*'

GET //conversion-tracker-tag-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-tracker-tag-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-tracker-tag-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-tracker-tag-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-tracker-tag-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-tracker-tag-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /conversion-tracker-types

Code samples

# You can also use wget
curl -X get //conversion-tracker-types \
  -H 'Accept: */*'

GET //conversion-tracker-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//conversion-tracker-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//conversion-tracker-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//conversion-tracker-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//conversion-tracker-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//conversion-tracker-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /custom-list-types

Code samples

# You can also use wget
curl -X get //custom-list-types \
  -H 'Accept: */*'

GET //custom-list-types HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//custom-list-types',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//custom-list-types',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//custom-list-types',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//custom-list-types', params={

}, headers = headers)

print r.json()

URL obj = new URL("//custom-list-types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /banner-dimensions

Code samples

# You can also use wget
curl -X get //banner-dimensions \
  -H 'Accept: */*'

GET //banner-dimensions HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//banner-dimensions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//banner-dimensions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//banner-dimensions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//banner-dimensions', params={

}, headers = headers)

print r.json()

URL obj = new URL("//banner-dimensions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /sites-apps

Code samples

# You can also use wget
curl -X get //sites-apps \
  -H 'Accept: */*'

GET //sites-apps HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//sites-apps',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//sites-apps',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//sites-apps',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//sites-apps', params={

}, headers = headers)

print r.json()

URL obj = new URL("//sites-apps");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /context/categories

Code samples

# You can also use wget
curl -X get //context/categories \
  -H 'Accept: */*'

GET //context/categories HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//context/categories',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//context/categories',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//context/categories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//context/categories', params={

}, headers = headers)

print r.json()

URL obj = new URL("//context/categories");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /context/categories/{id}/phrases

Code samples

# You can also use wget
curl -X get //context/categories/{id}/phrases \
  -H 'Accept: */*'

GET //context/categories/{id}/phrases HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//context/categories/{id}/phrases',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//context/categories/{id}/phrases',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//context/categories/{id}/phrases',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//context/categories/{id}/phrases', params={

}, headers = headers)

print r.json()

URL obj = new URL("//context/categories/{id}/phrases");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	string	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /report

Code samples

# You can also use wget
curl -X get //report?range=string&interval=string&metrics=string&dimensions=string \
  -H 'Accept: */*'

GET //report?range=string&interval=string&metrics=string&dimensions=string HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report',
  method: 'get',
  data: '?range=string&interval=string&metrics=string&dimensions=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report?range=string&interval=string&metrics=string&dimensions=string',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report',
  params: {
  'range' => 'string',
'interval' => 'string',
'metrics' => 'string',
'dimensions' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report', params={
  'range': 'string',  'interval': 'string',  'metrics': 'string',  'dimensions': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("//report?range=string&interval=string&metrics=string&dimensions=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
range	query	string	true	No description
from	query	string	false	YYYY-MM-DD required if range is custom
to	query	string	false	YYYY-MM-DD required if range is custom
interval	query	string	true	No description
metrics	query	string	true	No description
dimensions	query	string	true	No description
filters	query	string	false	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /report/options/range

Code samples

# You can also use wget
curl -X get //report/options/range \
  -H 'Accept: */*'

GET //report/options/range HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report/options/range',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report/options/range',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report/options/range',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report/options/range', params={

}, headers = headers)

print r.json()

URL obj = new URL("//report/options/range");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /report/options/interval

Code samples

# You can also use wget
curl -X get //report/options/interval \
  -H 'Accept: */*'

GET //report/options/interval HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report/options/interval',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report/options/interval',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report/options/interval',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report/options/interval', params={

}, headers = headers)

print r.json()

URL obj = new URL("//report/options/interval");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /report/options/metrics

Code samples

# You can also use wget
curl -X get //report/options/metrics \
  -H 'Accept: */*'

GET //report/options/metrics HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report/options/metrics',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report/options/metrics',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report/options/metrics',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report/options/metrics', params={

}, headers = headers)

print r.json()

URL obj = new URL("//report/options/metrics");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /report/options/dimensions

Code samples

# You can also use wget
curl -X get //report/options/dimensions \
  -H 'Accept: */*'

GET //report/options/dimensions HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report/options/dimensions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report/options/dimensions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report/options/dimensions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report/options/dimensions', params={

}, headers = headers)

print r.json()

URL obj = new URL("//report/options/dimensions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /report/options/filters

Code samples

# You can also use wget
curl -X get //report/options/filters \
  -H 'Accept: */*'

GET //report/options/filters HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//report/options/filters',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//report/options/filters',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//report/options/filters',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//report/options/filters', params={

}, headers = headers)

print r.json()

URL obj = new URL("//report/options/filters");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /audience/data-providers

Code samples

# You can also use wget
curl -X get //audience/data-providers \
  -H 'Accept: */*'

GET //audience/data-providers HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /audience/data-providers/{id}

Code samples

# You can also use wget
curl -X get //audience/data-providers/{id} \
  -H 'Accept: */*'

GET //audience/data-providers/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /audience/data-providers/{id}/categories

Code samples

# You can also use wget
curl -X get //audience/data-providers/{id}/categories \
  -H 'Accept: */*'

GET //audience/data-providers/{id}/categories HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers/{id}/categories',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers/{id}/categories',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers/{id}/categories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers/{id}/categories', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers/{id}/categories");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /audience/data-providers/{id}/categories/{parentId}

Code samples

# You can also use wget
curl -X get //audience/data-providers/{id}/categories/{parentId} \
  -H 'Accept: */*'

GET //audience/data-providers/{id}/categories/{parentId} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers/{id}/categories/{parentId}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers/{id}/categories/{parentId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers/{id}/categories/{parentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers/{id}/categories/{parentId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers/{id}/categories/{parentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
parentId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /audience/data-providers/categories

Code samples

# You can also use wget
curl -X get //audience/data-providers/categories \
  -H 'Accept: */*'

GET //audience/data-providers/categories HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers/categories',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers/categories',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers/categories',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers/categories', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers/categories");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

GET /audience/data-providers/categories/{parentId}

Code samples

# You can also use wget
curl -X get //audience/data-providers/categories/{parentId} \
  -H 'Accept: */*'

GET //audience/data-providers/categories/{parentId} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/data-providers/categories/{parentId}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/data-providers/categories/{parentId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/data-providers/categories/{parentId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/data-providers/categories/{parentId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/data-providers/categories/{parentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
parentId	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

GET /audience

Code samples

# You can also use wget
curl -X get //audience \
  -H 'Accept: */*'

GET //audience HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

POST /audience

Code samples

# You can also use wget
curl -X post //audience \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

POST //audience HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//audience',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "recency": 1,
  "segmentOperator": "AND",
  "audienceSegments": {
    "frequency": 1,
    "categoryOperator": "AND",
    "audienceSegmentCategories": {
      "category": 0
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//audience',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.post '//audience',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.post('//audience', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "recency": 1,
  "segmentOperator": "AND",
  "audienceSegments": {
    "frequency": 1,
    "categoryOperator": "AND",
    "audienceSegmentCategories": {
      "category": 0
    }
  }
}

Parameters

Parameter	In	Type	Required	Description
body	body	object	true	No description
» name	body	string	false	length 1-500
» recency	body	number(float)	false	length 1-3
» segmentOperator	body	string	true	No description
» audienceSegments	body	object	true	No description
»» frequency	body	number(float)	false	length 1-3
»» categoryOperator	body	string	true	No description
»» audienceSegmentCategories	body	object	true	No description
»»» category	body	integer	true	No description

Enumerated Values

Parameter	Value
» segmentOperator	AND
» segmentOperator	OR
»» categoryOperator	AND
»» categoryOperator	OR

Example responses

Responses

Status	Meaning	Description	Schema
201	Created	Success	Inline
400	Bad Request	Error	Inline

Response Schema

Status Code 201

Name	Type	Required	Description
data	object	false	No description
» id	integer	false	No description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /audience/{id}

Code samples

# You can also use wget
curl -X get //audience/{id} \
  -H 'Accept: */*'

GET //audience/{id} HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
data	object	false	No description
status	string	false	No description

PATCH /audience/{id}

Code samples

# You can also use wget
curl -X patch //audience/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*'

PATCH //audience/{id} HTTP/1.1
Host: null
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/{id}',
  method: 'patch',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "recency": 1,
  "segmentOperator": "AND",
  "audienceSegments": {
    "frequency": 1,
    "categoryOperator": "AND",
    "audienceSegmentCategories": {
      "category": 0
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'

};

fetch('//audience/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => '*/*'
}

result = RestClient.patch '//audience/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*'
}

r = requests.patch('//audience/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Body parameter

{
  "name": "string",
  "recency": 1,
  "segmentOperator": "AND",
  "audienceSegments": {
    "frequency": 1,
    "categoryOperator": "AND",
    "audienceSegmentCategories": {
      "category": 0
    }
  }
}

Parameters

Parameter	In	Type	Required	Description
id	path	integer	true	No description
body	body	object	true	No description
» name	body	string	false	length 1-500
» recency	body	number(float)	false	length 1-3
» segmentOperator	body	string	false	No description
» audienceSegments	body	object	false	No description
»» frequency	body	number(float)	false	length 1-3
»» categoryOperator	body	string	true	No description
»» audienceSegmentCategories	body	object	true	No description
»»» category	body	integer	true	No description

Enumerated Values

Parameter	Value
» segmentOperator	AND
» segmentOperator	OR
»» categoryOperator	AND
»» categoryOperator	OR

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline
400	Bad Request	Error	Inline
404	Not Found	error	None

Response Schema

Status Code 200

Name	Type	Required	Description
status	string	false	No description

Response Schema

Status Code 400

Name	Type	Required	Description
data	object	false	No description
» errors	[string]	false	No description
status	string	false	No description

GET /audience/details

Code samples

# You can also use wget
curl -X get //audience/details \
  -H 'Accept: */*'

GET //audience/details HTTP/1.1
Host: null

Accept: */*

var headers = {
  'Accept':'*/*'

};

$.ajax({
  url: '//audience/details',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'*/*'

};

fetch('//audience/details',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => '*/*'
}

result = RestClient.get '//audience/details',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('//audience/details', params={

}, headers = headers)

print r.json()

URL obj = new URL("//audience/details");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

Example responses

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Status Code 200

Name	Type	Required	Description
meta	object	false	No description
» totalItems	string	false	No description
status	string	false	No description
data	[object]	false	No description

Schemas

creative-type-1

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
} 

Properties

Name	Type	Required	Description
advertiser	integer	true	No description
name	string	true	length 1-255
type	integer	true	No description
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description
impressionTrackers	object	false	No description
» value	string	true	length 1-2000
» type	integer	true	No description
isArchived	boolean	false	No description
dataAssets	object	false	No description
imgAssets	object	true	No description
categories	[string]	false	No description

Enumerated Values

Property	Value
» type	1
» type	2

creative-type-1.dataAssets.1.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.dataAssets.11.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.dataAssets.12.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-20
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.dataAssets.2.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-60
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.dataAssets.2.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-140
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.imgAssets.2.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 100 minHeight 100 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.imgAssets.3.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 600 minHeight 600 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.imgAssets.3.2

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 1020 minHeight 700
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.titleAsset.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-25
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-1.titleAsset.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-70
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "6": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
} 

Properties

Name	Type	Required	Description
advertiser	integer	true	No description
name	string	true	length 1-255
type	integer	true	No description
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description
impressionTrackers	object	false	No description
» value	string	true	length 1-2000
» type	integer	true	No description
isArchived	boolean	false	No description
dataAssets	object	false	No description
imgAssets	object	true	No description
categories	[string]	false	No description

Enumerated Values

Property	Value
» type	1
» type	2

creative-type-2.dataAssets.1.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.dataAssets.11.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.dataAssets.12.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-20
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.dataAssets.2.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-60
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.dataAssets.2.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-140
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.dataAssets.6.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-15
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.imgAssets.2.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 100 minHeight 100 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.imgAssets.3.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 600 minHeight 600 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.imgAssets.3.2

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 1020 minHeight 700
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.titleAsset.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-25
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-2.titleAsset.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-70
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
} 

Properties

Name	Type	Required	Description
advertiser	integer	true	No description
name	string	true	length 1-255
type	integer	true	No description
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description
impressionTrackers	object	false	No description
» value	string	true	length 1-2000
» type	integer	true	No description
isArchived	boolean	false	No description
dataAssets	object	false	No description
imgAssets	object	true	No description
categories	[string]	false	No description

Enumerated Values

Property	Value
» type	1
» type	2

creative-type-3.dataAssets.1.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.dataAssets.11.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.dataAssets.12.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-20
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.dataAssets.2.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-60
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.dataAssets.2.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-140
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.imgAssets.2.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 100 minHeight 100 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.imgAssets.3.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 600 minHeight 600 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.imgAssets.3.2

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 1020 minHeight 700
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.titleAsset.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-25
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-3.titleAsset.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-70
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4

{
  "advertiser": 1,
  "name": "string",
  "type": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  },
  "impressionTrackers": {
    "value": "string",
    "type": 1
  },
  "categories": [
    "string"
  ],
  "isArchived": true,
  "titleAssets": [
    "Assets based on type"
  ],
  "dataAssets": {
    "1": [
      "Assets based on type"
    ],
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ],
    "6": [
      "Assets based on type"
    ],
    "11": [
      "Assets based on type"
    ],
    "12": [
      "Assets based on type"
    ]
  },
  "imgAssets": {
    "2": [
      "Assets based on type"
    ],
    "3": [
      "Assets based on type"
    ]
  }
} 

Properties

Name	Type	Required	Description
advertiser	integer	true	No description
name	string	true	length 1-255
type	integer	true	No description
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description
impressionTrackers	object	false	No description
» value	string	true	length 1-2000
» type	integer	true	No description
isArchived	boolean	false	No description
dataAssets	object	false	No description
imgAssets	object	true	No description
categories	[string]	false	No description

Enumerated Values

Property	Value
» type	1
» type	2

creative-type-4.dataAssets.1.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.11.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-30
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.12.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-20
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.2.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-60
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.2.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-140
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.3.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-5
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.dataAssets.6.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 0-15
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.imgAssets.2.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 100 minHeight 100 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.imgAssets.3.1

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 600 minHeight 600 ratio 1:1
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.imgAssets.3.2

{
  "image": 1,
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
image	integer	true	minWidth 1020 minHeight 700
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.titleAsset.1

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-25
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

creative-type-4.titleAsset.2

{
  "value": "string",
  "link": {
    "url": "string",
    "fallbackUrl": "string",
    "clickTrackers": [
      "string"
    ]
  }
} 

Properties

Name	Type	Required	Description
value	string	true	length 10-70
link	object	false	No description
» url	string	true	length 1-2000
» fallbackUrl	string	false	length 1-2000
» clickTrackers	[string]	false	No description

Reporting API

Query string

The route for the reporting is GET /report/buyer OR GET /report/seller

Choose buyer or seller depending on the type of report you’re wanting

List of parameters

Parameter name	Format	Options Available	Required
range	string	GET /report/options/range	Yes
from	date	YYYY-MM-DD	No
to	date	YYYY-MM-DD	No
interval	string	GET /report/options/interval	Yes
metrics	array	GET /report/options/metrics	Yes
dimensions	array	GET /report/options/dimensions	Yes
filters	array	GET /report/options/filters	No
options	array	GET /report/options/options	No
limit	int	(default: 10)	No
offset	int	(default: 0)	No

Range

GET report/options/range

Range - Example Response

{
    "status": "success",
    "data": {
        "today": "Today",
        "yesterday": "Yesterday",
        "last_7_days": "Last 7 Days",
        "last_48_hours": "Last 48 Hours",
        "month_to_date": "Month to Date",
        "last_month": "Last Month",
        "custom": "Custom"
    }
}

From

Format YYYY-MM-DD. Only required for range: “custom”

To

Format YYYY-MM-DD. Only required for range: “custom”

Interval

GET /report/options/interval

Interval - Example Response

{
    "status": "success",
    "data": {
        "cumulative": "Cumulative",
        "day": "Day",
        "month": "Month"
    }
}

Buyer Metrics

GET /report/options/metrics/buyer

Metrics - Example Response

{
    "status": "success",
    "data": {
        "impressions": "Impressions",
        "clicks": "Clicks",
        "ctr": "CTR",
        "gross": "Gross",
        "totalspend": "Total Spend",
        "mediaspend": "Media Spend",
        "buyerplatformfee": "Buyer Platform Fee",
        "sellerrevenue": "Seller Revenue",
        "sellerplatformfee": "Seller Platform Fee",
        "net": "Net",
        "ecpc": "eCPC",
        "ecpm": "eCPM"
    }
}

Seller Metrics

GET /report/options/metrics/seller

Metrics - Example Response

{
    "status": "success",
    "data": {
        "impressions": "Impressions",
        "clicks": "Clicks",
        "ctr": "CTR",
        "gross": "Gross",
        "totalspend": "Total Spend",
        "mediaspend": "Media Spend",
        "buyerplatformfee": "Buyer Platform Fee",
        "sellerrevenue": "Seller Revenue",
        "sellerplatformfee": "Seller Platform Fee",
        "net": "Net",
        "ecpc": "eCPC",
        "ecpm": "eCPM"
    }
}

Metric Groups

GET /report/options/metrics/groups

Groups - Example Response

{
    "status": "success",
    "data": {
        "core": "Core",
        "revenue": "Revenue",
        "video": "Video"
    }
}

Buyer Metric Groups

GET /report/options/metrics/buyer/group-metrics

Metrics - Example Response

{
    "status": "success",
    "data": {
        "impressions": "core",
        "clicks": "core",
        "postviewconversions": "core",
        "postclickconversions": "core",
        "conversions": "core",
        "ctr": "core",
        "videostart": "video",
        "videofirstquartile": "video",
        "videomidpoint": "video",
        "videothirdquartile": "video",
        "videocomplete": "video",
        "ecpvstart": "video",
        "ecpvfirstquartile": "video",
        "ecpvmidpoint": "video",
        "ecpvthirdquartile": "video",
        "ecpvcomplete": "video",
        "gross": "revenue",
        "totalspend": "revenue",
        "mediaspend": "revenue",
        "buyerplatformfee": "revenue",
        "datafee": "revenue",
        "buyerecpm": "revenue",
        "buyerecpc": "revenue"
    }
}

Seller Metric Groups

GET /report/options/metrics/seller/group-metrics

Metrics - Example Response

{
    "status": "success",
    "data": {
        "impressions": "core",
        "clicks": "core",
        "postviewconversions": "core",
        "postclickconversions": "core",
        "conversions": "core",
        "ctr": "core",
        "videostart": "video",
        "videofirstquartile": "video",
        "videomidpoint": "video",
        "videothirdquartile": "video",
        "videocomplete": "video",
        "ecpvstart": "video",
        "ecpvfirstquartile": "video",
        "ecpvmidpoint": "video",
        "ecpvthirdquartile": "video",
        "ecpvcomplete": "video",
        "net": "revenue",
        "sellerrevenue": "revenue",
        "sellerplatformfee": "revenue",
        "sellerecpm": "revenue",
        "sellerecpc": "revenue"
    }
}

Dimensions

GET /report/options/dimensions

Dimensions - Example Response

{
    "status": "success",
    "data": {
        "seller_account_id": "Seller",
        "buyer_account_id": "Buyer",
        "country": "Country",
        "source": "Source",
        "cid": "Campaign",
        "device_type": "Device Type"
    }
}

Filters

GET /report/options/filters

Filter - Example Response

{
    "status": "success",
    "data": {
        "seller_account_id": "Seller",
        "buyer_account_id": "Buyer",
        "country": "Country",
        "source": "Source",
        "cid": "Campaign",
        "device_type": "Device"
    }
}

To list the option for each filter you can use the following API:

GET /report/options/filters/{filter}/values

This API return paginated content. In order to use the pagination you can use two optional parameters: “limit” and “offset”.

i.e. country

{
    "status": "success",
    "data": {
        "items": {
            "GBR": "United Kingdom",
            "USA": "United States",
            "DEU": "Germany",
            "FRA": "France",
            "AFG": "Afghanistan",
            "ALB": "Albania",
            "DZA": "Algeria",
            "ASM": "American Samoa",
            "AND": "Andorra",
            "AGO": "Angola"
        },
        "limit": 10,
        "offset": 0,
        "totalItems": 227,
        "pages": 23
    }
}

Options

GET /report/options/options

Options - Example Response

{
    "status": "success",
    "data": [
        "showall",
        "total"
    ]
}

Accounts

This parameter is valid just if you are an admin. Accounts allows an array of values in this format:

Query string structure

Parameter name	Syntax
range	range=today
from	[ range=custom& ] from=2015-06-12 [ &to=2015-06-30 ]
to	[ range=custom&from=2015-06-12& ] to=2015-06-30
interval	interval=cumulative
metrics	metrics=impressions,clicks [ ,{metrics},… ]
dimensions	dimensions=inventory_id,campaign_id [ ,{dimensions},… ]
filters	filters=country:GBR,USA,ITA;device_id:1,2,3 [ ;{keyword}:{value},{value};… ]
accounts	accounts=e661785d-4a04-450b-a050-23426a58d3e5,95f8e7ec-9aa7-11e5-8994-feff819cdc9f [ ,{uuid},… ]

Request

curl \
    -H "ApiKey: xM6frL3y7ImCoZiDHKXRVMMkPB2v7PWvRJaPX7RY7n77IMpDwchlLUHSeYpkmqwNPFAbQLX6Cs33ug51rjJ7wrvScBkZUz9FbbbHETqaxW4=" \
    "https://api.powerlinks.com/report?range=yesterday&interval=cumulative&metrics=impressions,clicks&dimensions=inventory_id"

Response

{
    "status": "success",
    "data": {
        "headers": {
            "impressions": "Impressions",
            "clicks": "Clicks",
            "inventory_id": "Inventory"
        },
        "recordset": [
            {
                "impressions": 132336,
                "clicks": 386,
                "inventory_id": ""
            }
        ],
        "limit": 10,
        "offset": 0,
        "totalItems": 1,
        "pages": 1
    }
}

API Keys

Introduction

An API Key is used to temporarily authenticate an external application.

A POST is made to

https://api.powerlinks.com/users/login

with email and password in the body. This will return a temporary API Key.

Request

curl -X POST \
    https://api.powerlinks.com/users/login \
    -d '{
        "email"="EMAIL",
        "password"="PASSWORD"
    }'

Response

{
  "status":"success",
  "data":{
    "apiKey":"gJmil12lO5WRSKHsZ1j46QUvNUM4kBjIOKpH7S9TLA6s0rsv1NZ4Aj7DDXhe5wKG5N6lzRgRYeaYuy4MbrYf4LUZgxa44K0QUyYAXB0PNHMK59vx2tyEIWnXztyomWaL3DV-nwydm3A5vaqp_ghJjxRrfG2TbwJ00U0fRgyHva0",
    "expires":1548427228
  }
}

Using API Keys

The API Key will be added as a custom header “ApiKey” inside the HTTP request for each subsequent request to reporting API routes.

Persistent API Keys

In the case that a persistent API Key is required, a POST request is sent to

https://api.powerlinks.com/api-keys

The API Key header is the temporary API Key from the previous step, while the POST body’s ‘name’ is a descriptive name for the persistent key.

This will return a json response, where the ID is the numeric ID of the persistent key. Then, the persistent API Key can be retrieved by issuing a GET request to

https://api.powerlinks.com/api-keys/<API KEY NUMERIC ID>

Which will return a json response that includes the persistent key.

Request

curl -X POST \
  https://api.powerlinks.com/api-keys \
  -H 'Content-Type: application/json' \
  -H 'apikey: gJmil12lO5WRSKHsZ1j46QUvNUM4kBjIOKpH7S9TLA6s0rsv1NZ4Aj7DDXhe5wKG5N6lzRgRYeaYuy4MbrYf4LUZgxa44K0QUyYAXB0PNHMK59vx2tyEIWnXztyomWaL3DV-nwydm3A5vaqp_ghJjxRrfG2TbwJ00U0fRgyHva0' \
  -d '{
    "name": "persistent-key-name"
  }'

Response

{
    "status": "success",
    "data": {
        "id": 1
    }
}

Request

curl -X GET \
  https://api.powerlinks.com/api-keys/1 \
  -H 'Content-Type: application/json' \
  -H 'apikey: gJmil12lO5WRSKHsZ1j46QUvNUM4kBjIOKpH7S9TLA6s0rsv1NZ4Aj7DDXhe5wKG5N6lzRgRYeaYuy4MbrYf4LUZgxa44K0QUyYAXB0PNHMK59vx2tyEIWnXztyomWaL3DV-nwydm3A5vaqp_ghJjxRrfG2TbwJ00U0fRgyHva0'

Response

{
    "status": "success",
    "data": {
        "id": 1,
        "key": "gJmil12lO5Vu7xM2mikK1TcYk4nGnpRfw0LVQK_dJfZ3VIXUcO4Chyis3XkTo3MW5N6lzRgRYeaYuy4MbrYf4IpQSdCiZv17UyYAXB0PNHMK59vx2tyEIWnXztyomWaL3DV-nwydm3A5vaqp_ghJjxRrfG2TbwJ00U0fRgyHva0",
        "name": "persistent-key-name",
        "createdAt": "2018-01-01",
        "updatedAt": "2018-01-01",
        "deletedAt": ""
    }
}

DFP Support

Powerlinks Support for DFP Ad Servers

Powerlinks ad tags currently come in three varieties:

1) Fixed size tags such as a 300x250 or a 728x90

Typically these can support both native and banner demand, though this is configurable on a per tag basis. These tags build a standard sized ad inside a friendly iFrame of our own construction. These tags are self-styled, with all of the styling logic housed within our iFrame.

2) Responsive tags that responds to the width of its parent container

These tags build raw HTML on the page. They do not construct a friendly iFrame. These tags are self-styled, with all of the styling logic housed within our HTML.

3) Custom markup tags

These tags serve HTML markup that is customized to mimic the host page’s markup. These tags build raw HTML on the page. They do not construct a friendly iFrame. These tags typically rely on the host page to style the ad, and thus must reside on the host page in the correct location within the page’s markup in order to render correctly.

When serving PowerLinks tags through DFP, there are a few considerations.

1) Safe Frames

There is an option in DFP to serve third party tags behind ‘Safe Frames’. We discourage this, as it serves our tag into an unfriendly iFrame. This hinders our, and our buyers’, ability to view the referring URL of the page in many cases. If Safe Frames must be used, the only tag option is #1, where we serve a fixed size tag such as 300x250. A responsive or custom markup tag can not be served into a Safe Frame.

2) 1x1 vs Larger size

If serving a fixed size Powerlinks tag, such as a 300x250, then utilizing a 300x250 DFP tag is preferred. PowerLinks does not need to break out of the 300x250 iframe to serve directly to the page. We are still able to, but there is no need. If this is the case, then the custom instructions below do not apply.

However, for all other cases, including responsive tags and custom markup tags, it may be preferable to serve behind a 1x1 DFP tag. This is because we will need ‘break out’ of the DFP tag in order to sit directly on the host page. This is because for responsive tags, we need to respond to the width of the page’s column, and the friendly iFrame that houses our tag cannot automatically respond to our tag. Custom markup tags will not render correctly, because they will not inherit the requisite styling from the host page.

When we break out of the friendly iFrame, we will leave behind an empty space where the DFP tag is. If we leave behind a 1x1 empty space, that likely isn’t a problem.

If however we are served behind a 300x250, and then break out to create a responsive tag, we will leave behind a 300x250 blank space on the page.

We are capable of collapsing the DFP tag, and we do by default, however this can result in a blank space that shows for some period of time, and then collapses. This may not be a desired behavior, as the blank space may be visible to the user for some period of time.

Steps to create a DFP tag to serve a Powerlinks responsive or custom markup tag:

This also applies to standard fixed size tags IF we are being served behind a 1x1 DFP tag.

1: Create an Ad Unit in the Inventory section. This ideally should be a 1x1.

2: Create a line item and target it to the Inventory created in step 1.

3: Create a third party creative and add it to the line item from step 2.

    3a: Make sure that the ‘Serve into a SafeFrame’ option is unchecked.

    3b: Insert our tag into the Code Snippet field.

    3c: Our tag will include the following: eid=%%PATTERN:elementid%% This must remain intact. The %%PATTERN:elementid%% is something that DFP will recognize.

4: Go to the Generate tags link. Include the inventory in question. Click 'generate tags’

5: Leave tag type as Google Publisher Tag

6: Leave settings in Step 2 as is

7: Grab tag results from Step 3. The following step is very important. Without this step, none of this will work:

8: The 'Document Header’ section will contain code similar to this:

<script async='async' src='https://www.googletagservices.com/tag/js/gpt.js'></script>

<script> var googletag = googletag || {}; googletag.cmd = googletag.cmd || []; </script>

<script> googletag.cmd.push(function() { googletag.defineSlot('/26566907/1x1test', [1, 1], 'div-gpt-ad-1473712237579-0').addService(googletag.pubads()); googletag.pubads().enableSingleRequest(); googletag.enableServices(); }); </script>

In the second part, there is this line:

googletag.defineSlot('/26566907/1x1test', [1, 1], 'div-gpt-ad-1473712237579-0').addService(googletag.pubads());

You must edit that snippet. You will take the bit of text that starts with 'div-gpt-ad…’, and you will do the following:

googletag.defineSlot('/26566907/1x1test', [1, 1], 'div-gpt-ad-1473712237579-0').addService(googletag.pubads()).setTargeting('elementid','div-gpt-ad-1473712237579-0');

So on that line, BEFORE the semi-colon, you will add:

setTargeting('elementid','div-gpt-ad-1473712237579-0')

The value div-gpt-ad-1473712237579-0 must be the same as the value in the original unedited line. This is critical.

The ‘Document Body’ section can remain as is.

When the tag is implemented on the site, and the PowerLinks tag is served, we will use the element ID value that is passed to us to break out of the DFP friendly iframe to sit on the page. We will then collapse the DFP tag that we leave behind.

A general note:

When grabbing the tag from the Powerlinks Dashboard, be sure to select the ‘DFP’ version. This will include macros that DFP can recognize, including a cachebuster, referring URL, and the custom ‘elementid’ macro required for breaking out of the DFP friendly iFrame.