Brand Kit

#Get the workspace brand kit

GET/v1/brandkit/{id}

Retrieve the brand kit profile (website, summary, tone, onboarded) for a workspace.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/ID" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": {
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "branding": {},
    "id": "string",
    "onboarded": true,
    "summary": "string",
    "tone": "string",
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Update the workspace brand kit profile

PUT/v1/brandkit/{id}

Update website, summary, tone, and/or the onboarded flag.

Path parameters

idstring

Workspace ID

Request body

onboardedbooleanOptional

summarystringOptional

tonestringOptional

website_urlstringOptional

Response codes

200

400

Bad Request

401

Unauthorized

curl -X PUT "https://api.rendley.com/v1/brandkit/ID" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "onboarded": true,
    "summary": "<summary>",
    "tone": "<tone>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "onboarded": true,
    "summary": "<summary>",
    "tone": "<tone>"
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "onboarded": True,
      "summary": "<summary>",
      "tone": "<tone>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["onboarded" => true, "summary" => "<summary>", "tone" => "<tone>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "onboarded": true,
  "summary": "<summary>",
  "tone": "<tone>"
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { onboarded: true, summary: "<summary>", tone: "<tone>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

onboardedboolean

summarystring

tonestring

website_urlstring

Response

{
  "data": {
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "branding": {},
    "id": "string",
    "onboarded": true,
    "summary": "string",
    "tone": "string",
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Update the structured brand voice

PUT/v1/brandkit/{id}/brand-voice

Replace the machine-readable brand voice (adjectives, audience, messaging, vocabulary, do/don'ts) the AI agent uses. Free for all plans.

Path parameters

idstring

Workspace ID

Request body

brand_voiceobjectOptional

audiencestringOptional

energystringOptional

namestringOptional

Name is the editable brand display name. Seeded once from the import's extracted name; a user's value is never overwritten by a re-import.

notesstringOptional

free-form extra direction, read verbatim by the agent

tonestringOptional

Response codes

200

curl -X PUT "https://api.rendley.com/v1/brandkit/ID/brand-voice" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    }
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/brand-voice", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    }
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID/brand-voice",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "brand_voice": {
        "audience": "string",
        "energy": "string",
        "name": "string",
        "notes": "string",
        "tone": "string"
      }
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/brand-voice");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["brand_voice" => ["audience" => "string", "energy" => "string", "name" => "string", "notes" => "string", "tone" => "string"]]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "brand_voice": {
    "audience": "string",
    "energy": "string",
    "name": "string",
    "notes": "string",
    "tone": "string"
  }
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID/brand-voice", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/brand-voice")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { brand_voice: { audience: "string", energy: "string", name: "string", notes: "string", tone: "string" } }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

brand_voiceobject

audiencestring

energystring

namestring

Name is the editable brand display name. Seeded once from the import's extracted name; a user's value is never overwritten by a re-import.

notesstring

free-form extra direction, read verbatim by the agent

tonestring

Response

{
  "data": {
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "branding": {},
    "id": "string",
    "onboarded": true,
    "summary": "string",
    "tone": "string",
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Get the brand kit caption style

GET/v1/brandkit/{id}/caption-style

Returns the SDK-compatible caption style config (empty object when unset). Free for all plans.

Path parameters

idstring

Workspace ID

Response codes

200

curl "https://api.rendley.com/v1/brandkit/ID/caption-style" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/caption-style", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/caption-style",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/caption-style");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/caption-style", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/caption-style")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": {
    "config": {}
  }
}

#Set the brand kit caption style

PUT/v1/brandkit/{id}/caption-style

Store the SDK-compatible caption style config (main + highlight text styles, animation, mode, scale). Free for all plans.

Path parameters

idstring

Workspace ID

Request body

configobjectRequired

Response codes

200

curl -X PUT "https://api.rendley.com/v1/brandkit/ID/caption-style" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "prompt": "..."
    }
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/caption-style", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "config": {
      "prompt": "..."
    }
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID/caption-style",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "config": {
        "prompt": "..."
      }
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/caption-style");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["config" => ["prompt" => "..."]]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "config": {
    "prompt": "..."
  }
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID/caption-style", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/caption-style")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { config: { prompt: "..." } }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

