API Guide

Getting Started

This documentation section is designed for 3rd Party Application developers wishing to integrate DCP features into your platform. You must first obtain API credentials from the Hogarth Intelligent Content team. This will allow you to enable features within your application such as:

Trigger automated builds from DCP
Request previews of banners
Provide batch data sources to generate banner variations
Deliver banners to multiple platforms
Obtain and alter approval status

API explorer

Explore our interactive GraphQL interface, which allows you to try the Queries and Mutations described below.

Launch the API Explorer

About GraphQL

If you are new to GraphQL, you should take some time to familiarize yourself with some basic GraphQL concepts before digging into our documentation. There are many great resources to learn GraphQL — to start with, we recommend Introduction to GraphQL and How to GraphQL.

If you're already comfortable with GraphQL, feel free to skip ahead and begin learning about XXXX.

The Basics

Queries and Mutations

GraphQL requests come in two forms: queries and mutations. Queries are used to fetch data from the remote API (like a GET in a REST API). Mutations are used to make a change (like a PUT or a POST in a REST API). Both queries and mutations can take inputs.

In its simplest form, each request starts with the keyword query or mutation, then specifies the field or fields you want to get back in the response.

query {
  campaigns {
    _id
    name
  }
}

The name of the field being requested is campaigns, and it is of type Campaign, so it has the subfields _id and name. This is exactly what you'll receive back in the response.

{
  "data": {
    "campaigns": [
      {
        "_id": "CAMPAIGN_ID_1",
        "name": "CAMPAIGN_NAME_1"
      },
      {
        "_id": "CAMPAIGN_ID_2",
        "name": "CAMPAIGN_NAME_2"
      }
    ]
  }
}

The Explorer

You can take a look at the DCP API schema and try out queries and mutations with the Explorer. Dive in now or read more about using it in the rest of these guides.

Making API Calls

To make any request to the DCP GraphQL API, you make a HTTP POST request to

/api

Each request will also requires an API Key and an Access Token to be passed in the header. Below explains the authorization of the requests in more detail and how you can request your tokens.

Requests

Request Header

To authorize and authenticate a request to the API, you will need to use your API Key, this is required to track your API usage. The DCP GraphQL API uses the OAuth flow for authorization which means you will first need to obtain an Access Token. A typical request header looks like the following

{
  "Content-Type": "application/json",
  "X-Api-Key": "CLIENT_API_KEY",
  "Authorization": "ACCESS_TOKEN"
}

To request an access token you will need to make a HTTP POST request to

/api/token

You will also need to compose your app id and app secret in the following format APP_ID:APP_SECRET, and then Base64 encode them. One way to get the correct format is to run the following from the command line

echo -n "APP_ID:APP_SECRET" | base64

Make sure to strip out all newline characters from the Base64-encoded value and pass the following header in the HTTP POST request to /api/token Using the following headers

Authorization: Basic YOUR_BASE64ENCODED_APP_ID_AND_APP_SECRET

You can also request your Access Token via the command line with cURL:

curl -X POST /api/token -H 'Authorization: Basic YOUR_BASE64ENCODED_APP_ID_AND_APP_SECRET'

If successful you should expect to see a response containing your Access Token to use to authenticate against the API. The response will look like

{
  "access_token": "ACCESS_TOKEN",
  "expires_in": 3600,
  "token_type": "Bearer"
}

Request Body

The request body should be JSON-formatted, with two keys: query and variables. The variables key can be optional depending on the request.

The value for query should be a single string consisting of a correctly formatted GraphQL query or mutation. This will specify what information you want to receive back in the DCP GraphQL API's response.

The value for variables should be the parameters that will be used in the request, in JSON format. For example, when requesting a campaign, variables would consist of the ID for a Campaign.

Here is a typical request body for the campaign query, formatted for readability:

{
  "query": "query ($id: ID!) {
    campaign(id: $id) {
      _id
      name
    }
  }",
  "variables": {
    "id": "CAMPAIGN_ID"
  }
}

