Get Fonts

curl --request GET \
  --url https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts \
  --header 'Authorization: <authorization>'

import requests

url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"

headers = {"Authorization": "<authorization>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts")
  .header("Authorization", "<authorization>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

[
  "Arial",
  "Averia Libre",
  "Calibri",
  "Caveat",
  "Courier Prime",
  "Dancing Script",
  "Grandstander",
  "Helvetica",
  "Helvetica Neue",
  "Josefin Sans",
  "Lato",
  "Merriweather",
  "Montserrat",
  "Moon dance",
  "Noto Sans",
  "Open Sans",
  "Poppins",
  "ProximaNova",
  "Quicksand",
  "Roboto",
  "Rokkitt",
  "Rowdies",
  "Source Sans Pro",
  "Space mono",
  "Ubuntu"
]

{
  "message": "Unauthorized"
}

{
  "error": {
    "code": "INTERNAL_ERROR",
    "message": "An unexpected error occurred"
  }
}

GET

pictoryapis

video

storyboard

fonts

Get Fonts

curl --request GET \
  --url https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts \
  --header 'Authorization: <authorization>'

import requests

url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"

headers = {"Authorization": "<authorization>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts")
  .header("Authorization", "<authorization>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

[
  "Arial",
  "Averia Libre",
  "Calibri",
  "Caveat",
  "Courier Prime",
  "Dancing Script",
  "Grandstander",
  "Helvetica",
  "Helvetica Neue",
  "Josefin Sans",
  "Lato",
  "Merriweather",
  "Montserrat",
  "Moon dance",
  "Noto Sans",
  "Open Sans",
  "Poppins",
  "ProximaNova",
  "Quicksand",
  "Roboto",
  "Rokkitt",
  "Rowdies",
  "Source Sans Pro",
  "Space mono",
  "Ubuntu"
]

{
  "message": "Unauthorized"
}

{
  "error": {
    "code": "INTERNAL_ERROR",
    "message": "An unexpected error occurred"
  }
}

Overview

Fetch all supported text fonts available for video generation in the Pictory App. These fonts can be applied to text elements in your video storyboard, including captions, titles, headings, and body text. Use this endpoint to retrieve available fonts for video editing, text customization, or to allow users to select from supported font options when creating or editing video content.

You need a valid API key to use this endpoint. Get your API key from the API Access page in your Pictory dashboard.

API Endpoint

GET https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts

Request Parameters

Headers

Authorization

string

required

API key for authentication (starts with pictai_)

Authorization: YOUR_API_KEY

Response

Returns an array of font names as strings. Each font name represents a supported typeface that can be used in video text elements.

Array

array of strings

List of available font names

Response Examples

[
  "Arial",
  "Averia Libre",
  "Calibri",
  "Caveat",
  "Courier Prime",
  "Dancing Script",
  "Grandstander",
  "Helvetica",
  "Helvetica Neue",
  "Josefin Sans",
  "Lato",
  "Merriweather",
  "Montserrat",
  "Moon dance",
  "Noto Sans",
  "Open Sans",
  "Poppins",
  "ProximaNova",
  "Quicksand",
  "Roboto",
  "Rokkitt",
  "Rowdies",
  "Source Sans Pro",
  "Space mono",
  "Ubuntu"
]

{
  "message": "Unauthorized"
}

{
  "error": {
    "code": "INTERNAL_ERROR",
    "message": "An unexpected error occurred"
  }
}

Code Examples

Replace YOUR_API_KEY with your actual API key that starts with pictai_

curl --request GET \
  --url 'https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts' \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'accept: application/json' | python -m json.tool

import requests

url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
headers = {
    "Authorization": "YOUR_API_KEY",
    "accept": "application/json"
}

response = requests.get(url, headers=headers)
fonts = response.json()

print(f"Total fonts available: {len(fonts)}\n")

# Display all fonts
for i, font in enumerate(fonts, 1):
    print(f"{i}. {font}")

const response = await fetch(
  'https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts',
  {
    method: 'GET',
    headers: {
      'Authorization': 'YOUR_API_KEY',
      'accept': 'application/json'
    }
  }
);

const fonts = await response.json();

console.log(`Total fonts available: ${fonts.length}\n`);

// Display all fonts
fonts.forEach((font, index) => {
  console.log(`${index + 1}. ${font}`);
});

<?php
// Replace 'YOUR_API_KEY' with your actual API key

function getFonts($apiKey) {
    $url = 'https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts';

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: ' . $apiKey,
        'accept: application/json'
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode !== 200) {
        throw new Exception('Request failed with status ' . $httpCode);
    }

    return json_decode($response, true);
}

// Usage
try {
    $fonts = getFonts('YOUR_API_KEY');

    echo "Total fonts available: " . count($fonts) . "\n\n";

    // Display all fonts
    foreach ($fonts as $index => $font) {
        echo ($index + 1) . ". $font\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

// Replace "YOUR_API_KEY" with your actual API key

package main

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

func getFonts(apiKey string) ([]string, error) {
    url := "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", apiKey)
    req.Header.Set("accept", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("request failed (status %d): %s", resp.StatusCode, string(body))
    }

    var fonts []string
    if err := json.Unmarshal(body, &fonts); err != nil {
        return nil, err
    }

    return fonts, nil
}

// Usage
func main() {
    fonts, err := getFonts("YOUR_API_KEY")
    if err != nil {
        panic(err)
    }

    fmt.Printf("Total fonts available: %d\n\n", len(fonts))

    // Display all fonts
    for i, font := range fonts {
        fmt.Printf("%d. %s\n", i+1, font)
    }
}

Common Use Cases

1. List All Available Fonts

Retrieve and display all supported fonts:

import requests

url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
headers = {
    "Authorization": "YOUR_API_KEY",
    "accept": "application/json"
}

response = requests.get(url, headers=headers)
fonts = response.json()

print(f"Total fonts: {len(fonts)}\n")

# Display in columns
for i in range(0, len(fonts), 3):
    row = fonts[i:i+3]
    print("  ".join(f"{font:<20}" for font in row))

2. Create Font Selector for UI

Build a dropdown/selector component:

import requests

def get_fonts_for_selector(api_key):
    """
    Get fonts formatted for a UI selector.

    Args:
        api_key: Your API key

    Returns:
        List of selector options
    """
    url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    fonts = response.json()

    # Format for UI selector
    selector_options = [
        {
            "value": font,
            "label": font
        }
        for font in sorted(fonts)
    ]

    return selector_options

# Usage
options = get_fonts_for_selector("YOUR_API_KEY")

print(f"Font options: {len(options)}\n")

# Example output
for option in options[:10]:
    print(f"  {option['label']}")

3. Categorize Fonts by Type

Organize fonts into categories based on their characteristics:

import requests

def categorize_fonts(api_key):
    """
    Categorize fonts based on their characteristics.

    Args:
        api_key: Your API key

    Returns:
        Dictionary with categorized fonts
    """
    url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    fonts = response.json()

    categories = {
        'Sans-Serif': [],
        'Serif': [],
        'Monospace': [],
        'Script/Handwriting': [],
        'Display/Decorative': [],
        'Other': []
    }

    # Categorize fonts based on name patterns
    sans_serif = ['Arial', 'Helvetica', 'Calibri', 'Lato', 'Open Sans',
                  'Poppins', 'Roboto', 'Noto Sans', 'Source Sans Pro',
                  'Josefin Sans', 'Ubuntu', 'ProximaNova', 'Quicksand']

    serif = ['Merriweather', 'Rokkitt']

    monospace = ['Courier Prime', 'Space mono']

    script = ['Dancing Script', 'Caveat', 'Moon dance']

    display = ['Grandstander', 'Rowdies', 'Averia Libre', 'Montserrat']

    for font in fonts:
        if font in sans_serif:
            categories['Sans-Serif'].append(font)
        elif font in serif:
            categories['Serif'].append(font)
        elif font in monospace:
            categories['Monospace'].append(font)
        elif font in script:
            categories['Script/Handwriting'].append(font)
        elif font in display:
            categories['Display/Decorative'].append(font)
        else:
            categories['Other'].append(font)

    return categories

# Usage
categories = categorize_fonts("YOUR_API_KEY")

for category, fonts in categories.items():
    if fonts:
        print(f"\n{category} ({len(fonts)} fonts):")
        for font in fonts:
            print(f"  - {font}")

4. Search Fonts by Name

Find fonts matching specific criteria:

import requests

def search_fonts(api_key, search_term):
    """
    Search for fonts by name.

    Args:
        api_key: Your API key
        search_term: Text to search for in font names

    Returns:
        List of matching font names
    """
    url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    fonts = response.json()

    # Case-insensitive search
    search_term_lower = search_term.lower()
    matches = [
        font for font in fonts
        if search_term_lower in font.lower()
    ]

    return matches

# Usage - Find all fonts containing "sans"
sans_fonts = search_fonts("YOUR_API_KEY", "sans")

print(f"Found {len(sans_fonts)} fonts containing 'sans':")
for font in sans_fonts:
    print(f"- {font}")

# Find monospace fonts
mono_fonts = search_fonts("YOUR_API_KEY", "mono")
print(f"\nFound {len(mono_fonts)} monospace fonts:")
for font in mono_fonts:
    print(f"- {font}")

5. Validate Font Names

Check if a font name is supported:

import requests

def validate_font(api_key, font_name):
    """
    Validate if a font name is supported.

    Args:
        api_key: Your API key
        font_name: The font name to validate

    Returns:
        Tuple of (is_valid, exact_match or None)
    """
    url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    response = requests.get(url, headers=headers)
    fonts = response.json()

    # Exact match (case-sensitive)
    if font_name in fonts:
        return True, font_name

    # Case-insensitive match
    for font in fonts:
        if font.lower() == font_name.lower():
            return True, font

    return False, None

# Usage
test_fonts = ["Arial", "arial", "Roboto", "Times New Roman", "Poppins"]

for font in test_fonts:
    is_valid, exact_match = validate_font("YOUR_API_KEY", font)
    if is_valid:
        print(f"✓ '{font}' is valid (exact: '{exact_match}')")
    else:
        print(f"✗ '{font}' is not supported")

Font Categories

The supported fonts can be grouped into the following categories:

Category	Fonts	Use Case
Sans-Serif	Arial, Helvetica, Calibri, Lato, Open Sans, Poppins, Roboto, Noto Sans, Source Sans Pro, Josefin Sans, Ubuntu, ProximaNova, Quicksand	Modern, clean text; body copy; UI elements
Serif	Merriweather, Rokkitt	Traditional, formal text; headings; elegant designs
Monospace	Courier Prime, Space mono	Code snippets; technical content; typewriter effect
Script/Handwriting	Dancing Script, Caveat, Moon dance	Personal touch; invitations; creative designs
Display/Decorative	Grandstander, Rowdies, Averia Libre, Montserrat	Headlines; attention-grabbing text; branding

Font Characteristics

Sans-Serif Fonts

Best for: Modern designs, body text, readability on screens

Arial - Classic, widely supported
Helvetica / Helvetica Neue - Professional, clean
Roboto - Modern, geometric
Open Sans - Friendly, optimized for web
Lato - Warm, contemporary
Poppins - Geometric, playful
Montserrat - Urban, sophisticated

Serif Fonts

Best for: Traditional designs, printed materials, elegance

Merriweather - Designed for screens, highly readable
Rokkitt - Geometric slab serif, distinctive

Monospace Fonts

Best for: Code, technical documentation, retro designs

Courier Prime - Classic typewriter style
Space mono - Quirky, geometric

Script & Handwriting Fonts

Best for: Personal touch, creative projects, invitations

Dancing Script - Elegant, flowing
Caveat - Casual, handwritten
Moon dance - Playful, decorative

Display & Decorative Fonts

Best for: Headlines, logos, attention-grabbing text

Grandstander - Bold, energetic
Rowdies - Fun, rounded
Averia Libre - Artistic, unique

Usage Notes

Font Names are Case-Sensitive: When applying fonts to video elements, use the exact font name as returned by this endpoint, including capitalization.

Caching Recommended: The list of supported fonts changes infrequently. Cache the results locally to improve performance and reduce API calls.

Fallback Fonts: If a specified font is unavailable, the system will fall back to a default font (typically Arial or Roboto).

Best Practices

Cache Font List: Fetch fonts once and cache them locally. The list changes infrequently.
Use Exact Names: Always use the exact font name as returned by the API, including capitalization and spacing.
Provide Font Preview: In user interfaces, display visual previews of fonts in their actual typeface to help users make selections.
Group by Category: Organize fonts into logical categories (Sans-Serif, Serif, Script, etc.) for better user experience.
Sort Alphabetically: Present fonts in alphabetical order for easy browsing.
Validate Font Names: Before applying a font to a video element, verify the name exists in the current list of supported fonts.
Consider Readability: Choose fonts appropriate for the video context:
- Captions/Subtitles: Sans-serif fonts (Arial, Roboto, Open Sans)
- Headlines: Display or bold sans-serif fonts (Montserrat, Poppins)
- Formal Content: Serif fonts (Merriweather)
- Creative/Personal: Script fonts (Dancing Script, Caveat)
Test Font Sizes: Different fonts have different optical sizes. Test readability at various sizes.
Limit Font Variety: Use 2-3 fonts maximum per video for visual consistency.
Accessibility: Ensure sufficient contrast between text and background. Avoid overly decorative fonts for important information.

Integration with Video Storyboard

Apply fonts when creating or updating video storyboard elements:

import requests

def apply_font_to_text_element(api_key, project_id, font_name):
    """
    Example of applying a font to a text element in a video storyboard.

    Args:
        api_key: Your API key
        project_id: The project ID
        font_name: The font to apply

    Note: This is a conceptual example. The actual implementation
    depends on the storyboard update endpoint structure.
    """
    # First, validate the font exists
    fonts_url = "https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    fonts_response = requests.get(fonts_url, headers=headers)
    fonts = fonts_response.json()

    # Check if font exists
    if font_name not in fonts:
        # Try case-insensitive match
        font_match = next((f for f in fonts if f.lower() == font_name.lower()), None)
        if font_match:
            font_name = font_match
        else:
            raise ValueError(f"Font '{font_name}' not supported")

    # Apply font to storyboard element
    print(f"Applying font '{font_name}' to project {project_id}")
    # Implementation depends on storyboard update endpoint

# Usage
apply_font_to_text_element(
    "YOUR_API_KEY",
    "project-123",
    "Poppins"
)

Popular Font Combinations

Professional & Clean

Heading: Montserrat (Bold)
Body: Open Sans (Regular)
Caption: Roboto (Light)

Modern & Friendly

Heading: Poppins (SemiBold)
Body: Lato (Regular)
Caption: Lato (Light)

Classic & Elegant

Heading: Merriweather (Bold)
Body: Lato (Regular)
Caption: Lato (Italic)

Creative & Playful

Heading: Grandstander (Bold)
Body: Quicksand (Regular)
Caption: Quicksand (Light)

Technical & Modern

Heading: Roboto (Bold)
Body: Roboto (Regular)
Code: Courier Prime (Regular)

Get Text Styles - Retrieve text styling presets
Get Video Brands - Retrieve video brand configurations
Video Storyboard - Create and manage video storyboards

Get Video Brands List Projects

⌘I

​Overview

​API Endpoint

​Request Parameters

​Headers

​Response

​Response Examples

​Code Examples

​Common Use Cases

​1. List All Available Fonts

​2. Create Font Selector for UI

​3. Categorize Fonts by Type

​4. Search Fonts by Name

​5. Validate Font Names

​Font Categories

​Font Characteristics

​Sans-Serif Fonts

​Serif Fonts

​Monospace Fonts

​Script & Handwriting Fonts

​Display & Decorative Fonts

​Usage Notes

​Best Practices

​Integration with Video Storyboard

​Popular Font Combinations

​Professional & Clean

​Modern & Friendly

​Classic & Elegant

​Creative & Playful

​Technical & Modern

​Related Endpoints

Overview

API Endpoint

Request Parameters

Headers

Response

Response Examples

Code Examples

Common Use Cases

1. List All Available Fonts

2. Create Font Selector for UI

3. Categorize Fonts by Type

4. Search Fonts by Name

5. Validate Font Names

Font Categories

Font Characteristics

Sans-Serif Fonts

Serif Fonts

Monospace Fonts

Script & Handwriting Fonts

Display & Decorative Fonts

Usage Notes

Best Practices

Integration with Video Storyboard

Popular Font Combinations

Professional & Clean

Modern & Friendly

Classic & Elegant

Creative & Playful

Technical & Modern

Related Endpoints