configREQUIREDjson

Response

{
  "data": {
    "config": {}
  }
}

#List brand kit colors

GET/v1/brandkit/{id}/colors

Retrieve the colors of a workspace brand kit.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/ID/colors" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/colors", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/colors",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/colors");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/colors", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/colors")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "id": "string",
      "name": "string",
      "role": "string",
      "value": "string"
    }
  ]
}

#Add a brand kit color

POST/v1/brandkit/{id}/colors

Add a color to a workspace brand kit.

Path parameters

idstring

Workspace ID

Request body

colorstringRequired

namestringOptional

rolestringOptional

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/colors" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "color": "<color>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/colors", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "color": "<color>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/colors",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "color": "<color>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/colors");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["color" => "<color>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "color": "<color>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/colors", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/colors")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { color: "<color>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

colorREQUIREDstring

namestring

rolestring

Response

{
  "data": {
    "id": "string",
    "name": "string",
    "role": "string",
    "value": "string"
  }
}

#Delete a brand kit color

DELETE/v1/brandkit/{id}/colors

Remove a color from a workspace brand kit.

Path parameters

idstring

Workspace ID

Request body

color_idstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X DELETE "https://api.rendley.com/v1/brandkit/ID/colors" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "color_id": "<color_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/colors", {
  method: "DELETE",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "color_id": "<color_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.delete(
    "https://api.rendley.com/v1/brandkit/ID/colors",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "color_id": "<color_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/colors");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["color_id" => "<color_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "color_id": "<color_id>"
}`)
	req, _ := http.NewRequest("DELETE", "https://api.rendley.com/v1/brandkit/ID/colors", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/colors")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { color_id: "<color_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

color_idREQUIREDstring

#Add multiple brand colors

POST/v1/brandkit/{id}/colors/batch

Add one or more brand colors in a single call.

Path parameters

idstring

Workspace ID

Request body

colorsobject[]Required

colorstringRequired

namestringOptional

rolestringOptional

Response codes

200

400

Bad Request

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/colors/batch" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "colors": [
      {
        "color": "string",
        "name": "string",
        "role": "string"
      }
    ]
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/colors/batch", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "colors": [
      {
        "color": "string",
        "name": "string",
        "role": "string"
      }
    ]
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/colors/batch",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "colors": [
        {
          "color": "string",
          "name": "string",
          "role": "string"
        }
      ]
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/colors/batch");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["colors" => [["color" => "string", "name" => "string", "role" => "string"]]]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "colors": [
    {
      "color": "string",
      "name": "string",
      "role": "string"
    }
  ]
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/colors/batch", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/colors/batch")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { colors: [{ color: "string", name: "string", role: "string" }] }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

colorsREQUIREDobject[]

colorREQUIREDstring

namestring

rolestring

Response

{
  "data": [
    {
      "id": "string",
      "name": "string",
      "role": "string",
      "value": "string"
    }
  ]
}

#Fill the brand kit with Rendley defaults

POST/v1/brandkit/{id}/defaults

Fills any empty brand kit field (colors, fonts, text styles, captions) with the Rendley defaults. Used by the "start from scratch" path; set fields are kept.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/defaults" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/defaults", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/defaults",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/defaults");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/defaults", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/defaults")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

#List brand kit fonts

GET/v1/brandkit/{id}/fonts

Path parameters

idstring

Workspace ID

Response codes

200

curl "https://api.rendley.com/v1/brandkit/ID/fonts" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/fonts", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/fonts",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/fonts");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/fonts", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/fonts")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "font_id": "string",
      "id": "string",
      "is_pro": true,
      "name": "string",
      "order": 0,
      "role": "string",
      "source": "string",
      "source_url": "string",
      "styles": {},
      "weights": {}
    }
  ]
}

#Add a font to the brand kit

POST/v1/brandkit/{id}/fonts

Reference a catalog font in the brand fonts collection. Catalog fonts whose source is "brandkit" (custom) require the Pro font-upload entitlement.

Path parameters

idstring

Workspace ID

Request body

font_idstringRequired

orderintegerOptional

rolestringOptional

Response codes

200

curl -X POST "https://api.rendley.com/v1/brandkit/ID/fonts" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "font_id": "<font_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/fonts", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "font_id": "<font_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/fonts",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "font_id": "<font_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/fonts");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["font_id" => "<font_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "font_id": "<font_id>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/fonts", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/fonts")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { font_id: "<font_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

font_idREQUIREDstring

orderinteger

rolestring

Response

{
  "data": {
    "font_id": "string",
    "id": "string",
    "is_pro": true,
    "name": "string",
    "order": 0,
    "role": "string",
    "source": "string",
    "source_url": "string",
    "styles": {},
    "weights": {}
  }
}

#Remove a font from the brand kit

DELETE/v1/brandkit/{id}/fonts

Path parameters

idstring

Workspace ID

Request body

brandkit_font_idstringRequired

Response codes

200

curl -X DELETE "https://api.rendley.com/v1/brandkit/ID/fonts" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "brandkit_font_id": "<brandkit_font_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/fonts", {
  method: "DELETE",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "brandkit_font_id": "<brandkit_font_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.delete(
    "https://api.rendley.com/v1/brandkit/ID/fonts",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "brandkit_font_id": "<brandkit_font_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/fonts");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["brandkit_font_id" => "<brandkit_font_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "brandkit_font_id": "<brandkit_font_id>"
}`)
	req, _ := http.NewRequest("DELETE", "https://api.rendley.com/v1/brandkit/ID/fonts", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/fonts")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { brandkit_font_id: "<brandkit_font_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

brandkit_font_idREQUIREDstring

#Get the complete brand kit

GET/v1/brandkit/{id}/full

Retrieve the whole agent-facing brand kit (voice, colors, fonts, text styles, caption style, voices, assets) in one payload.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/ID/full" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/full", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/full",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/full");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/full", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/full")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": {
    "assets": [
      {
        "asset_type": "string",
        "duration": 0,
        "height": 0,
        "id": "string",
        "mime_type": "string",
        "name": "string",
        "original_file_name": "string",
        "source_url": "string",
        "tags": [
          "string"
        ],
        "width": 0
      }
    ],
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "caption_style": {},
    "colors": [
      {
        "id": "string",
        "name": "string",
        "role": "string",
        "value": "string"
      }
    ],
    "fonts": [
      {
        "font_id": "string",
        "id": "string",
        "is_pro": true,
        "name": "string",
        "order": 0,
        "role": "string",
        "source": "string",
        "source_url": "string",
        "styles": {},
        "weights": {}
      }
    ],
    "name": "string",
    "summary": "string",
    "text_styles": [
      {
        "color": "string",
        "color_role": "string",
        "font_id": "string",
        "font_name": "string",
        "font_size": 0,
        "font_source": "string",
        "font_weight": "string",
        "letter_spacing": 0,
        "line_height": 0,
        "role": "string",
        "text_align": "string",
        "text_case": "string"
      }
    ],
    "tone": "string",
    "voices": [
      {
        "id": "string",
        "model_id": "string",
        "name": "string",
        "order": 0,
        "settings": {},
        "voice_id": "string"
      }
    ],
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Import brand kit from a website