Note that the id key in the variables section maps to the $id variable defined by the query in the query section. You can name this key whatever you would like. If the query you're using doesn't take a complex set of parameters, variables can be omitted and instead you have the option to inline the variables into the query field.

For instance, the only thing you need to provide to query for a campaign is a single ID. The campaign ID can be provided in the variables object as above or variables can be omitted and it can be supplied inline in the query object.

{
  "query": "{
    campaign(id: \"CAMPAIGN_ID\") {
      _id
      name
    }
  }"
}

Responses

A response from the GraphQL API will always return with HTTP status 200. The body of the response will determine whether or not an error occurred. Because you can send multiple queries and mutations in a single request, and because GraphQL includes the concept of a "partial success", the request may contain some successful data and some errors. The body is always JSON-formatted and may include any of the three top-level keys: data, errors, and extensions.

Data

A successful query will return a JSON-formatted response with the data you requested in your original query. Each key in the response will exactly match those specified and named in the query.

A successful campaign request as outlined above should return

{
  "data": {
    "campaign": {
      "_id": "CAMPAIGN_ID",
      "name": "CAMPAIGN_NAME"
    }
  },
  "extensions": {}
}

Errors

Unlike a conventional REST API, GraphQL APIs do not rely on HTTP status codes as a way to convey the status of a request. Our GraphQL API should always return a JSON body with the 200 status code, even when there are errors.

If an error occurred, the response body will include a top-level errors object that describes the error or errors. For example, the response for campaign without providing the campaign id would be

{
  "errors": [
    {
      "message": "Field \"campaign\" argument \"id\" of type \"ID!\" is required but not provided.",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ]
    }
  ]
}

Extensions

In addition to data and errors, an extensions object also is present on the API response. Each request you make to the GraphQL API will have a tracing object returned for performance tracing so you can analyse the performance of your queries and mutations.

Using GraphQL Explorer

We've integrated the GraphQL Playground project into our GraphQL documentation to allow you to explore the API in your browser using your API credentials. GraphQL Playground is a graphical interactive IDE for exploring GraphQL APIs.

You can use it via the Explorer on this site, or with the desktop application, to interact with the API in real time. To access the API, authenticate with your API credentials. From there, you can browse the schema documentation and live code queries and mutations.

Rather than passing in a JSON-formatted string, as we show in the examples above, the GraphQL Playground explorer expects plain GraphQL queries and JSON-formatted variables to be entered in separate windows. We will follow this "plain" GraphQL formatting in our guides, so you can easily test-drive queries and mutations in GraphiQL. Just remember to use JSON-formatting when handling your own HTTP requests outside of the GraphQL Playground.

Scope in Hogarth Intelligent Content DCP

There are four available scopes:

Campaign Scope
Template Scope
Editable Group Scope
Editable Group + Template Scope

Overwrites are the way DCP API can customise deliverables. Values (eg text or images) are saved on a specific scope - and the computed result is what will appear within the final creative.

Overwrites are defined at the campaign level for a specific editable with a specific scope. Each scope has a bunch of information being able to uniquely identify it.

Scope Name	Scope	Required fields
campaignScope	Campaign	editableId, campaignId
masterTemplateScope	Campaign + Master Template	editableId, campaignId, masterTemplateId
editableGroupScope	Campaign + Editable Group	editableId, campaignId, editableGroupValueIds
editableGroupAndMasterTemplateScope	Campaign + Editable Group + Master Template	editableId, campaignId, editableGroupValueIds, masterTemplateId

Campaign Scope

This is the weakest overwriting scopes. This means, if some editable has more than one overwrites defined on a specific campaign this scope is the first one ignored. This scope should be used only if we want to have a default value for a specific campaign. Let's say we have a master template editable value: "all campaigns" and we want this particular editable to have a specific value for a specific campaign like: "my current campaign name".

Master Template Scope

