MENU
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Getting Started

Overview

This is a living document, intended to help you enjoy working with Brandfolder's API.

By activating or using the Brandfolder API, you acknowledge and agree to the API License Agreement found here.

V4 is a RESTful JSON API giving you programmatic access to the same resources you can access as a user of our website.

You're probably wondering, "Which resources are those?" Well each one has its own section in this documentation for you to learn in more detail exactly what operations you can perform in relation to that particular resource, but a bit of an overview here might be helpful.

As a Brandfolder user, you are part of one or more Organizations.

Organizations can have multiple Brandfolders.

Brandfolders have Sections which hold Assets.

Assets can also belong to multiple Collections within a Brandfolder.

Assets have Attachments and can also have Tags and Custom Fields.

You can also send Invitations to grant users access to Organizations, Brandfolders, and Collections.

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Authentication

Authentication is performed with every API call by sending a header with your unique Brandfolder API key.

The required header in each request is:

Authorization: Bearer {BF_API_KEY}

Each response to your API calls will only include the resources that you (or the User whose API key your application is using) can access based on your permissions.

Making Requests

All V4 requests are made via the following URL:

https://brandfolder.com/api/v4 + resource endpoint

When using our examples in your code, you'll need to make sure to replace {organization_id} (or any other resource ID like {asset_id}) with the actual ID for the desired resource.

For example, Fetch an Organization shows the endpoint as GET /organizations/{organization_id}. If you wish to fetch information about an Organization with an ID of plqlkk-22rw6g-3dqgx0, then this means you need to make an HTTP request with a method of GET to https://brandfolder.com/api/v4/organizations/plqlkk-22rw6g-3dqgx0

We provide a list of valid parameters for each API endpoint. You can click on any of them to see more information about how to use it in the Parameters section.

If our API responds to your request with an error, please see Troubleshooting to understand what may have gone wrong.

Organizations

An Organization is the top level resource of all objects in Brandfolder. It can have many Brandfolders nested beneath it.

List Organizations

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/organizations \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/organizations',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/organizations',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/organizations", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-cocc75",
      "type": "organizations",
      "attributes": {
        "name": "Brandfolder's Organization",
        "tagline": "An example tagline for the Organization",
        "slug": "brandfolder-organization"
      }
    }
  ]
}

GET /organizations

Lists all Organizations for a User. Unauthorized requests will return an empty list.

You can use the returned slug attribute to form a link to the desired Organization like so:

https://brandfolder.com/organizations/{slug}

Optional URL Parameters

Name Allowed Values
fields asset_count
include brandfolders, collections, portals, brandguides

Fetch an Organization

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/organizations/{organization_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations/{organization_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations/{organization_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/organizations/{organization_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/organizations/{organization_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations/{organization_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/organizations/{organization_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-cocc75",
    "type": "organizations",
    "attributes": {
      "name": "Brandfolder's Organization",
      "tagline": "An example tagline for the Organization",
      "slug": "brandfolder-organization"
    }
  }
}

GET /organizations/{organization_id}

You can use the returned slug attribute to form a link to the desired Organization like so:

https://brandfolder.com/organizations/{slug}

Optional URL Parameters

Name Allowed Values
fields asset_count
include brandfolders, collections, portals, brandguides, assets

List Assets in an Organization

See List Assets.

List Attachments in an Organization

See List Attachments.

List Invitations to an Organization

See List Invitations.

Create an Invitation to an Organization

See Create an Invitation.

List Brandfolders in an Organization

See List Brandfolders.

Create a Brandfolder in an Organization

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers
var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/organizations/{organization_id}/brandfolders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Brandfolder",
      "tagline": "You expected this - Brandfolder's Brandfolder!",
      "privacy": "public",
      "slug": "brandfolder"
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgiju-21olts-ce9egi",
    "type": "brandfolders",
    "attributes": {
      "name": "Brandfolder",
      "tagline": "You expected this - Brandfolder's Brandfolder!",
      "privacy": "public",
      "slug": "brandfolder"
    }
  }
}

POST /organizations/{organiation_id}/brandfolders

Request Body

Attribute Allowed Values Notes
name String
slug String of letters, numbers, hyphens, and underscores Optional, we recommend not to invent your own slug. If it is not unique and valid, the request will fail with a 422 error. Default is to automatically assign a slug based on name (a name of "My Brandfolder" would make a slug of "my-brandfolder")
tagline String Optional, defaults to null

Brandfolders

Brandfolders are nested directly underneath an Organization in the overall heirarchy. They can have many Collections, Sections, and Assets.

List Brandfolders

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgiju-21olts-ce9egi",
      "type": "brandfolders",
      "attributes": {
        "name": "Brandfolder",
        "tagline": "You expected this - Brandfolder's Brandfolder!",
        "privacy": "public",
        "slug": "brandfolder"
      }
    }
  ]
}

GET /brandfolders

Lists all Brandfolders for a User. Unauthorized requests will return an empty list.

You can use the returned slug attribute to form a link to the desired Brandfolder like so:

https://brandfolder.com/{slug}

Optional URL Parameters

Name Allowed Values
search Any URI-encoded query
fields asset_count, attachment_count, storage
include organization, collections, assets

Fetch a Brandfolder

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgiju-21olts-ce9egi",
    "type": "brandfolders",
    "attributes": {
      "name": "Brandfolder",
      "tagline": "You expected this - Brandfolder's Brandfolder!",
      "privacy": "public",
      "slug": "brandfolder"
    }
  }
}

GET /brandfolders/{brandfolder_id}

You can use the returned slug attribute to form a link to the desired Brandfolder like so:

https://brandfolder.com/{slug}

Optional URL Parameters

Name Allowed Values
fields asset_count, attachment_count, section_count
include organization, sections, collections, search_filters

List Sections in a Brandfolder

See List Sections.

Create a Section in a Brandfolder

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Test Section",
      "default_asset_type": "GenericFile",
      "position": 0
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Test Section",
      "default_asset_type": "GenericFile",
      "position": 0
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgol8-dslwxs-58b2z3",
    "type": "sections",
    "attributes": {
      "name": "Test Section",
      "default_asset_type": "GenericFile",
      "position": 0
    }
  }
}

POST /brandfolders/{brandfolder_id}/sections

Request Body

Attribute Allowed Values Notes
name String
default_asset_type GenericFile, Color, Font, ExternalMedium, Person, Press, Text We strongly recommend using GenericFile when Assets will be added to the Section via the API.
position Non-negative integer Optional, defaults to the last position. This is where the new Section is displayed relative to other Sections. 0 means it will be first.

List Collections in a Brandfolder

See List Collections.

Create a Collection in a Brandfolder

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Brandfolder - Print Ready",
      "slug": "print-ready",
      "tagline": "All Brandfolder's assets that are ready for print"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Brandfolder - Print Ready",
      "slug": "print-ready",
      "tagline": "All Brandfolder's assets that are ready for print"
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-hh142d",
    "type": "collections",
    "attributes": {
      "name": "Brandfolder - Print Ready",
      "slug": "print-ready",
      "tagline": "All Brandfolder's assets that are ready for print",
      "public": true,
      "stealth": false
    }
  }
}