POST/v1/brandkit/{id}/import

Extract a website's brand (via the Gemini-backed extractor) and populate the brand kit profile, colors and fonts.

Path parameters

idstring

Workspace ID

Request body

website_urlstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/import" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "website_url": "<website_url>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/import", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "website_url": "<website_url>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/import",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "website_url": "<website_url>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/import");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["website_url" => "<website_url>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "website_url": "<website_url>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/import", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/import")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { website_url: "<website_url>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

website_urlREQUIREDstring

Response

{
  "data": {
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "branding": {},
    "id": "string",
    "onboarded": true,
    "summary": "string",
    "tone": "string",
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Import brand kit from an uploaded PDF

POST/v1/brandkit/{id}/import-pdf

Read a brand PDF previously uploaded to storage (via the presigned URL) and populate the brand kit profile, colors and fonts. The transient PDF is deleted after.

Path parameters

idstring

Workspace ID

Request body

storage_keystringRequired

Response codes

200

400

Bad Request

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/import-pdf" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "storage_key": "<storage_key>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/import-pdf", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "storage_key": "<storage_key>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/import-pdf",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "storage_key": "<storage_key>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/import-pdf");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["storage_key" => "<storage_key>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "storage_key": "<storage_key>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/import-pdf", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/import-pdf")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { storage_key: "<storage_key>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

storage_keyREQUIREDstring

Response

{
  "data": {
    "brand_voice": {
      "audience": "string",
      "energy": "string",
      "name": "string",
      "notes": "string",
      "tone": "string"
    },
    "branding": {},
    "id": "string",
    "onboarded": true,
    "summary": "string",
    "tone": "string",
    "website_url": "string",
    "workspace_id": "string"
  }
}

#Get a presigned URL to upload a brand PDF

POST/v1/brandkit/{id}/import-pdf/upload-url

Returns a presigned PUT URL to upload a brand PDF directly to storage, plus the storage key to pass to the import endpoint.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/import-pdf/upload-url")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": {
    "presigned_url": "string",
    "storage_key": "string"
  }
}

#Get brand kit overview

GET/v1/brandkit/{id}/overview

Retrieve a brand kit overview grouped by category for a workspace.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/ID/overview" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/overview", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/overview",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/overview");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/overview", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/overview")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "assets": [
        {
          "asset_type": "string",
          "duration": 0,
          "height": 0,
          "id": "string",
          "mime_type": "string",
          "name": "string",
          "original_file_name": "string",
          "source_url": "string",
          "tags": [
            {}
          ],
          "width": 0
        }
      ],
      "category_id": "string",
      "category_name": "string"
    }
  ]
}