This scope has the power to overwrite the campaign scope. If some editable needs to have a specific value in a specific master template - campaign situation, then this is the right scope. For the example above if we need the editable value to be: "my current campaign name for a specific deliverable size", then this is the right scope to be used.

Editable Group Value Scope

This is the most commonly used scope - allowing a unique value per Editable Group Value. Values can be stored at this scope by providing the Editable Group Id as well as the Editable id. This overwriting scope has the power to overwrite a master template scope and campaign scope. An example of using this scope would be to populate a Editable Group called "Products" with Editable Group Values ("Product 1", "Product 2") and populating the Editable regions of a banner with content for each product.

Editable Group Value and Master Template Scope

This is the most powerful overwriting scope. For the example above, if desired value depends also on the deliverable size, then this is the write scope to be used. This scope is a combination between Editable Group and Master Template scopes.

API Quickstart

Campaign setup

Note: These queries and mutations are not currently exposed via the API.

~~Create a campaign using the createCampaign Mutation~~
~~Validate your campaign has been created using the campaigns Query~~
~~Add Master templates to your campaign with addMasterTemplate Mutation~~
~~Validate your templates have been added using the campaigns Query, including the masterTemplates key~~

Using the groupId's and editableId's within your Master Templates, you can begin to add content.

Asset Management

If you need to upload a local asset to DCP API, use the Campaign Query to get the config to allow uploads to the temporary S3 bucket. For an example on how to POST a local file to the bucket see the provided Node.js Example.
Use the Media Items Query to view a list of files and folders in a given directory. If no folderId is passed as a parameter to the query the query will list the root folder.
Add a new asset to the media library using the Upload Media Files mutation.
You can update an existing asset in the media library using the Update Media Files mutation.
To create a sub folder in the media library you can use the Create Media Folder mutation.
If at any time you need to remove a media item you can use the Remove Media mutation.

Adding content

Use the Campaigns Query to identify the available editableGroups on your campaign, and the editables (text and image regions of a banner) that they affect. Make a note of the ID's.
Use the Add Editable Group Value mutation to create an Editable Group. This will allow you to store different values for the Editable Group.
Add new Editable values to your Editable Group, using the overwriteEditablesWithEditableGroupScope mutation.
Repeat this process, adding new EditableGroups and EditableGroupValues to increase the variations within DCP API.
Preview your variations using the Hogarth Intelligent Content Portal interface.

Viewing Ads

Query the API to identify the available editable group values and master templates which compute your deliverable. Example Query. Make a note of the ID's.
Use the Compute Deliverable Preview mutation to generate a preview URL to the Ad.

Queries

Get all campaigns

Retrieve all campaign objects that are visible under your API key. You can also bring back nested details that belong to that campaign, such as the Master Templates in the example below. You can explore all nested options via the API Explorer.

query {
  campaigns {
    _id
    name
    masterTemplates {
      _id
      name
      adType
      height
      width
    }
  }
}

Get campaign by id

If you know the Campaign Id, it is more efficent to make calls using the campaign query, which will return the same information as campaigns, but for a single campaign.

query {
  campaign(id: "CAMPAIGN_ID") {
    _id
    name
  }
}

Get temporary upload config

Get the upload config to allow access to upload to the temporary S3 bucket for the campaign.

query {
  campaign(id: "CAMPAIGN_ID") {
    _id
    name
    temporaryUploadConfig {
      filePrefix
      action
      postData
    }
  }
}

Editable groups by campaign

Display all Editable Groups that exist within a campaign. Editable Groups are added to a campaign automatically, based on which Master Templates have been associated to that campaign. You can use the Editable Group name property, and editables _id properties for saving content using the Overwrite mutations.

query {
  editableGroupsByCampaign(id: "CAMPAIGN_ID") {
    name
    editables {
      _id
      name
      type
      defaultValues {
        masterTemplateId
        value
      }
    }
    editableGroupValues {
      _id
      value
    }
  }
}

Master Templates by campaign

A dedicated query for retrieving Master Templates associated to a campaign. This returns an array of Master Template objects.

