Get Fonts

GET https://api.pictory.ai/pictoryapis/v1/video/storyboard/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))

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']}")

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}")

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}")

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

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