#List brand kit text styles

GET/v1/brandkit/{id}/text-styles

Role-bound text styles (title/subtitle/heading/body/label). Free for all plans.

Path parameters

idstring

Workspace ID

Response codes

200

curl "https://api.rendley.com/v1/brandkit/ID/text-styles" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/text-styles", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/text-styles",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/text-styles");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/text-styles", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/text-styles")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "color": "string",
      "color_role": "string",
      "font_id": "string",
      "font_name": "string",
      "font_size": 0,
      "font_source": "string",
      "font_weight": "string",
      "letter_spacing": 0,
      "line_height": 0,
      "role": "string",
      "text_align": "string",
      "text_case": "string"
    }
  ]
}

#Create or update a text style

PUT/v1/brandkit/{id}/text-styles

Upsert the text style for a single role. Free for all plans.

Path parameters

idstring

Workspace ID

Request body

colorstringOptional

color_rolestringOptional

soft reference to a brand color role

font_idstringOptional

font_sizenumberOptional

font_weightstringOptional

letter_spacingnumberOptional

line_heightnumberOptional

rolestringRequired

text_align"left" | "center" | "right"Optional

text_case"none" | "uppercase" | "lowercase" | "capitalize"Optional

Response codes

200

curl -X PUT "https://api.rendley.com/v1/brandkit/ID/text-styles" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "role": "<role>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/text-styles", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "role": "<role>"
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID/text-styles",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "role": "<role>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/text-styles");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["role" => "<role>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "role": "<role>"
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID/text-styles", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/text-styles")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { role: "<role>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

colorstring

color_rolestring

soft reference to a brand color role

font_idstring

font_sizenumber

font_weightstring

letter_spacingnumber

line_heightnumber

roleREQUIREDstring

text_align"left" | "center" | "right"

text_case"none" | "uppercase" | "lowercase" | "capitalize"

#Delete a text style

DELETE/v1/brandkit/{id}/text-styles

Path parameters

idstring

Workspace ID

Request body

rolestringRequired

Response codes

200

curl -X DELETE "https://api.rendley.com/v1/brandkit/ID/text-styles" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "role": "<role>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/text-styles", {
  method: "DELETE",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "role": "<role>"
  }),
});
const { data } = await res.json();

import requests