query {
  masterTemplatesByCampaign(id: "CAMPAIGN_ID") {
    _id
    name
    adType
    height
    width
    persistentKey
    preview
    collapsed
    created
    modified
    createdBy
    modifiedBy
  }
}

Master Template download URL

This query is used to get a URL for the archive file that was uploaded to create the Master Template in DCP API. The archive will contain all HTML, CSS, JS and other assets that make up the banner. This URL will only be accessible for one hour.

query {
  masterTemplateDownloadUrl(masterTemplateId: "MASTER_TEMPLATE_ID")
}

Editable Group Values and Master Templates

query {
  editableGroupsByCampaign(id: "CAMPAIGN_ID") {
    editableGroupValues {
      _id
      value
    }
  }
  masterTemplatesByCampaign(id: "CAMPAIGN_ID") {
    _id
    name
  }
}

Compute Deliverables

This query computes all the different banner variant combinations (Computed Deliverables) that exist using the combination of Computed Deliverable Identifier components (Editable Group Value IDs, Master Template IDs and Language Codes). These variants can then be filtered by QA Status, Published Status and Visiblity properties. The results are paginated and a maximum of 50 per page can be returned. The preview parameter will determine whether or not the returned overwrite values are prefixed to be proxied through the DCP API preview server, yoou will nearly always want this to be false.

query {
  computeDeliverables(
    campaignId: "CAMPAIGN_ID"
    libraryFilters: {
      filters: {
        editableGroups: [
          {
            name: "GROUP_NAME"
            valueIds: ["EDITABLE_GROUP_VALUE_ID"]
          }
        ],
        masterTemplateIds: ["MASTER_TEMPLATE_ID"]
        languages: ["LANG_CODE"]
      }
      publishedStatus: {
        published: Boolean
        platform: ALL / DOUBLECLICK / SIZMEK
      }
      status: IN_DRAFT / IN_QA / APPROVED / REJECTED
      visibleTo: ["ROLE_ID"]
    }
    preview: Boolean
    page: 1
    perPage: 50
  )
  {
    deliverables {
      _id
      hash
      editableGroupValueIds
      language
      visibleTo
      status
      users {
        user {
          id
          role
        }
        status
      }
      annotations(annotationType: QA / CLIENT) {
        _id
        type
        description
        comments {
          _id
          annotationId
          content
          author
          user
        }
        status
        timeline
        xpos
        ypos
        author
        user

      }
      reportingLabel
      publishedStatus
      masterTemplate {
        _id
        name
        adType
        height
        width
        persistentKey
        preview
        collapsed
        created
        modified
        createdBy
        modifiedBy
      }
      computedValues {
        editableId
        name
        type
        value
      }
    }
    pagination {
      page
      perPage
      maxPage
      total
      totalCount
    }
  }
}

Computed Deliverables

Similar to the comoputeDeliverables query above but can be used when you know exactly which Computed Deliverables you want and you can provide the identifiers. Results are not paginated and generating the computed overwrite values is optional. This query cannot be filtered by QA or published statuses or visibility.

query {
  computedDeliverables(
    campaignId: "CAMPAIGN_ID"
    computedDeliverableIdentifiers: [{
      editableGroupValueIds: ["EDITABLE_GROUP_VALUE_ID"],
      masterTemplateId: "MASTER_TEMPLATE_ID",
      language: "LANG_CODE"
    }]
    computeValues: Boolean
    preview: Boolean
  )
  {
    _id
    hash
    editableGroupValueIds
    language
    visibleTo
    status
    users {
      user {
        id
        role
      }
      status
    }
    annotations(annotationType: QA / CLIENT) {
      _id
      type
      description
      comments {
        _id
        annotationId
        content
        author
        user
      }
      status
      timeline
      xpos
      ypos
      author
      user

    }
    reportingLabel
    publishedStatus
    masterTemplate {
      _id
      name
      adType
      height
      width
      persistentKey
      preview
      collapsed
      created
      modified
      createdBy
      modifiedBy
    }
    computedValues {
      editableId
      name
      type
      value
    }
  }
}

