Skip to main content
GET
https://api.pictory.ai
/
pictoryapis
/
v1
/
video
/
storyboard
/
fonts
Get Fonts
curl --request GET \
  --url https://api.pictory.ai/pictoryapis/v1/video/storyboard/fonts \
  --header 'Authorization: <authorization>'
[
  "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"
]

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"
]

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

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:
CategoryFontsUse Case
Sans-SerifArial, Helvetica, Calibri, Lato, Open Sans, Poppins, Roboto, Noto Sans, Source Sans Pro, Josefin Sans, Ubuntu, ProximaNova, QuicksandModern, clean text; body copy; UI elements
SerifMerriweather, RokkittTraditional, formal text; headings; elegant designs
MonospaceCourier Prime, Space monoCode snippets; technical content; typewriter effect
Script/HandwritingDancing Script, Caveat, Moon dancePersonal touch; invitations; creative designs
Display/DecorativeGrandstander, Rowdies, Averia Libre, MontserratHeadlines; 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

  1. Cache Font List: Fetch fonts once and cache them locally. The list changes infrequently.
  2. Use Exact Names: Always use the exact font name as returned by the API, including capitalization and spacing.
  3. Provide Font Preview: In user interfaces, display visual previews of fonts in their actual typeface to help users make selections.
  4. Group by Category: Organize fonts into logical categories (Sans-Serif, Serif, Script, etc.) for better user experience.
  5. Sort Alphabetically: Present fonts in alphabetical order for easy browsing.
  6. Validate Font Names: Before applying a font to a video element, verify the name exists in the current list of supported fonts.
  7. 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)
  8. Test Font Sizes: Different fonts have different optical sizes. Test readability at various sizes.
  9. Limit Font Variety: Use 2-3 fonts maximum per video for visual consistency.
  10. 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"
)

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)