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.

Find your API key at https://brandfolder.com/profile#integrations.
Click the icon to the right of your key to copy it to your clipboard.
Use the key in your code when making requests to our API.

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 Section`brandfolder`, `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 Section`brandfolder`, `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.

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}

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

search

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

page_token

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": {
    "page_token": "<page_token>"
  }
}

page_token is an optional parameter that can be used in conjunction with search to enable you to scroll through large datasets beyond the normal 10,000 asset limit. The assets returned are sorted by created_at desc.

Step 1: To get the first page of assets make a request with an empty page_token param.
Step 2: In the meta of your response you will receive a page_token. Use that new token in your next API request
Step 3: Repeat Step 2 until you reach the end of your result set.

Note: page_token search only supports sorting by created_at desc. Any requests that attempt to sort by different criteria will be rejected.

Important: page_token search cannot be combined with page, sort_by, or order params.

Example

GET /sections/{section_id}/assets?search=cloud?page_token=?per=500

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, used to define the number of results returned per page. The value you set for per is the maximum number of records returned per request, although more may exist (as denoted by the meta.total_count value). The default value is 100 and the 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.

Note: page cannot be combined with page_token parameter.

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.

Note: sort_by cannot be combined with page_token parameter.

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).

Note: order cannot be combined with page_token parameter.

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

Getting Started

Overview

Authentication

Making Requests

Organizations

List Organizations

Optional URL Parameters

Fetch an Organization

Optional URL Parameters

List Assets in an Organization

List Attachments in an Organization

List Invitations to an Organization

Create an Invitation to an Organization

List Brandfolders in an Organization

Create a Brandfolder in an Organization

Request Body

Brandfolders

List Brandfolders

Optional URL Parameters

Fetch a Brandfolder

Optional URL Parameters

List Sections in a Brandfolder

Create a Section in a Brandfolder

Request Body

List Collections in a Brandfolder

Create a Collection in a Brandfolder

Request Body

List Assets in a Brandfolder

Create Assets in a Brandfolder

List Attachments in a Brandfolder

List Custom Field Keys for a Brandfolder

Optional URL Parameters

Create Custom Field Keys for a Brandfolder

Request Body

List Invitations to a Brandfolder

Create an Invitation to a Brandfolder

Collections

List Collections

...that a User can access

...within a Brandfolder

Optional URL Parameters

Fetch a Collection

Optional URL Parameters

Create a Collection

Update a Collection

Request Body

Delete a Collection

List Assets in a Collection

Create Assets in a Collection

List Attachments in a Collection

List Invitations to a Collection

Create an Invitation to a Collection

Sections

List Sections

Optional URL Parameters

Fetch a Section

Optional URL Parameters

Create a Section

Assets

List Assets

...within an Organization

...within a Brandfolder

...within a Collection

...within a Label

Optional URL Parameters

Fetch an Asset

Optional URL Parameters

Create Assets

...within a Brandfolder

...within a Collection

Request Body

Update an Asset

Request Body

Delete an Asset

List Attachments on an Asset

List Tags for an Asset

Optional URL Parameters

List Custom Field Values for an Asset

Optional URL Parameters

Create Tags for an Asset