Mutations

Add Editable Group Value

Create a container for Editable content, by creating a new Editable Group Value. You need the editableGroupName (eg "Weather"), and a string to describe your new Editable Group Value (eg. "Rainy").

mutation {
  addEditableGroupValue(
    campaignId: "CAMPAIGN_ID"
    editableGroupName: "EXISTING_EDITABLE_GROUP_NAME"
    value: "NEW_GROUP_NAME_STRING"
  ) {
    _id
    value
  }
}

Update Editable Group Values (Batch)

Update the Editable Group Value Names to new names. This can be a batch operation.

mutation {
  updateEditableGroupValues(
    editableGroupValues: [
      {
        editableGroupValueId: "EXISTING_EDITABLE_GROUP_VALUE_ID"
        value: "NEW_GROUP_NAME_STRING"
      }
      {
        editableGroupValueId: "EXISTING_EDITABLE_GROUP_VALUE_ID"
        value: "NEW_GROUP_NAME_STRING"
      }
    ]
  ) {
    _id
    value
  }
}

Remove Editable Group Values (Batch)

Delete any Editable Group Values. This will also soft delete any Editable values that have been stored under this Editable Group Value. If you add the Editable Group Value back, the Editable values will be restored. This can be a batch operation.

mutation {
  removeEditableGroupValues(
    editableGroupValueIds: ["EDITABLE_GROUP_ID_1", "EDITABLE_GROUP_ID_2"]
  ) {
    _id
    value
  }
}

Overwrite Editables

You should select the correct scope based on how you would like the overrides to compute. You can set the value of an editable by passing through a new value OR mediaId.

Campaign Scope - applies a value across specific editableId's within a campaign

mutation {
  overwriteEditablesWithCampaignScope(
    campaignId: "CAMPAIGN_ID"
    overwrites: [
      {
        editableId: "EDITABLE_ID"
        language: "LANGUAGE_CODE"
        value: "NEW_TEXT_CONTENT"
        mediaId: "MEDIA_ID"
      }
    ]
  ) {
    _id
  }
}

Master Template Scope - applies a value across a specific editableId, within a specific template, within a campaign. Overwrites Campaign Scope.

mutation {
  overwriteEditablesWithMasterTemplateScope(
    campaignId: "CAMPAIGN_ID"
    overwrites: [
      {
        editableId: "EDITABLE_ID"
        masterTemplateId: "MASTER_TEMPLATE_ID"
        language: "LANGUAGE_CODE"
        value: "NEW_TEXT_CONTENT"
        mediaId: "MEDIA_ID"
      }
    ]
  ) {
    _id
  }
}

Editable Group Scope - applies a value across a specific editableId, overwriting Campaign and Master Template scopes.

mutation {
  overwriteEditablesWithEditableGroupScope(
    campaignId: "CAMPAIGN_ID"
    overwrites: [
      {
        editableId: "EDITABLE_ID"
        editableGroupValueIds: ["EDITABLE_GROUP_VALUE_ID_ARRAY"]
        language: "LANGUAGE_CODE"
        value: "NEW_TEXT_CONTENT"
        mediaId: "MEDIA_ID"
      }
    ]
  ) {
    _id
  }
}

Editable Group and Master Template Scope - applies a value across a specific editableId within a specific Master Template, overwriting all other scopes.

mutation {
  overwriteEditablesWithEditableGroupAndMasterTemplateScope(
    campaignId: "CAMPAIGN_ID"
    overwrites: [
      {
        editableId: "EDITABLE_ID"
        masterTemplateId: "MASTER_TEMPLATE_ID"
        editableGroupValueIds: ["EDITABLE_GROUP_VALUE_ID_ARRAY"]
        language: "LANGUAGE_CODE"
        value: "NEW_TEXT_CONTENT"
        mediaId: "MEDIA_ID"
      }
    ]
  ) {
    _id
  }
}