POST /brandfolders/{brandfolder_id}/collections

Request Body

Attribute Allowed Values Notes
name String
slug String of letters, numbers, hyphens, and underscores Optional, we recommend not to invent your own slug. If it is not unique and valid, the request will fail with a 422 error. Default is to automatically assign a slug based on name (a name of "My Collection" would make a slug of "my-collection")
tagline String Optional, defaults to null

List Assets in a Brandfolder

See List Assets.

Create Assets in a Brandfolder

See Create Assets.

List Attachments in a Brandfolder

See List Attachments.

List Custom Field Keys for a Brandfolder

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": [
        {
            "id": "plqlkk-22rw6g-3dqgx0",
            "type": "custom_field_keys",
            "attributes": {
                "name": "color",
                "allowed_values": [
                    "blue",
                    "red",
                    "white"
                ],
                "restricted": true
            }
        },
        {
            "id": "pfse7g-otvs8-3m6kbf",
            "type": "custom_field_keys",
            "attributes": {
                "name": "sku",
                "allowed_values": [],
                "restricted": false
            }
        }
    ]
}

This endpoint is useful for seeing all the keys that have been used in Custom Fields on Assets within a particular Brandfolder.

GET /brandfolders/{brandfolder_id}/custom_field_keys

Optional URL Parameters

Name Allowed Values
fields values
include custom_field_values

Create Custom Field Keys for a Brandfolder

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": [
        {
          "name": "color",
          "allowed_values": ["red", "white", "blue"]
        },
        {
          "name": "sku"
        }
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": [
        {
          "name": "color",
          "allowed_values": ["red", "white", "blue"]
        },
        {
          "name": "sku"
        }
    ]
  }
}

Example JSON Response

{
    "data": [
        {
            "id": "plqlkk-22rw6g-3dqgx0",
            "type": "custom_field_keys",
            "attributes": {
                "name": "color",
                "allowed_values": [
                    "blue",
                    "red",
                    "white"
                ],
                "restricted": true
            }
        },
        {
            "id": "pfse7g-otvs8-3m6kbf",
            "type": "custom_field_keys",
            "attributes": {
                "name": "sku",
                "allowed_values": [],
                "restricted": false
            }
        }
    ]
}

This endpoint is only needed for setting up controlled Custom Fields. If this is enabled for your Brandfolder, you can set the allowed keys and optionally restrict their allowed values for Custom Fields using this endpoint.

POST /brandfolders/{brandfolder_id}/custom_field_keys

Request Body

Attribute Allowed Values Notes
name String This will be the key.
allowed_values Array of strings Optional, the value that can be used with this key when creating or updating any Custom Field on an Asset must be one of these strings. If not included or empty array [], the values are not restricted.

List Invitations to a Brandfolder

See List Invitations.

Create an Invitation to a Brandfolder

See Create an Invitation.

Collections

Collections are nested under a Brandfolder and contain many Assets. They are mainly used as an additional way to organize, manage, share, and restrict access to a subset of Assets within your Brandfolder without having to upload Assets to multiple places.

List Collections

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/collections \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/collections HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/collections',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/collections',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/collections',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/collections', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/collections");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/collections", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-hh142d",
      "type": "collections",
      "attributes": {
        "name": "Brandfolder - Print Ready",
        "slug": "print-ready",
        "tagline": "All Brandfolder's assets that are ready for print",
        "public": true,
        "stealth": false
      }
    }
  ]
}

...that a User can access

GET /collections

Unauthorized requests will return an empty list.

...within a Brandfolder

GET /brandfolders/{brandfolder_id}/collections

You can use the returned slug parameter (in conjunction with the slug of the parent Brandfolder) to form a link to the desired Collection like so:

https://brandfolder.com/{brandfolder_slug}/{collection_slug}

Optional URL Parameters

Name Allowed Values
fields asset_count
include brandfolder, assets

