MENU
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Getting Started

Overview

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

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.

export BF_API_KEY="Your Brandfolder API Key Here"

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 Non-Default 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',
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/organizations', params={
    # use a dict with your desired request body 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, assets

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',
  'Content-Type': '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 request body 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, 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.

/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',
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/brandfolders', params={
    # use a dict with your desired request body 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',
  'Content-Type': '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 request body 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

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 = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/sections', params={
    # use a dict with your desired request body 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 = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/collections', params={
    # use a dict with your desired request body 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',
  'Content-Type': '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 request body 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

List Custom Field values for a Brandfolder

Example Request

# You can also use wget
curl -X GET https://brandfolder.com/api/v4/brandfolders/{brandfolder_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/brandfolders/{brandfolder_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/brandfolders/{brandfolder_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/brandfolders/{brandfolder_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/brandfolders/{brandfolder_id}/custom_field_values',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/brandfolders/{brandfolder_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/brandfolders/{brandfolder_id}/custom_field_values", data)
    req.Header = headers

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

Example JSON Response

{
    "data": [
        {
            "id": "ph49in-ck15c-2kp59v",
            "type": "custom_field_values",
            "attributes": {
                "key": "sku",
                "value": "123"
            }
        },
        {
            "id": "ph48ds-fonf1c-88o269",
            "type": "custom_field_values",
            "attributes": {
                "key": "size",
                "value": "M"
            }
        },
        {
            "id": "pfy1cy-5x93rs-8b82em",
            "type": "custom_field_values",
            "attributes": {
                "key": "sku",
                "value": "234"
            }
        },
        {
            "id": "pfxglo-brawb4-fce5vk",
            "type": "custom_field_values",
            "attributes": {
                "key": "color",
                "value": "red"
            }
        },
        {
            "id": "pfse7g-13qq68-ai00qk",
            "type": "custom_field_values",
            "attributes": {
                "key": "color",
                "value": "red"
            }
        }
    ]
}

For convenience, this also returns the key for each value as a read only attribute

GET /brandfolders/{brandfolder_id}/custom_field_values

Optional URL Parameters

Name Allowed Values
include custom_field_key

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 = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/brandfolders/{brandfolder_id}/custom_field_keys', params={
    # use a dict with your desired request body 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',
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.get('https://brandfolder.com/api/v4/collections', params={
    # use a dict with your desired request body 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',
  'Content-Type': '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 request body 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 = {
  'Content-Type': 'application/json',
  '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 request body 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 request body 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.).

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',
  'Content-Type': '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 request body here
}, headers=headers)

print(r.json())

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

Example JSON Response

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

GET /sections/{section_id}

Optional URL Parameters

Name Allowed Values
include requested Section. Valid Sectionbrandfolder, assets

Create a Section

See Create a Section in a Brandfolder.

/assets

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

List Assets

Example Request

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

GET https://brandfolder.com/api/v4/organizations/{organization_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/organizations/{organization_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/organizations/{organization_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/organizations/{organization_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

print(r.json())

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

Optional URL Parameters

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

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',
  'Content-Type': '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 request body 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",
      "approved": true
    }
  }
}

GET /assets/{asset_id}

Optional URL Parameters

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

Create Assets

Example Request

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

POST https://brandfolder.com/api/v4/collections/{collection_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/collections/{collection_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",
        "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/collections/{collection_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/collections/{collection_id}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/collections/{collection_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/collections/{collection_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",
        "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",
        "approved": true
      }
    }
  ]
}

...within a Brandfolder

POST /brandfolders/{brandfolder_id}/assets

...within a Collection

POST /collections/{collection_id}/assets

We do not currently allow direct file uploads via the API. 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).

Request Body

Attribute Allowed Values Notes
name String
description String Optional
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 Optional, defaults to the file name part of the URL.
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",
      "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 = {
  'Content-Type': 'application/json',
  '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 request body 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",
      "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",
      "approved": true
    }
  }
}

PUT /assets/{asset_id}

Request Body

Attribute Allowed Values
name String
description String
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

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 request body here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/assets/{asset_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

Example JSON Response

{}

DELETE /assets/{asset_id}

List Attachments on an Asset

See List Attachments.

List Tags for an Asset

Example Request

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

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

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

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

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

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

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

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Content-Type': '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 request body 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

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 = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/assets/{asset_id}/tags', params={
    # use a dict with your desired request body 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

Example Request

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

POST https://brandfolder.com/api/v4/assets/{asset_id}/custom_fields 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}/custom_fields',
  method: 'post',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

};