Single mutation for all scopes. For convenience, you can use a single mutation for Overwrites. Simply select the desired scope and pass through the values as per the above examples. You can also pass through multiple scopes in the same mutation.

mutation {
  overwriteEditables(
    campaignId: "CAMPAIGN_ID",
    campaignScoped: [...],
    masterTemplateScoped: [...],
    editableGroupScoped: [...],
    editableGroupAndMasterTemplateScoped: [...]
  ) {
    _id
  }
}

Example of using the overwriteEditables mutation on a editableGroup Scope:

mutation {
  overwriteEditables(
    campaignId: "CAMPAIGN_ID",
    editableGroupScoped: [
      campaignId: "CAMPAIGN_ID",
      overwrites: [{
        editableId: "EDITABLE_ID",
        editableGroupValueIds: ["EDITABLE_GROUP_VALUE_ID_ARRAY"],
        language: "LANGUAGE_CODE",
        value: "NEW_TEXT_CONTENT",
        mediaId: "MEDIA_ID"
      }]
    ]) {
      _id
    }
}

Restore Editables to Default Values

Remove all scopes stored against an Editable and reset it to the Default value stored in the Master Template

mutation {
  restoreEditableToDefaultValue(
    campaignId: "CAMPAIGN_ID"
    editableId: "EDITABLE_ID"
  )
}

Compute Deliverable Preview

Genrate preview URL to a computed deliverable. Lanuage is optional and if not pass will default to "en".

mutation {
  computeDeliverablePreview(
    campaignId: "CAMPAIGN_ID"
    computedDeliverableIdentifiers: [
      {
        editableGroupValueIds: ["EDITABLE_GROUP_VALUE_ID_ARRAY"]
        masterTemplateId: "MASTER_TEMPLATE_ID"
        language: "LANGUAGE_CODE"
      }
    ]
  )
}

Get media items

Get a list of media items in the root folder or a given sub folder.

query {
  mediaItems {
    id
    folderId
    type
    persistentKey
    url
    name
    author
    info {
      contentLength
      created
    }
  }
}

query {
  mediaItems(folderId: "MEDIA_FOLDER_ID")) {
    id
    name
  }
}

Upload media files

Upload an asset to either the root folder or a given sub folder.

mutation {
  uploadMediaFiles(
    files: [{ name: "FILE_NAME", temporaryPath: "TEMPORARY_BUCKET_KEY" }]
  ) {
    id
    folderId
    name
  }
}

mutation {
  uploadMediaFiles(
    folderId: "MEDIA_FOLDER_ID"
    files: [{ name: "FILE_NAME", temporaryPath: "TEMPORARY_BUCKET_KEY" }]
  ) {
    id
    folderId
    name
  }
}

Alternatively you can upload an asset from an 3rd part URL.

mutation {
  uploadMediaFiles(
    folderId: "MEDIA_FOLDER_ID"
    files: [{ name: "FILE_NAME", url: "3RD_PARTY_URL" }]
  ) {
    id
    folderId
    name
  }
}

Update media files

Update an asset in either the root folder or a given sub folder.

mutation {
  updateMediaFiles(
    files: [
      {
        name: "FILE_NAME"
        fileId: "FILE_ID"
        temporaryPath: "TEMPORARY_BUCKET_KEY"
      }
    ]
  ) {
    id
    folderId
    name
  }
}

mutation {
  updateMediaFiles(
    folderId: "MEDIA_FOLDER_ID"
    files: [
      {
        name: "FILE_NAME"
        fileId: "FILE_ID"
        temporaryPath: "TEMPORARY_BUCKET_KEY"
      }
    ]
  ) {
    id
    folderId
    name
  }
}

Alternatively you can update an asset from an 3rd part URL.

mutation {
  updateMediaFiles(
    folderId: "MEDIA_FOLDER_ID"
    files: [{ name: "FILE_NAME", fileId: "FILE_ID", url: "3RD_PARTY_URL" }]
  ) {
    id
    folderId
    name
  }
}