Fetch a Collection

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/collections/{collection_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/collections/{collection_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/collections/{collection_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/collections/{collection_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/collections/{collection_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/collections/{collection_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/collections/{collection_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/collections/{collection_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-hh142d",
    "type": "collections",
    "attributes": {
      "name": "Brandfolder - Print Ready",
      "slug": "print-ready",
      "tagline": "All Brandfolder's assets that are ready for print",
      "public": true,
      "stealth": false
    }
  }
}

GET /collections/{collection_id}

You can use the returned slug parameter (in conjunction with the slug of the parent Brandfolder) to form a link to the desired Collection like so:

https://brandfolder.com/{brandfolder_slug}/{collection_slug}

Optional URL Parameters

Name Allowed Values
fields asset_count
include brandfolder, assets, search_filters

Create a Collection

See Create a Collection in a Brandfolder.

Update a Collection

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/collections/{collection_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/collections/{collection_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/collections/{collection_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Updated Name",
      "slug": "updated-name",
      "tagline": "Updated Tagline"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/collections/{collection_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/collections/{collection_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/collections/{collection_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/collections/{collection_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/collections/{collection_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Updated Name",
      "slug": "updated-name",
      "tagline": "Updated Tagline"
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-hh142d",
    "type": "collections",
    "attributes": {
      "name": "Updated Name",
      "slug": "updated-name",
      "tagline": "Updated Tagline",
      "public": true,
      "stealth": false
    }
  }
}

PUT /collections/{collection_id}

Request Body

Attribute Allowed Values Notes
name String
slug String of letters, numbers, hyphens, and underscores We recommend not to invent your own slug. If it is not unique and valid, the request will fail with a 422 error. Default is to automatically assign a slug based on name (a name of "My Collection" would make a slug of "my-collection").
tagline String

Delete a Collection

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/collections/{collection_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/collections/{collection_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/collections/{collection_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/collections/{collection_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/collections/{collection_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/collections/{collection_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/collections/{collection_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/collections/{collection_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /collections/{collection_id}

List Assets in a Collection

See List Assets.

Create Assets in a Collection

See Create Assets.

List Attachments in a Collection

See List Attachments.

List Invitations to a Collection

See List Invitations.

Create an Invitation to a Collection

See Create an Invitation.

Sections

Sections are nested under a Brandfolder and contain many Assets. They exist to help keep Assets organized within a Brandfolder. They also determine which type of digital assets can be uploaded within them (files, external media, fonts, etc.).

List Sections

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgol8-dslwxs-58b2z3",
      "type": "sections",
      "attributes": {
        "name": "Logos",
        "default_asset_type": "GenericFile",
        "position": 0
      }
    }
  ]
}

GET /brandfolders/{brandfolder_id}/sections

Optional URL Parameters

Name Allowed Values
include requested Section. Valid Sectionbrandfolder, assets

Fetch a Section

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/sections/{section_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/sections/{section_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/sections/{section_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/sections/{section_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/sections/{section_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/sections/{section_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/sections/{section_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/sections/{section_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgol8-dslwxs-58b2z3",
    "type": "sections",
    "attributes": {
      "name": "Logos",
      "default_asset_type": "GenericFile",
      "position": 0
    }
  }
}

GET /sections/{section_id}

Optional URL Parameters

Name Allowed Values
include requested Section. Valid Sectionbrandfolder, assets

Create a Section

See Create a Section in a Brandfolder.

Assets

Assets are the core resource of Brandfolder. They act like containers that hold all of your digital resources and files, which we call Attachments. They belong to a Section in a Brandfolder and can also exist within many Collections.

List Assets

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com?Expires=1624742369",
        "approved": true
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com?Expires=1624742369",
        "approved": false
      }
    }
  ],
  "meta": {
    "total_count": 2
  }
}

...within an Organization

GET /organizations/{organization_id}/assets

...within a Brandfolder

GET /brandfolders/{brandfolder_id}/assets

...within a Collection

GET /collections/{collection_id}/assets

...within a Label

GET /labels/{label_id}/assets

Optional URL Parameters

Name Allowed Values
page Any positive integer
per Any positive integer up to 3000. Default value is 100
search Any URI-encoded query
fields created_at, updated_at, cdn_url, availability
include brandfolder, section, collections, attachments, tags, custom_fields

Fetch an Asset

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/assets/{asset_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/assets/{asset_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/assets/{asset_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-443db",
    "type": "generic_files",
    "attributes": {
      "name": "Brandfolder Logo",
      "description": "Brandfolder's logo in print ready format",
      "thumbnail_url": "https://example.com/example.jpg?Expires=1624742369",
      "approved": true
    }
  }
}

GET /assets/{asset_id}

Optional URL Parameters

Name Allowed Values
fields created_at, updated_at, cdn_url, availability, availability_start, availability_end
include brandfolder, section, collections, attachments, tags, custom_fields

Create Assets

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": [
      {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready format",
        "availability_start": "2021-02-23T18:22:49.771Z",
        "availability_end": "2022-02-23T18:22:49.771Z",
        "attachments": [
          {
            "url": "https://example.com/brandfolder.pdf",
            "filename": "brandfolder_logo.pdf"
          }
        ]
      }
    ]
  },
  "section_key": "oqgol8-dslwxs-58b2z3"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": [
      {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready format",
        "availability_start": "2021-02-23T18:22:49.771Z",
        "availability_end": "2022-02-23T18:22:49.771Z",
        "attachments": [
          {
            "url": "https://example.com/brandfolder.pdf",
            "filename": "brandfolder_logo.pdf"
          }
        ]
      }
    ]
  },
  "section_key": "oqgol8-dslwxs-58b2z3"
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready format",
        "thumbnail_url": "https://example.com/brandfolder.pdf?Expires=1624742369",
        "approved": true
      }
    }
  ]
}

...within a Brandfolder

POST /brandfolders/{brandfolder_id}/assets

...within a Collection

POST /collections/{collection_id}/assets

Any files you wish to use as an Attachment in Brandfolder must be hosted at a publicly available URL (until they have been successfully imported). If you need to upload file contents directly to a server, you can use do a binary file upload to our temporary storage bucket and then use that URL when creating Assets/Attachments.

Request Body

Attribute Allowed Values Notes
name String
description String Optional
availability_start String Optional, This represents the publish/availability date in Brandfolder, the label "draft" will show
availability_end String Optional, This represents the expiration date in brandfolder, the label "expired" will show
attachments Array of Attachment objects Optional, if not included or empty [] then no Attachments will be created for this Asset. We recommended creating at least 1 Attachment with the Asset.
url (attachments) Fully formed URL of the file to upload
filename (attachments) String Full filename with extension, i.e. logo_image.jpg
section_key String ID of the Section in which you want the newly created Asset(s) to live.

Update an Asset

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/assets/{asset_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/assets/{asset_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Updated Name",
      "description": "Updated Description",
      "availability_start": "2021-02-23T18:22:49.771Z",
      "availability_end": "2022-02-23T18:22:49.771Z",
      "attachments": [
        {
          "url": "https://example.com/new-attachment.jpg",
          "filename": "new-attachment.jpg"
        },
        {
          "url": "https://example.com/another-attachment.jpg"
        }
      ]
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/assets/{asset_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Updated Name",
      "description": "Updated Description",
      "availability_start": "2021-02-23T18:22:49.771Z",
      "availability_end": "2022-02-23T18:22:49.771Z",
      "attachments": [
        {
          "url": "https://example.com/new-attachment.jpg",
          "filename": "new-attachment.jpg"
        },
        {
          "url": "https://example.com/another-attachment.jpg"
        }
      ]
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr5iv4-443db",
    "type": "generic_files",
    "attributes": {
      "name": "Updated Name",
      "description": "Updated Description",
      "thumbnail_url": "https://example.com/example.jpg?Expires=1624742369",
      "approved": true
    }
  }
}

PUT /assets/{asset_id}

Request Body

Attribute Allowed Values Notes
name String
description String
availability_start String This represents the publish/availability date in Brandfolder, the label "draft" will show
availability_end String This represents the expiration date in brandfolder, the label "expired" will show
attachments Array of Attachment objects to add to the Asset (these do not overwrite exisiting Attachments)
url (attachments) Fully formed URL of the file to upload (required for each new Attachment)
filename (attachments) String Full filename with extension, i.e. logo_image.jpg

Delete an Asset

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/assets/{asset_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/assets/{asset_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/assets/{asset_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/assets/{asset_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/assets/{asset_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /assets/{asset_id}

List Attachments on an Asset

See List Attachments.

List Tags for an Asset

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/assets/{asset_id}/tags \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/assets/{asset_id}/tags HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}/tags',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}/tags',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/assets/{asset_id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/assets/{asset_id}/tags', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_id}/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/assets/{asset_id}/tags", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "a3dlao-hd6so4-7d91d2",
      "type": "tags",
      "attributes": {
        "name": "product",
        "auto_generated": false
      }
    },
    {
      "id": "7d9df0-hs8kck-lapd74",
      "type": "tags",
      "attributes": {
        "name": "logo",
        "auto_generated": false
      }
    }
  ]
}

GET /assets/{asset_id}/tags

See Tags for more information.

Optional URL Parameters

Name Allowed Values
include asset

List Custom Field Values for an Asset

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/assets/{asset_id}/custom_field_values", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "mn8bswhbtm47cjqxvzx98k66",
      "type": "custom_field_values",
      "attributes": {
          "key": "Team",
          "value": "Product"
      }
    },
    {
      "id": "r79p3j4gbcgtv33gbsqrxb",
      "type": "custom_field_values",
      "attributes": {
          "key": "Campaign",
          "value": "Fall"
      }
    },
    {
      "id": "8m95q6t6n9bpv8q3ctpfpr",
      "type": "custom_field_values",
      "attributes": {
          "key": "Language",
          "value": "Spanish"
      }
    }
  ]
}

GET /assets/{asset_id}/custom_field_values

See Custom Fields for more information.

Optional URL Parameters

Name Allowed Values
include custom_field_key

Create Tags for an Asset

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/assets/{asset_id}/tags \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/assets/{asset_id}/tags HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/assets/{asset_id}/tags',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": [
      {
        "name": "logo"
      },
      {
        "name": "product"
      }
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}/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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/assets/{asset_id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/assets/{asset_id}/tags', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_id}/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/assets/{asset_id}/tags", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": [
      {
        "name": "logo"
      },
      {
        "name": "product"
      }
    ]
  }
}

Example JSON Response

{
  "data": [
    {
      "id": "a3dlao-hd6so4-7d91d2",
      "type": "tags",
      "attributes": {
        "name": "product",
        "auto_generated": false
      }
    },
    {
      "id": "7d9df0-hs8kck-lapd74",
      "type": "tags",
      "attributes": {
        "name": "logo",
        "auto_generated": false
      }
    },
    {
      "id": "7d9123-hs8asd-asd789",
      "type": "tags",
      "attributes": {
        "name": "pizza",
        "auto_generated": true
      }
    }
  ]
}

POST /assets/{asset_id}/tags

See Tags for more information.

Request Body

Attribute Allowed Values
name String

Create Custom Fields for an Asset

In order to use this endpoint, you will need to have the Custom Field Key ID for the Custom Field you wish to create. Please see List Custom Field Keys for a Brandfolder to get a list of the Custom Field Key IDs.

Want to learn more about Custom Fields? Check out out our Knowledge Base article on Custom Fields.

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  { 
  "data":
    [
      {
        "attributes": {
          "value": "product"
        },
        "relationships": {
          "asset": {
            "data": { "type": "assets", "id": "k5nj2bf5mc36j3ssm63359h" }
          }
        }
      }
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}/custom_field_values", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{ 
  "data":
  [
    {
      "attributes": {
        "value": "product"
      },
      "relationships": {
        "asset": {
          "data": { "type": "assets", "id": "k5nj2bf5mc36j3ssm63359h" }
        }
      }
    },
    {
      "attributes": {
        "value": "marketing"
      },
      "relationships": {
        "asset": {
          "data": { "type": "assets", "id": "oqgkkd-fr5iv4-443db" }
        }
      }
    }
  ]
}

Example JSON Response

{
  "data": [
    {
      "id": "ouudxr-cvimd4-9r3769",
      "type": "custom_field_values",
      "attributes": {
        "key": "team",
        "value": "product"
      }
    },
    {
      "id": "ouudxs-1bris0-7x06j8",
      "type": "custom_field_values",
      "attributes": {
        "key": "team",
        "value": "marketing"
      }
    }
  ]
}

POST /custom_field_keys/{custom_field_key_id}/custom_field_values

Request Body

Attribute Allowed Values
value String
type "assets"
id String

Attachments

Attachments are the representation of digital assets in Brandfolder. Generally speaking, they are actual files but can also be colors, fonts, links to embedded/external media, etc. They belong to an Asset and contain extra metadata related to the files they represent.

List Attachments

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/attachments", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr3j84-33j7db",
      "type": "attachments",
      "attributes": {
        "filename": "brandfolder_logo.png",
        "mimetype": "image/png",
        "url": "https://example.com/brandfolder_logo.png?expiry=1625260667",
        "size": 123456,
        "width": 1920,
        "height": 1080,
        "position": 0
      }
    }
  ]
}

...within an Organization

GET /organizations/{organization_id}/attachments

...within a Brandfolder

GET /brandfolders/{brandfolder_id}/attachments

...within a Collection

GET /collections/{collection_id}/attachments

...on an Asset

GET /assets/{asset_id}/attachments

Optional URL Parameters

Name Allowed Values
page Any positive integer
per Any positive integer up to 3000. Default value is 100
search Any URI-encoded query
fields metadata, thumbnail_url, view_thumbnail_retina, extension, version_count, tag_names, label_names
include asset, section, brandfolder, collections, tags, labels

Fetch an Attachment

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/attachments/{attachment_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/attachments/{attachment_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/attachments/{attachment_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/attachments/{attachment_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/attachments/{attachment_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/attachments/{attachment_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr3j84-33j7db",
    "type": "attachments",
    "attributes": {
      "filename": "brandfolder_logo.png",
      "mimetype": "image/png",
      "url": "https://example.com/brandfolder_logo.png?expiry=1625260667",
      "size": 123456,
      "width": 1920,
      "height": 1080,
      "position": 0
    }
  }
}

GET /attachments/{attachment_id}

Optional URL Parameters

Name Allowed Values
fields metadata, thumbnail_url, view_thumbnail_retina, extension, version_count, tag_names, label_names
include asset, section, brandfolder, collections, tags, labels

Create Attachments

Attachments are created when you create or update their parent Asset.

See Create Assets and Update an Asset for more information.

Update an Attachment

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/attachments/{attachment_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/attachments/{attachment_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Updated Name",
      "description": "Updated Description",
      "attachments": [
        {
          "url": "https://example.com/new-attachment.jpg",
          "filename": "new-attachment.jpg"
        },
        {
          "url": "https://example.com/another-attachment.jpg"
        }
      ]
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/attachments/{attachment_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/attachments/{attachment_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/attachments/{attachment_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/attachments/{attachment_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "url": "https://path_to_file/updated_filename.jpg",
      "filename": "updated_filename.jpg"
    }
  }
}

Example JSON Response

{
    "data": {
        "id": "oqgkkd-fr3j84-33j7db",
        "type": "attachments",
        "attributes": {
            "mimetype": null,
            "filename": "updated_filename.jpg",
            "size": null,
            "width": null,
            "height": null,
            "url": "https://path_to_file/updated_filename.jpg?expiry=1625260667",
            "position": 0
        }
    }
}

PUT /attachments/{attachment_id}

Request Body

Attribute Allowed Values
url Fully formed URL of the file to upload
filename String

Delete an Attachment

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/attachments/{attachment_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/attachments/{attachment_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/attachments/{attachment_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/attachments/{attachment_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/attachments/{attachment_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/attachments/{attachment_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/attachments/{attachment_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /attachments/{attachment_id}

Tags

Tags can be assigned to Assets and are generally helpful for organizing and searching Assets within a Brandfolder.

Each Tag is essentially a keyword associated with exactly one Asset.

For example, if you have several Assets that represent products you sell, you might create a "product" Tag for each one. If you modify or delete the "product" Tag for any particular Asset, it will not affect other Tags with the same value on other Assets.

Tags have a read-only attribute called auto_generated which indicates if the Tag was created automatically by our smart analysis of the file Attachment(s) (true) or if a User created the Tag (false).

List Tags

Also see List Tags for an Asset.

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/tags", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": [
        {
            "id": "ou7lox-br0dg8-6vlude",
            "type": "tags",
            "attributes": {
                "name": "logo",
                "auto_generated": false
            }
        },
        {
            "id": "ou7lox-br0dg8-c5yje0",
            "type": "tags",
            "attributes": {
                "name": "Print",
                "auto_generated": false
            }
        }
    ],
    "meta": {
        "current_page": 1,
        "next_page": null,
        "prev_page": null,
        "total_pages": 1,
        "total_count": 2
    }
}

...within a Brandfolder

GET /brandfolders/{brandfolder_id}/tags

...within a Collection

GET /collections/{collection_id}/tags

Optional URL Parameters

Name Allowed Values
page Any positive integer
per Any positive integer up to 3000. Default value is 100

Create Tags

See Create Tags for an Asset.

Update a Tag

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/tags/{tag_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/tags/{tag_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/tags/{tag_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "name": "Product"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/tags/{tag_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/tags/{tag_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/tags/{tag_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/tags/{tag_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/tags/{tag_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "name": "Product"
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "a3dlao-hd6so4-7d91d2",
    "type": "tags",
    "attributes": {
      "name": "Product",
      "auto_generated": false
    }
  }
}

PUT /tags/{tag_id}

Request Body

Attribute Allowed Values
name String

Delete a Tag

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/tags/{tag_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/tags/{tag_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/tags/{tag_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/tags/{tag_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/tags/{tag_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/tags/{tag_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/tags/{tag_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/tags/{tag_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /tags/{tag_id}

Custom Fields

Custom Fields can be assigned to Assets and are generally helpful for organizing and searching Assets within a Brandfolder, as well as for understanding more details about each Asset.

Each Custom Field is essentially a key/value pair associated with exactly one Asset. Keys and values are always a string type, so use "123" instead of 123.

For example, if you have several Assets that represent products you sell in different colors, you might create a Custom Field for each of those Assets with a key of "color" and a value of "blue" or "red", etc. If you modify or delete a "color":"blue" Custom Field for any particular Asset, it will not affect other Custom Fields on other Assets, even if they have the same key and/or value.

List Custom Field Keys

See List Custom Field Keys for a Brandfolder.

Create Custom Field Keys

See Create Custom Field Keys for a Brandfolder.

Update a Custom Field Key

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes":
        {
          "name": "dark color",
          "allowed_values": ["black", "blacker", "blackest"]
        }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes":
        {
          "name": "dark color",
          "allowed_values": ["black", "blacker", "blackest"]
        }
  }
}

Example JSON Response

{
    "data": {
        "id": "plqlkk-22rw6g-3dqgx0",
        "type": "custom_field_keys",
        "attributes": {
            "name": "dark color",
            "allowed_values": [
                "black",
                "blacker",
                "blackest"
            ],
            "restricted": true
        }
    }
}

PUT /custom_field_keys/{custom_field_key_id}

Request Body

Attribute Allowed Values Notes
name String This will be the key.
allowed_values Array of strings Optional, the value that can be used with this key when creating or updating any Custom Field on an Asset must be one of these strings. If not included or empty array [], the values are not restricted.

Delete a Custom Field key

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/custom_field_keys/{custom_field_key_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /custom_field_keys/{custom_field_key_id}

List Custom Field Values

See List Custom Field Values for an Asset.

Update a Custom Field Value

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes":
        {
          "value": "red"
        }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes":
      {
        "value": "red"
      }
  }
}

Example JSON Response

{
    "data": {
        "id": "plqlkk-22rw6g-3dqgx0",
        "type": "custom_field_values",
        "attributes": {
            "key": "color",
            "value": "red"
        }
    }
}

PUT /custom_field_values/{custom_field_value_id}

Request Body

Attribute Allowed Values
value String

Delete a Custom Field value

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/custom_field_values/{custom_field_value_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /custom_field_values/{custom_field_value_id}

Create Custom Field Keys/Values

See Create Custom Fields for an Asset.

Labels

Brandfolder’s Labels are an enhanced organization and findability feature meant to provide the peace of mind that comes with an organization's existing folder structure. Think of Labels like your music playlists – any asset can be assigned to a label or multiple labels.

Labels are not turned on for every account. If you are unsure whether you have or need Labels, please contact brandfoldersupport@smartsheet.com

List Labels

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": [
        {
            "id": "123456-f82sn4-37hch9",
            "type": "labels",
            "attributes": {
                "name": "Summer Collection",
                "path": [
                    "123456-ejah6o-4tuewo",
                    "123456-f82sn4-37hch9"
                ],
                "position": 5,
                "depth": 2
            }
        },
        {
            "id": "123456-6w19pc-2psjhr",
            "type": "labels",
            "attributes": {
                "name": "Fall Collection",
                "path": [
                    "123456-ejah6o-4tuewo",
                    "123456-6w19pc-2psjhr"
                ],
                "position": 3,
                "depth": 2
            }
        }
    ],
    "meta": {
        "current_page": 1,
        "next_page": 2,
        "prev_page": null,
        "total_pages": 28,
        "total_count": 56
    }
}

...within a Brandfolder

GET /brandfolders/{brandfolder_id}/labels

Fetch a Label

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/labels/{label_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/labels/{label_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/labels/{label_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/labels/{label_id}',
{
  method: 'GET',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/labels/{label_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/labels/{label_id}', params={
  # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/labels/{label_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/labels/{label_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": {
        "id": "123456-22mpg8-dfmfi7",
        "type": "labels",
        "attributes": {
            "name": "Label Name",
            "path": [
                "123456-2zcyw0-cgez78"
            ],
            "position": 0,
            "depth": 1
        }
    }
}

GET /labels/{label_id}

Create a Label

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
    "data": {
        "attributes": {
            "name": "Sub Label",
            "parent_key": "<parent_label_id>"  # don't use this attribute when creating at root level
        }
    }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/labels", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
    "data": {
        "attributes": {
            "name": "Sub Label",
            "parent_key": "<parent_label_id>"  # don't use this attribute when creating at root level
        }
    }
}

Example JSON Response

{
    "data": {
        "id": "123456-22mpg8-dfmfi7",
        "type": "labels",
        "attributes": {
            "name": "Sub Label",
            "path": [
                "123456-2zcyw0-cgez78",
                "123456-22mpg8-dfmfi7"
            ],
            "position": 0,
            "depth": 2
        }
    }
}

...within a Brandfolder

POST /brandfolders/{brandfolder_id}/labels

Request Body

Attribute Allowed Values Notes
name String
parent_key String Optional Include this if you wish to create the label as a child under a parent label with an id of <parent_key>

Update a Label

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/labels/{label_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/labels/{label_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/labels/{label_id}',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
    "data": {
        "attributes": {
            "name": "Label - New Name"
        }
    }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/labels/{label_id}',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/labels/{label_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/labels/{label_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/labels/{label_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/labels/{label_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
    "data": {
        "attributes": {
            "name": "Label - New Name"
        }
    }
}

Example JSON Response

{
    "data": {
        "id": "123456-22mpg8-dfmfi7",
        "type": "labels",
        "attributes": {
            "name": "Label - New Name",
            "path": [
                "123456-2zcyw0-cgez78",
                "123456-22mpg8-dfmfi7"
            ],
            "position": 0,
            "depth": 2
        }
    }
}

PUT /labels/{label_id}

Attribute Allowed Values
name String

Move a Label

Example Request

# You can also use wget
curl -X PUT https://brandfolder.com/api/v4/labels/{label_id}/move \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

PUT https://brandfolder.com/api/v4/labels/{label_id}/move HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/labels/{label_id}/move',
  method: 'put',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
    "data": {
        "attributes": {
            "parent_key": "<parent_label_id>"
        }
    }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/labels/{label_id}/move',
{
  method: 'PUT',
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.put 'https://brandfolder.com/api/v4/labels/{label_id}/move',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.put('https://brandfolder.com/api/v4/labels/{label_id}/move', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/labels/{label_id}/move");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://brandfolder.com/api/v4/labels/{label_id}/move", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
    "data": {
        "attributes": {
            "parent_key": "123456-2zcyw0-cgez78"
        }
    }
}

Example JSON Response

{
    "data": {
        "id": "123456-22mpg8-dfmfi7",
        "type": "labels",
        "attributes": {
            "name": "Label - New Name",
            "path": [
                "123456-2zcyw0-cgez78",
                "123456-22mpg8-dfmfi7"
            ],
            "position": 0,
            "depth": 2
        }
    }
}

PUT /labels/{label_id}/move

Attribute Allowed Values
parent_key String

Delete a Label

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/labels/{label_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/labels/{label_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/labels/{label_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/labels/{label_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/labels/{label_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/labels/{label_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/labels/{label_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/labels/{label_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /labels/{label_id}

List Assets in a Label

See List Assets.

Invitations

Invitations are exactly what they sound like and can be created to invite Users to join your Organization, Brandfolder, or Collection as a guest, collaborator, admin, or (when inviting someone to an Organization) owner.

Learn more about the permission levels you can grant Users in our Knowledge Base article on User Permissions

List Invitations

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/organizations/{organization_id}/invitations \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations/{organization_id}/invitations HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations/{organization_id}/invitations', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_id}/invitations");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/organizations/{organization_id}/invitations", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr3j84-33j7db",
      "type": "invitations",
      "attributes": {
        "email": "test@example.com",
        "permission_level": "guest",
        "personal_message": "Welcome to my Organization!"
      }
    }
  ]
}

...to an Organization

GET /organizations/{organization_id}/invitations

...to a Brandfolder

GET /brandfolders/{brandfolder_id}/invitations

...to a Collection

GET /collections/{collection_id}/invitations

...to a Portal

GET /portals/{portal_id}/invitations

...to a Brandguide

GET /brandguides/{brandguide_id}/invitations

The examples show how to list Invitations to an Organization. Make sure to replace organization[s|_id] everywhere with brandfolder[s|_id], collection[s|_id], portal[s|_id] or brandguide[s|_id] if you wish to list Invitations to a Brandfolder, Collection, Portal, or Brandguide respectively.

You can find Portal and Brandguide IDs by using the include parameter on the Fetch an Organization

Optional URL Parameters

Name Allowed Values
fields created_at
include inviter, inviteable

Create an Invitation

Example Request

# You can also use wget
curl -X POST https://brandfolder.com/api/v4/organizations/{organization_id}/invitations \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

POST https://brandfolder.com/api/v4/organizations/{organization_id}/invitations HTTP/1.1
Host: brandfolder.com
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "data": {
    "attributes": {
      "email": "test@example.com",
      "permission_level": "guest",
      "personal_message": "Welcome to my Organization!"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'

};

fetch('https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
{
  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' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.post 'https://brandfolder.com/api/v4/organizations/{organization_id}/invitations',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/organizations/{organization_id}/invitations', json={
    # use a dict with the POST body here
  }, params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_id}/invitations");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://brandfolder.com/api/v4/organizations/{organization_id}/invitations", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example Request Body

{
  "data": {
    "attributes": {
      "email": "test@example.com",
      "permission_level": "guest",
      "personal_message": "Welcome to my Organization!",
      "prevent_email": true
    }
  }
}

Example JSON Response

{
  "data": {
    "id": "oqgkkd-fr3j84-33j7db",
    "type": "invitations",
    "attributes": {
      "email": "test@example.com",
      "permission_level": "guest",
      "personal_message": "Welcome to my Organization!"
    }
  },
  "meta": {
    "auto_accepted": false
  }
}

...to an Organization

POST /organizations/{organization_id}/invitations

...to a Brandfolder

POST /brandfolders/{brandfolder_id}/invitations

...to a Collection

POST /collections/{collection_id}/invitations

...to a Portal

POST /portals/{portal_id}/invitations

...to a Brandguide

POST /brandguides/{brandguide_id}/invitations

The examples show how to create an Invitation to an Organization. Make sure to replace organization[s|_id] everywhere with brandfolder[s|_id], collection[s|_id], portal[s|_id], brandguide[s|_id] if you wish to invite a user to a Brandfolder, Collection, Portal, or Brandguide respectively.

You can find Portal and Brandguide IDs by using the include parameter on the Fetch an Organization

Learn more about the permission levels you can grant Users in our Knowledge Base article on User Permissions

Request Body

Attribute Allowed Values Notes
email Email address
permission_level guest, collaborator, admin, owner owner is only valid when inviting someone to an Organization
personal_message String Optional, not currently sent to the invitee
prevent_email Boolean Optional, defaults to false (does send en email to the invitee)

Fetch an Invitation

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/invitations/{invitation_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/invitations/{invitation_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/invitations/{invitation_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/invitations/{invitation_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/invitations/{invitation_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/invitations/{invitation_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/invitations/{invitation_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/invitations/{invitation_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
  "data": {
    "id": "a3dlao-hd6so4-7d91d2",
    "type": "invitations",
    "attributes": {
      "email": "test@example.com",
      "permission_level": "guest",
      "personal_message": "Welcome to my Brandfolder!"
    }
  }
}

GET /invitations/{invitation_id}

Optional URL Parameters

Name Allowed Values Notes
fields created_at
include inviteable Using inviteable will include the Brandfolder, Collection, or Organization that this Invitation is for.

Delete an Invitation

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/invitations/{invitation_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/invitations/{invitation_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/invitations/{invitation_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/invitations/{invitation_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/invitations/{invitation_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/invitations/{invitation_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/invitations/{invitation_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/invitations/{invitation_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /invitations/{invitation_id}

User Permissions

User permissions describe relationships between Organizations, Brandfolders, Collections, Portals or Brandguides and the users that have access to them.

Learn more about permissioning in our Knowledge Base article on User Permissions

List User Permissions

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions");
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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/organizations/{organization_id}/user_permissions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": [
        {
            "id": "p2f0ou-3geb4w-123456",
            "type": "user_permissions",
            "attributes": {
                "permission_level": "collaborator"
            },
            "relationships": {
                "user": {
                    "data": {
                        "id": "p0v24p-g7jy9k-123456",
                        "type": "users"
                    }
                },
                "permissible": {
                    "data": {
                        "id": "obte6d-45b4mo-123456",
                        "type": "organizations"
                    }
                }
            }
        },
        {
            "id": "pd7rdi-k6sco-123456",
            "type": "user_permissions",
            "attributes": {
                "permission_level": "admin"
            },
            "relationships": {
                "user": {
                    "data": {
                        "id": "p6k2zf-a52n14-123456",
                        "type": "users"
                    }
                },
                "permissible": {
                    "data": {
                        "id": "obte6d-45b4mo-123456",
                        "type": "organizations"
                    }
                }
            }
        },
        {
            "id": "pd7rdi-2jgiv4-123456",
            "type": "user_permissions",
            "attributes": {
                "permission_level": "owner"
            },
            "relationships": {
                "user": {
                    "data": {
                        "id": "oyn9qn-a5zy3s-123456",
                        "type": "users"
                    }
                },
                "permissible": {
                    "data": {
                        "id": "obte6d-45b4mo-123456",
                        "type": "organizations"
                    }
                }
            }
        },
        {
            "id": "pq46nx-c48r54-123456",
            "type": "user_permissions",
            "attributes": {
                "permission_level": "guest"
            },
            "relationships": {
                "user": {
                    "data": {
                        "id": "pq0nbh-26f3y0-123456",
                        "type": "users"
                    }
                },
                "permissible": {
                    "data": {
                        "id": "obte6d-45b4mo-123456",
                        "type": "organizations"
                    }
                }
            }
        }
    ],
    "included": [
        {
            "id": "p0v24p-g7jy9k-123456",
            "type": "users",
            "attributes": {
                "email": "michael@example.com",
                "first_name": "Michael",
                "last_name": "Font"
            }
        },
        {
            "id": "obte6d-45b4mo-123456",
            "type": "organizations",
            "attributes": {
                "slug": "example-organization",
                "name": "Example Organization"
            }
        },
        {
            "id": "p6k2zf-a52n14-123456",
            "type": "users",
            "attributes": {
                "email": "michele@example.com",
                "first_name": "Michele",
                "last_name": "Charles"
            }
        },
        {
            "id": "oyn9qn-a5zy3s-123456",
            "type": "users",
            "attributes": {
                "email": "chelsea@example.com",
                "first_name": "Chelsea",
                "last_name": "Michaels"
            }
        },
        {
            "id": "pq0nbh-26f3y0-123456",
            "type": "users",
            "attributes": {
                "email": "phil@example.com",
                "first_name": "Phil",
                "last_name": "Goodman"
            }
        }
    ],
    "meta": {
        "current_page": 1,
        "next_page": null,
        "prev_page": null,
        "total_pages": 1,
        "total_count": 4
    }
}

...for an Organization

GET /organizations/{organization_id}/user_permissions

...for a Brandfolder

GET /brandfolders/{brandfolder_id}/user_permissions

...for a Collection

GET /collections/{collection_id}/user_permissions

Optional URL Parameters

Name Allowed Values
page Any positive integer
per Any positive integer up to 3000. Default value is 100

Fetch a User Permission

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/user_permissions/{user_permission_id} \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/user_permissions/{user_permission_id} HTTP/1.1
Host: brandfolder.com
Accept: application/json
Content-Type: application/json

var headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
  method: 'get',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json',
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.get 'https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/user_permissions/{user_permission_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/user_permissions/{user_permission_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://brandfolder.com/api/v4/user_permissions/{user_permission_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{
    "data": {
        "id": "pxdgnq-jrw34-123456",
        "type": "user_permissions",
        "attributes": {
            "permission_level": "guest"
        },
        "relationships": {
            "user": {
                "data": {
                    "id": "p4kml1-dm0d8o-123456",
                    "type": "users"
                }
            },
            "permissible": {
                "data": {
                    "id": "pnyf7k-6kuih4-123456",
                    "type": "brandfolders"
                }
            }
        }
    },
    "included": [
        {
            "id": "p4kml1-dm0d8o-123456",
            "type": "users",
            "attributes": {
                "email": "john@example.com",
                "first_name": "John",
                "last_name": "Doe"
            }
        },
        {
            "id": "pnyf7k-6kuih4-123456",
            "type": "brandfolders",
            "attributes": {
                "slug": "example-brandfolder",
                "name": "Example Brandfolder"
            }
        }
    ]
}

GET /user_permissions/{user_permission_id}

Create a User Permission

See Create an Invitation.

Delete a User Permission (revoke access)

Example Request

# You can also use wget
curl -X DELETE https://brandfolder.com/api/v4/user_permissions/{user_permission_id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

DELETE https://brandfolder.com/api/v4/user_permissions/{user_permission_id} HTTP/1.1
Host: brandfolder.com
Content-Type: application/json

var headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

$.ajax({
  url: 'https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
  method: 'delete',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Content-Type':'application/json',
  'Authorization':'Bearer {BF_API_KEY}'
};

fetch('https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {BF_API_KEY}'
}

result = RestClient.delete 'https://brandfolder.com/api/v4/user_permissions/{user_permission_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.delete('https://brandfolder.com/api/v4/user_permissions/{user_permission_id}', params={
    # use a dict with your desired URL parameters here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/user_permissions/{user_permission_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());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"Bearer {BF_API_KEY}"},   
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://brandfolder.com/api/v4/user_permissions/{user_permission_id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Example JSON Response

{}

DELETE /user_permissions/{user_permission_id}

Parameters

Many API endpoints accept some or all of the following URL parameters in order for you to get more information or specify what exactly you would like to retrieve.

This section aims to explain generally how to use each parameter. See the section related to the exact API call you are doing in order to find out its valid parameters and accepted values.

We'll use the List Assets in an Organization call to illustrate the usage of each parameter.

fields

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.jpeg?Expires=1624742369",
        "approved": true,
        "cdn_url": "https://cdn.bfldr.com/example/asset/example1.png?auto=webp&format=png",
        "updated_at": "2018-09-11T20:31:34.858Z"
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com/thumbnail2/example.jpeg?Expires=1624742369",
        "approved": false,
        "cdn_url": "https://cdn.bfldr.com/example/asset/example1.png?auto=webp&format=png",
        "updated_at": "2018-09-11T20:31:34.858Z"
      }
    }
  ],
  "meta": {
    "total_count": 2
  }
}

fields is an optional parameter that takes values as a comma-separated string with no spaces. These additional requested fields are returned as attributes on the fetched resource(s). Make sure to read the documentation for each endpoint to know which non-default attribute fields can be requested.

Example

GET /brandfolders/{brandfolder_id}/assets?fields=cdn_url,updated_at

include

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example1.jpeg?Expires=1624742369",
        "approved": true
      },
      "relationships": {
        "brandfolder": {
          "data": {
            "id": "pdmjei-bhg70o-4ap88",
            "type": "brandfolders"
          }
        },
        "section": {
          "data": {
            "id": "pdmjmp-3zcfgo-boa4xr",
            "type": "sections"
          }
        },
        "attachments": {
          "data": [
            {
              "id": "pewron-9f9uaw-2em6u7",
              "type": "attachments"
            }
          ]
        }
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com/thumbnail137/example.jpeg?Expires=1624742369",
        "approved": false
      },
      "relationships": {
        "brandfolder": {
          "data": {
            "id": "pdmjei-bhg70o-4ap88",
            "type": "brandfolders"
          }
        },
        "section": {
          "data": {
            "id": "pdmjmp-3zcfgo-boa4xr",
            "type": "sections"
          }
        },
        "attachments": {
          "data": [
            {
              "id": "pewron-e23is0-2x6fbq",
              "type": "attachments"
            }
          ]
        }
      }
    }
  ],
  "included": [
    {
      "id": "pdmjei-bhg70o-4ap88",
      "type": "brandfolders",
      "attributes": {
        "name": "Example Brandfolder",
        "tagline": "This is an awesome Brandfolder",
        "privacy": "stealth",
        "slug": "example-brandfolder"
      }
    },
    {
      "id": "pdmjmp-3zcfgo-boa4xr",
      "type": "sections",
      "attributes": {
        "name": "Logo Section",
        "default_asset_type": "GenericFile",
        "position": 0
      }
    },
    {
      "id": "pewron-9f9uaw-2em6u7",
      "type": "attachments",
      "attributes": {
        "mimetype": "image/png",
        "filename": "1example.png",
        "size": 1603,
        "width": 126,
        "height": 75,
        "url": "https://example.com/pewron-9f9uaw-2em6u7/original/1example.png",
        "position": 0
      }
    },
    {
      "id": "pewron-e23is0-2x6fbq",
      "type": "attachments",
      "attributes": {
        "mimetype": "image/png",
        "filename": "137example.png",
        "size": 1539,
        "width": 134,
        "height": 187,
        "url": "https://example.com/pewron-e23is0-2x6fbq/original/137example.png",
        "position": 0
      }
    }
  ],
  "meta": {
    "total_count": 2
  }
}

include is an optional parameter used to request records that are related to the resource(s) you are fetching. It will add any existing related records to an included array in the JSON response. Make sure to read the documentation for each endpoint to know which relationships are valid to include with each request. Values must be submitted as a comma-separated string with no spaces.

Example

GET /brandfolders/{brandfolder_id}/assets?include=brandfolder,section,attachments

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.png?Expires=1624742369",
        "approved": true,
        "cdn_url": "https://cdn.bfldr.com/example/asset/example1.png?auto=webp&format=png",
        "updated_at": "2018-09-11T20:31:34.858Z"
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com/thumbnail2/example.png?Expires=1624742369",
        "approved": false,
        "cdn_url": "https://cdn.bfldr.com/example/asset/example1.png?auto=webp&format=png",
        "updated_at": "2018-09-11T20:31:34.858Z"
      }
    }
  ],
  "meta": {
    "total_count": 2
  }
}

search is an optional parameter that allows you to fetch only the records that match your query. It works just like the standard search bar does on the Brandfolder website. Appropriate values for searching for Assets or Attachments can be found at https://help.smartsheet.com/360000042134-Searching-in-Brandfolder. Just make sure that whatever values you use are properly URL encoded. If provided, only resources matching the query will be returned.

Example

GET /brandfolders/{brandfolder_id}/assets?search=extension:png

per

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.jpeg?Expires=1624742369",
        "approved": true
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com/thumbnail2/example.jpeg?Expires=1624742369",
        "expiration_date": "2018-09-11T20:31:34.858Z",
        "approved": false
      }
    }
  ],
  "meta": {
    "total_count": 17
  }
}

per is an optional parameter used for pagination, or simply to limit or increase the amount of results you would like to receive back from your request. The value you set for per is the maximum number for records you will get, although more may exist (as denoted by the meta.total_count value). The default value is 100 and maximum is 3000.

Example

GET /brandfolders/{brandfolder_id}/assets?per=2

page

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.jpeg?Expires=1624742369",
        "approved": true
      }
    },
    {
      "id": "oqh4xl-ci1u7c-emfa7g",
      "type": "generic_files",
      "attributes": {
        "name": "Facebook Banner - Large",
        "description": "Brandfolder banner optimized for Facebook",
        "thumbnail_url": "https://example.com/thumbnail2/example.jpeg?Expires=1624742369",
        "approved": false
      }
    }
  ],
  "meta": {
    "total_count": 17
  }
}

page is an optional parameter used for pagination. It specifies which page of results you would like to receive back. Unless you explicitly set a value for per, the default number of results per page is 100.

Example

GET /brandfolders/{brandfolder_id}/assets?page=3&per=2

sort_by

sort_by is an optional parameter used for sorting results based on a specific attribute. Supported values are name, score, position, updated_at, created_at.

Example

GET /brandfolders/{brandfolder_id}/assets?sort_by=name returns assets sorted alphabetically by their name.

order

order is an optional parameter used for setting the sort order of results. Supported values are ASC (ascending) and DESC (descending).

Example

GET /brandfolders/{brandfolder_id}/assets?order=DESC&sort_by=name returns assets sorted by their name in reverse-alphabetical order.

Troubleshooting

Common Errors

A common source of errors

# All `PUT` and `POST` calls to our API accept
{
  "data": {
    "attributes": ...
  }
}

# but sometimes `attributes` should be an object
{
  ...
}

# and other times, it must be an array of objects
[
  {...},
  {...},
  {...}
]

The Brandfolder V4 API uses the following error codes:

Error Code Meaning Possible Causes
400 Bad Request You probably misspelled a parameter in the query string, used one that isn't valid for that endpoint, or forgot a required data attribute in the request body.
403 Forbidden You do not have access to the requested resource because you are not sending an appropriate API key or the resource was deleted.
404 Not Found You may have misspelled the resource ID or the endpoint path in the request URL.
405 Method Not Allowed You tried to use an HTTP method that isn't accepted by our API. The only valid methods are GET, PUT, POST, and DELETE and not every one is valid for every endpoint.
429 Too Many Requests You're sending too many requests in a short period of time.
500 Internal Server Error We had a problem with our server. Please try again later and let us know if the problem persists.

Webhooks

Overview

The Brandfolder Webhooks service allows you to subscribe to event-based notifications (callbacks) when a qualifying event is triggered within Brandfolder. Asset data will then be sent to the user-provided callback_url at the time the subscribed event occurs within the specified Brandfolder.

View our Webhooks' documentation HERE

Binary Upload

Overview

The upload request flow allows for authenticated users to upload a file to a storage bucket that can be ingested by the Brandfolder API during asset creation.

View our Binary Upload documentation HERE

Insights Data Connector

Overview

Brandfolder's Insights Data Connector allows customers to connect directly to their own data. The data is housed in Google BigQuery within a unique Google Cloud Platform (GCP) Project which is established for the customer. The data can be accessed with any existing BigQuery connection method using a GCP account associated with the customer GCP project. The data is refreshed nightly.

View our Insights Data Connector documentation HERE