fetch('https://brandfolder.com/api/v4/assets/{asset_id}/custom_fields',
{
  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}/custom_fields',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

print(r.json())

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

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

Example Request Body

{
  "data": {
    "attributes": [
      {
        "key": "team",
        "value": "product"
      },
      {
        "key": "campaign",
        "value": "fall"
      }
    ]
  }
}

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": "campaign",
        "value": "fall"
      }
    }
  ]
}

POST /assets/{asset_id}/custom_fields

Request Body

Attribute Allowed Values
key String
value 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/organizations/{organization_id}/attachments \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer {BF_API_KEY}'

GET https://brandfolder.com/api/v4/organizations/{organization_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/organizations/{organization_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/organizations/{organization_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/organizations/{organization_id}/attachments',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/organizations/{organization_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/organizations/{organization_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",
        "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. Default value is 100
search Any URI-encoded query
fields metadata, thumbnail_url, view_thumbnail_retina
include asset, collections

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',
  'Content-Type': '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 request body 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",
      "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
include asset, collections

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 = {
  'Content-Type': 'application/json',
  '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 request body 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",
            "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 request body here
}, headers=headers)

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/attachments/{attachment_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

Example JSON Response

{}

DELETE /attachments/{attachment_id}

/tags

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

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

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

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

List Tags

See List Tags for an Asset.

Create Tags

See Create Tags for an Asset.

Update a Tag

Example Request

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

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

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

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

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

};

fetch('https://brandfolder.com/api/v4/tags/{tag_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/tags/{tag_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

Example Request Body

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

Example JSON Response

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

PUT /tags/{tag_id}

Request Body

Attribute Allowed Values
name String

Delete a Tag

Example Request

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

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

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

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

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

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

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

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

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

print(r.json())

URL obj = new URL("https://brandfolder.com/api/v4/tags/{tag_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

Example JSON Response

{}

DELETE /tags/{tag_id}

/custom_fields_[keys|values]

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 = {
  'Content-Type': 'application/json',
  '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 request body 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 request body 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 a Brandfolder.

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 = {
  'Content-Type': 'application/json',
  '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 request body 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 request body 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.

/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 at https://help.brandfolder.com/hc/en-us/articles/115002602273

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',
  'Content-Type': '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 request body 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

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

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 = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {BF_API_KEY}'
}

r = requests.post('https://brandfolder.com/api/v4/organizations/{organization_id}/invitations', params={
    # use a dict with your desired request body 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!"
    }
  }
}

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

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

Learn more about the permission levels you can grant Users at https://help.brandfolder.com/hc/en-us/articles/115002602273

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

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',
  'Content-Type': '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 request body 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 request body 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}

?parameters=non-default

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",
        "approved": true,
        "cdn_url": "https://cdn.brandfolder.io/example/asset/example1.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",
        "approved": false,
        "cdn_url": "https://cdn.brandfolder.io/example/asset/example1.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 /organizations/{organization_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",
        "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",
        "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 /organizations/{organization_id}/assets?include=brandfolder,section,attachments

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.png",
        "approved": true,
        "cdn_url": "https://cdn.brandfolder.io/example/asset/example1.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",
        "approved": false,
        "cdn_url": "https://cdn.brandfolder.io/example/asset/example1.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.brandfolder.com/hc/en-us/articles/360000042134-Search-Terms. Just make sure that whatever values you use are properly URL encoded. If provided, only resources matching the query will be returned.

Example

GET /organizations/{organization_id}/assets?search=extension:png

per

Example JSON Response

{
  "data": [
    {
      "id": "oqgkkd-fr5iv4-443db",
      "type": "generic_files",
      "attributes": {
        "name": "Brandfolder Logo",
        "description": "Brandfolder's logo in print ready form",
        "thumbnail_url": "https://example.com/thumbnail1/example.jpeg",
        "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",
        "approved": false
      }
    }
  ],
  "meta": {
    "total_count": 17
  }
}

per is an optional parameter used for pagination, or simply to limit or increase the amount of results you would like to receive back from your request. The value you set for per is the maximum number for records you will get, although more may exist (as denoted by the meta.total_count value). The default value is 100.

Example

GET /organizations/{organization_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",
        "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",
        "approved": false
      }
    }
  ],
  "meta": {
    "total_count": 17
  }
}

page is an optional parameter used for pagination. It specifies which page of results you would like to receive back. Unless you explicitly set a value for per, the default number of results per page is 100.

Example

GET /organizations/{organization_id}/assets?page=3&per=2

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.