Create media folder

Create a folder in either the root folder or a given sub folder.

mutation {
  createMediaFolder(newFolderName: "FOLDER_NAME") {
    id
    folderId
    name
  }
}

mutation {
  createMediaFolder(folderId: "MEDIA_FOLDER_ID", newFolderName: "FOLDER_NAME") {
    id
    folderId
    name
  }
}

Remove media

Remove an item from the media library.

mutation {
  removeMedia(mediaIds: ["MEDIA_ID_1", "MEDIA_ID_2"]) {
    id
  }
}

Generate Video

Starts a job to generate a video file from a HTML webpage. The response will contain the jobId. Once a job has been started its status can be checked by polling the getJob query. Once complete a link to the produced file will be emailed to the provided address and will be added to the payload of the job.

url, width, height, duration and email are all required parameters. An error will be thrown if the email address is invalid or the duration is higher than 120.

mutation {
  generateVideo(
    url: "https://example.com/index.html"
    width: 1080
    height: 1920
    duration: 15
    email: "me@example.com"
  ) {
    _id
    createdBy {
      id
      name
    }
  }
}

Get Job

This query can be used to check the status of a job. All of the data about the current state of the job can be see in the payload key. Long running jobs will have a progress key in the payload which contains a status for each of the items in the job.

query {
  job(jobId: "JOB_ID") {
    _id
    createdBy {
      id
      name
    }
    payload
  }
}

Code Examples

Upload local file to Temporary S3 Bucket (Node.js)

const fs = require("fs");
const request = require("request");
// Local asset information
const pathToFile = __dirname;
const filename = "logo.jpg";
// temporaryUploadConfig received from API
const temporaryUploadConfig = {
  filePrefix: "PREFIX_FOR_S3_KEY",
  action: "UPLOAD_URL",
  postData: "UPLOAD_POST_DATA"
};
// Build upload file from filePrefix and filename
temporaryUploadConfig.postData = JSON.parse(temporaryUploadConfig.postData);
temporaryUploadConfig.postData.key = `${temporaryUploadConfig.filePrefix}/${filename}`;
// Set upload options
const options = {
  method: "POST",
  url: temporaryUploadConfig.action,
  headers: {
    "Content-Type": "multipart/form-data"
  },
  formData: {}
};
// Append postData to formData
Object.keys(temporaryUploadConfig.postData).forEach(key => {
  options.formData[key] = temporaryUploadConfig.postData[key];
});
// Read local file to formData
options.formData.file = fs.createReadStream(`${pathToFile}/${filename}`);
// Post data to tmpUrl
request(options, (err, res, body) => {
  if (err) {
    throw err;
  }

  console.log(options.formData.key);
});

# API Guide

# Getting Started

# API explorer

# About GraphQL

# The Basics

# Queries and Mutations

# The Explorer

# Making API Calls

# Requests

# Request Header

# Request Body

# Responses

# Data

# Errors

# Extensions

# Using GraphQL Explorer

# Scope in Hogarth Intelligent Content DCP

# Campaign Scope

# Master Template Scope

# Editable Group Value Scope

# Editable Group Value and Master Template Scope

# API Quickstart

# Campaign setup

# Asset Management

# Adding content

# Viewing Ads

# Queries

# Get all campaigns

# Get campaign by id

# Get temporary upload config

# Editable groups by campaign

# Master Templates by campaign

# Master Template download URL

# Editable Group Values and Master Templates

# Compute Deliverables

# Computed Deliverables

# Mutations

# Add Editable Group Value

# Update Editable Group Values (Batch)

# Remove Editable Group Values (Batch)

# Overwrite Editables

# Restore Editables to Default Values

# Compute Deliverable Preview

# Get media items

# Upload media files

# Update media files

# Create media folder

# Remove media

# Generate Video

# Get Job

# Code Examples

# Upload local file to Temporary S3 Bucket (Node.js)