res = requests.delete(
    "https://api.rendley.com/v1/brandkit/ID/text-styles",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "role": "<role>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/text-styles");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["role" => "<role>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "role": "<role>"
}`)
	req, _ := http.NewRequest("DELETE", "https://api.rendley.com/v1/brandkit/ID/text-styles", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/text-styles")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { role: "<role>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

roleREQUIREDstring

#List brand kit uploads

GET/v1/brandkit/{id}/uploads

Retrieve the uploaded assets of a workspace brand kit.

Path parameters

idstring

Workspace ID

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/ID/uploads" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/uploads",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/uploads", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "asset_type": "string",
      "duration": 0,
      "height": 0,
      "id": "string",
      "mime_type": "string",
      "name": "string",
      "original_file_name": "string",
      "source_url": "string",
      "tags": [
        "string"
      ],
      "width": 0
    }
  ]
}

#Create a brand kit upload

POST/v1/brandkit/{id}/uploads

Initiate an upload of an asset to a workspace brand kit.

Path parameters

idstring

Workspace ID

Request body

asset_typestringRequired

durationnumberOptional

file_sizeintegerRequired

heightintegerOptional

mime_typestringRequired

namestringOptional

original_file_namestringOptional

tagsstring[]Optional

widthintegerOptional

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "asset_type": "<asset_type>",
    "file_size": 0,
    "mime_type": "<mime_type>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "asset_type": "<asset_type>",
    "file_size": 0,
    "mime_type": "<mime_type>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "asset_type": "<asset_type>",
      "file_size": 0,
      "mime_type": "<mime_type>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["asset_type" => "<asset_type>", "file_size" => 0, "mime_type" => "<mime_type>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "asset_type": "<asset_type>",
  "file_size": 0,
  "mime_type": "<mime_type>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { asset_type: "<asset_type>", file_size: 0, mime_type: "<mime_type>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

asset_typeREQUIREDstring

durationnumber

file_sizeREQUIREDinteger

heightinteger

mime_typeREQUIREDstring

namestring

original_file_namestring

tagsstring[]

widthinteger

#Rename a brand kit asset

PUT/v1/brandkit/{id}/uploads

Set a friendly display name on an uploaded asset so it's easy to find.

Path parameters

idstring

Workspace ID

Request body

namestringRequired

upload_idstringRequired

Response codes

200

curl -X PUT "https://api.rendley.com/v1/brandkit/ID/uploads" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "<name>",
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "name": "<name>",
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID/uploads",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "name": "<name>",
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["name" => "<name>", "upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "name": "<name>",
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID/uploads", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { name: "<name>", upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

nameREQUIREDstring

upload_idREQUIREDstring

#Delete a brand kit upload

DELETE/v1/brandkit/{id}/uploads

Remove an uploaded asset from a workspace brand kit.

Path parameters

idstring

Workspace ID

Request body

upload_idstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X DELETE "https://api.rendley.com/v1/brandkit/ID/uploads" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads", {
  method: "DELETE",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.delete(
    "https://api.rendley.com/v1/brandkit/ID/uploads",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("DELETE", "https://api.rendley.com/v1/brandkit/ID/uploads", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

upload_idREQUIREDstring

#Presign a batch of brand kit uploads

POST/v1/brandkit/{id}/uploads/batch

Presign several brand assets in one call; each returns a presigned PUT URL matched back by media_id.

Path parameters

idstring

Workspace ID

Request body

filesobject[]Required

asset_typestringRequired

durationnumberOptional

file_sizeintegerRequired

heightintegerOptional

media_idstringRequired

mime_typestringRequired

namestringOptional

original_file_namestringOptional

tagsstring[]Optional

widthintegerOptional

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/batch" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "files": [
      {
        "asset_type": "string",
        "duration": 0,
        "file_size": 0,
        "height": 0,
        "media_id": "string",
        "mime_type": "string",
        "name": "string",
        "original_file_name": "string",
        "tags": [
          "string"
        ],
        "width": 0
      }
    ]
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/batch", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "files": [
      {
        "asset_type": "string",
        "duration": 0,
        "file_size": 0,
        "height": 0,
        "media_id": "string",
        "mime_type": "string",
        "name": "string",
        "original_file_name": "string",
        "tags": [
          "string"
        ],
        "width": 0
      }
    ]
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/batch",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "files": [
        {
          "asset_type": "string",
          "duration": 0,
          "file_size": 0,
          "height": 0,
          "media_id": "string",
          "mime_type": "string",
          "name": "string",
          "original_file_name": "string",
          "tags": [
            "string"
          ],
          "width": 0
        }
      ]
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/batch");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["files" => [["asset_type" => "string", "duration" => 0, "file_size" => 0, "height" => 0, "media_id" => "string", "mime_type" => "string", "name" => "string", "original_file_name" => "string", "tags" => ["string"], "width" => 0]]]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "files": [
    {
      "asset_type": "string",
      "duration": 0,
      "file_size": 0,
      "height": 0,
      "media_id": "string",
      "mime_type": "string",
      "name": "string",
      "original_file_name": "string",
      "tags": [
        "string"
      ],
      "width": 0
    }
  ]
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/batch", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/batch")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { files: [{ asset_type: "string", duration: 0, file_size: 0, height: 0, media_id: "string", mime_type: "string", name: "string", original_file_name: "string", tags: ["string"], width: 0 }] }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

filesREQUIREDobject[]

asset_typeREQUIREDstring

durationnumber

file_sizeREQUIREDinteger

heightinteger

media_idREQUIREDstring

mime_typeREQUIREDstring

namestring

original_file_namestring

tagsstring[]

widthinteger

Response

{
  "data": {
    "items": [
      {
        "media_id": "string",
        "presigned_url": "string",
        "upload_id": "string"
      }
    ],
    "rejected": [
      {
        "media_id": "string",
        "reason": "string"
      }
    ]
  }
}

#Finalize a batch of brand kit uploads

POST/v1/brandkit/{id}/uploads/batch/complete

Finalize several uploaded brand assets in one call, reporting any per-upload failures.

Path parameters

idstring

Workspace ID

Request body

upload_idsstring[]Required

Response codes

200

400

Bad Request

401

Unauthorized

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "upload_ids": [
      "string"
    ]
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "upload_ids": [
      "string"
    ]
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "upload_ids": [
        "string"
      ]
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["upload_ids" => ["string"]]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "upload_ids": [
    "string"
  ]
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/batch/complete")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { upload_ids: ["string"] }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

upload_idsREQUIREDstring[]

Response

{
  "data": {
    "failed": [
      {
        "error": "string",
        "upload_id": "string"
      }
    ]
  }
}

#Complete a brand kit upload

POST/v1/brandkit/{id}/uploads/complete

Finalize a previously initiated brand kit upload.

Path parameters

idstring

Workspace ID

Request body

upload_idstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/complete" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/complete", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/complete",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/complete");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/complete", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/complete")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

upload_idREQUIREDstring

#Abort a chunked brand kit upload

POST/v1/brandkit/{id}/uploads/multipart/abort

Discard an in-progress multipart brand asset upload and its pending record.

Path parameters

idstring

Workspace ID

Request body

s3_upload_idstringRequired

upload_idstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "s3_upload_id": "<s3_upload_id>",
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "s3_upload_id": "<s3_upload_id>",
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "s3_upload_id": "<s3_upload_id>",
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["s3_upload_id" => "<s3_upload_id>", "upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "s3_upload_id": "<s3_upload_id>",
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/abort")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { s3_upload_id: "<s3_upload_id>", upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

s3_upload_idREQUIREDstring

upload_idREQUIREDstring

#Complete a chunked brand kit upload

POST/v1/brandkit/{id}/uploads/multipart/complete

Assemble the uploaded parts and finalize the brand asset.

Path parameters

idstring

Workspace ID

Request body

partsobject[]Required

etagstringRequired

part_numberintegerRequired

s3_upload_idstringRequired

upload_idstringRequired

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "parts": [
      {
        "etag": "string",
        "part_number": 0
      }
    ],
    "s3_upload_id": "<s3_upload_id>",
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "parts": [
      {
        "etag": "string",
        "part_number": 0
      }
    ],
    "s3_upload_id": "<s3_upload_id>",
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "parts": [
        {
          "etag": "string",
          "part_number": 0
        }
      ],
      "s3_upload_id": "<s3_upload_id>",
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["parts" => [["etag" => "string", "part_number" => 0]], "s3_upload_id" => "<s3_upload_id>", "upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "parts": [
    {
      "etag": "string",
      "part_number": 0
    }
  ],
  "s3_upload_id": "<s3_upload_id>",
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/complete")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { parts: [{ etag: "string", part_number: 0 }], s3_upload_id: "<s3_upload_id>", upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

partsREQUIREDobject[]

etagREQUIREDstring

part_numberREQUIREDinteger

s3_upload_idREQUIREDstring

upload_idREQUIREDstring

#Initiate a chunked brand kit upload

POST/v1/brandkit/{id}/uploads/multipart/initiate

Start a multipart upload for a brand asset too large for a single request, returning one presigned URL per part.

Path parameters

idstring

Workspace ID

Request body

asset_typestringRequired

durationnumberOptional

file_sizeintegerRequired

heightintegerOptional

mime_typestringRequired

namestringOptional

original_file_namestringOptional

part_countintegerRequired

tagsstring[]Optional

widthintegerOptional

Response codes

200

400

Bad Request

401

Unauthorized

403

Forbidden

curl -X POST "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "asset_type": "<asset_type>",
    "file_size": 0,
    "mime_type": "<mime_type>",
    "part_count": 0
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "asset_type": "<asset_type>",
    "file_size": 0,
    "mime_type": "<mime_type>",
    "part_count": 0
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "asset_type": "<asset_type>",
      "file_size": 0,
      "mime_type": "<mime_type>",
      "part_count": 0
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["asset_type" => "<asset_type>", "file_size" => 0, "mime_type" => "<mime_type>", "part_count" => 0]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "asset_type": "<asset_type>",
  "file_size": 0,
  "mime_type": "<mime_type>",
  "part_count": 0
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/multipart/initiate")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { asset_type: "<asset_type>", file_size: 0, mime_type: "<mime_type>", part_count: 0 }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

asset_typeREQUIREDstring

durationnumber

file_sizeREQUIREDinteger

heightinteger

mime_typeREQUIREDstring

namestring

original_file_namestring

part_countREQUIREDinteger

tagsstring[]

widthinteger

Response

{
  "data": {
    "presigned_urls": [
      {
        "part_number": 0,
        "url": "string"
      }
    ],
    "s3_upload_id": "string",
    "upload_id": "string"
  }
}

#Search brand kit uploads

GET/v1/brandkit/{id}/uploads/search

Search uploaded assets by name, filename or tag, optionally scoped to an asset type.

Path parameters

idstring

Workspace ID

Query parameters

qstringOptional

Search term

asset_typestringOptional

Asset type filter

Response codes

200

curl "https://api.rendley.com/v1/brandkit/ID/uploads/search" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/search", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/uploads/search",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/search");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/uploads/search", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/search")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

qstring

asset_typestring

Response

{
  "data": [
    {
      "asset_type": "string",
      "duration": 0,
      "height": 0,
      "id": "string",
      "mime_type": "string",
      "name": "string",
      "original_file_name": "string",
      "source_url": "string",
      "tags": [
        "string"
      ],
      "width": 0
    }
  ]
}

#Update tags on a brand asset

PUT/v1/brandkit/{id}/uploads/tags

Replace the searchable tag set on an uploaded asset.

Path parameters

idstring

Workspace ID

Request body

tagsstring[]Optional

upload_idstringRequired

Response codes

200

curl -X PUT "https://api.rendley.com/v1/brandkit/ID/uploads/tags" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "upload_id": "<upload_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/uploads/tags", {
  method: "PUT",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "upload_id": "<upload_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.put(
    "https://api.rendley.com/v1/brandkit/ID/uploads/tags",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "upload_id": "<upload_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/uploads/tags");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["upload_id" => "<upload_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "upload_id": "<upload_id>"
}`)
	req, _ := http.NewRequest("PUT", "https://api.rendley.com/v1/brandkit/ID/uploads/tags", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/uploads/tags")
req = Net::HTTP::Put.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { upload_id: "<upload_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

tagsstring[]

upload_idREQUIREDstring

#List brand kit preferred voices

GET/v1/brandkit/{id}/voices

Path parameters

idstring

Workspace ID

Response codes

200

curl "https://api.rendley.com/v1/brandkit/ID/voices" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/voices", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/ID/voices",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/voices");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/ID/voices", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/voices")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Response

{
  "data": [
    {
      "id": "string",
      "model_id": "string",
      "name": "string",
      "order": 0,
      "settings": {},
      "voice_id": "string"
    }
  ]
}

#Add a preferred voice to the brand kit

POST/v1/brandkit/{id}/voices

Free plans are limited to a small number of preferred voices.

Path parameters

idstring

Workspace ID

Request body

model_idstringRequired

namestringOptional

orderintegerOptional

settingsobjectOptional

voice_idstringRequired

Response codes

200

curl -X POST "https://api.rendley.com/v1/brandkit/ID/voices" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "<model_id>",
    "voice_id": "<voice_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/voices", {
  method: "POST",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "model_id": "<model_id>",
    "voice_id": "<voice_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.post(
    "https://api.rendley.com/v1/brandkit/ID/voices",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "model_id": "<model_id>",
      "voice_id": "<voice_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/voices");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["model_id" => "<model_id>", "voice_id" => "<voice_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "model_id": "<model_id>",
  "voice_id": "<voice_id>"
}`)
	req, _ := http.NewRequest("POST", "https://api.rendley.com/v1/brandkit/ID/voices", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/voices")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { model_id: "<model_id>", voice_id: "<voice_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

model_idREQUIREDstring

namestring

orderinteger

settingsjson

voice_idREQUIREDstring

Response

{
  "data": {
    "id": "string",
    "model_id": "string",
    "name": "string",
    "order": 0,
    "settings": {},
    "voice_id": "string"
  }
}

#Remove a preferred voice from the brand kit

DELETE/v1/brandkit/{id}/voices

Path parameters

idstring

Workspace ID

Request body

brandkit_voice_idstringRequired

Response codes

200

curl -X DELETE "https://api.rendley.com/v1/brandkit/ID/voices" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "brandkit_voice_id": "<brandkit_voice_id>"
  }'

const res = await fetch("https://api.rendley.com/v1/brandkit/ID/voices", {
  method: "DELETE",
  headers: { Authorization: "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "brandkit_voice_id": "<brandkit_voice_id>"
  }),
});
const { data } = await res.json();

import requests

res = requests.delete(
    "https://api.rendley.com/v1/brandkit/ID/voices",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
      "brandkit_voice_id": "<brandkit_voice_id>"
    },
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/ID/voices");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY", "Content-Type: application/json"]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["brandkit_voice_id" => "<brandkit_voice_id>"]));

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
	"bytes"
)

func main() {
	body := bytes.NewBufferString(`{
  "brandkit_voice_id": "<brandkit_voice_id>"
}`)
	req, _ := http.NewRequest("DELETE", "https://api.rendley.com/v1/brandkit/ID/voices", body)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/ID/voices")
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
req["Content-Type"] = "application/json"
req.body = { brandkit_voice_id: "<brandkit_voice_id>" }.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

idREQUIREDstring

Body

brandkit_voice_idREQUIREDstring

#List brand kit categories

GET/v1/brandkit/categories

Retrieve the fixed set of brand kit categories.

Response codes

200

401

Unauthorized

curl "https://api.rendley.com/v1/brandkit/categories" \
  -H "Authorization: Bearer YOUR_API_KEY"

const res = await fetch("https://api.rendley.com/v1/brandkit/categories", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const { data } = await res.json();

import requests

res = requests.get(
    "https://api.rendley.com/v1/brandkit/categories",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)
data = res.json()["data"]

$ch = curl_init("https://api.rendley.com/v1/brandkit/categories");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer YOUR_API_KEY"]);

$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true)["data"];

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.rendley.com/v1/brandkit/categories", nil)
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

require "net/http"
require "json"

uri = URI("https://api.rendley.com/v1/brandkit/categories")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(res.body)["data"]

API key

Response

{
  "data": [
    {
      "default": true,
      "group": "string",
      "id": "string",
      "name": "string"
    }
  ]
}