> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pictory.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Using Brand Settings

> Apply saved brand presets to your videos for consistent branding across all content

This guide shows you how to apply saved brand presets to your videos for consistent branding across all your content. Brand presets include logos, colors, fonts, subtitle styles, and other brand elements saved in your Pictory account.

## What You'll Learn

<CardGroup cols={2}>
  <Card title="Brand Presets" icon="palette">
    Use saved brand configurations by name
  </Card>

  <Card title="Consistent Branding" icon="stamp">
    Apply uniform styling across all videos
  </Card>

  <Card title="Quick Production" icon="bolt">
    Speed up video creation with presets
  </Card>

  <Card title="Multi-Brand Support" icon="layer-group">
    Manage multiple brand identities
  </Card>
</CardGroup>

## Before You Begin

Make sure you have:

* A [Pictory API key](https://app.pictory.ai/api-access)
* Node.js or Python installed on your machine
* Brand preset created in your Pictory account
* Brand preset name from your Pictory settings

<CodeGroup>
  ```bash npm theme={null}
  npm install axios
  ```

  ```bash pip theme={null}
  pip install requests
  ```
</CodeGroup>

## How Brand Presets Work

When you apply a brand preset to your video:

1. **Brand Selection** - You specify your brand preset by name
2. **Style Application** - All brand settings are automatically applied
3. **Consistent Elements** - Logos, colors, fonts, and styles are unified
4. **Automatic Formatting** - Subtitles, intro/outro, and layouts use brand settings
5. **Video Creation** - Your video is created with complete brand consistency

<Note>
  Brand presets must be created in your Pictory account before using them via the API. You can create and manage brand presets through the Pictory web interface under Brand Settings.
</Note>

## Complete Example

<CodeGroup>
  ```javascript Node.js theme={null}
  import axios from "axios";

  const API_BASE_URL = "https://api.pictory.ai/pictoryapis";
  const API_KEY = "YOUR_API_KEY";

  const SAMPLE_TEXT =
    "AI is poised to significantly impact educators and course creators on social media. " +
    "By automating tasks like content generation, visual design, and video editing, " +
    "AI will save time and enhance consistency.";

  async function createVideoWithBrandPreset() {
    try {
      console.log("Creating video with brand preset...");

      const response = await axios.post(
        `${API_BASE_URL}/v2/video/storyboard/render`,
        {
          videoName: "text_to_video_with_brand",
          brandName: "{YOUR_BRAND_NAME}",      // Your saved brand preset name

          // Scene configuration
          scenes: [
            {
              story: SAMPLE_TEXT,
              createSceneOnNewLine: true,
              createSceneOnEndOfSentence: true,
            },
          ],
        },
        {
          headers: {
            "Content-Type": "application/json",
            Authorization: API_KEY,
          },
        }
      );

      const jobId = response.data.data.jobId;
      console.log("✓ Video creation started!");
      console.log("Job ID:", jobId);

      // Monitor progress
      console.log("\nMonitoring video creation...");
      let jobCompleted = false;
      let jobResult = null;

      while (!jobCompleted) {
        const statusResponse = await axios.get(
          `${API_BASE_URL}/v1/jobs/${jobId}`,
          {
            headers: { Authorization: API_KEY },
          }
        );

        const status = statusResponse.data.data.status;
        console.log("Status:", status);

        if (status === "completed") {
          jobCompleted = true;
          jobResult = statusResponse.data;
          console.log("\n✓ Video with brand preset is ready!");
          console.log("Video URL:", jobResult.data.videoURL);
        } else if (status === "failed") {
          throw new Error("Video creation failed: " + JSON.stringify(statusResponse.data));
        }

        await new Promise(resolve => setTimeout(resolve, 5000));
      }

      return jobResult;
    } catch (error) {
      console.error("Error:", error.response?.data || error.message);
      throw error;
    }
  }

  createVideoWithBrandPreset();
  ```

  ```python Python theme={null}
  import requests
  import time
  import json

  API_BASE_URL = 'https://api.pictory.ai/pictoryapis'
  API_KEY = 'YOUR_API_KEY'

  SAMPLE_TEXT = (
      "AI is poised to significantly impact educators and course creators on social media. "
      "By automating tasks like content generation, visual design, and video editing, "
      "AI will save time and enhance consistency."
  )

  def create_video_with_brand_preset():
      try:
          print("Creating video with brand preset...")

          response = requests.post(
              f'{API_BASE_URL}/v2/video/storyboard/render',
              json={
                  'videoName': 'text_to_video_with_brand',
                  'brandName': '{YOUR_BRAND_NAME}',      # Your saved brand preset name

                  # Scene configuration
                  'scenes': [
                      {
                          'story': SAMPLE_TEXT,
                          'createSceneOnNewLine': True,
                          'createSceneOnEndOfSentence': True
                      }
                  ]
              },
              headers={
                  'Content-Type': 'application/json',
                  'Authorization': API_KEY
              }
          )
          response.raise_for_status()

          job_id = response.json()['data']['jobId']
          print("✓ Video creation started!")
          print(f"Job ID: {job_id}")

          # Monitor progress
          print("\nMonitoring video creation...")
          job_completed = False
          job_result = None

          while not job_completed:
              status_response = requests.get(
                  f'{API_BASE_URL}/v1/jobs/{job_id}',
                  headers={'Authorization': API_KEY}
              )
              status_response.raise_for_status()

              status = status_response.json()['data']['status']
              print(f"Status: {status}")

              if status == 'completed':
                  job_completed = True
                  job_result = status_response.json()
                  print("\n✓ Video with brand preset is ready!")
                  print(f"Video URL: {job_result['data']['videoURL']}")
              elif status == 'failed':
                  raise Exception(f"Video creation failed: {status_response.json()}")

              time.sleep(5)

          return job_result

      except requests.exceptions.RequestException as error:
          print(f"Error: {error}")
          if hasattr(error, 'response') and error.response is not None:
              print(f"Response: {error.response.text}")
          raise

  if __name__ == '__main__':
      create_video_with_brand_preset()
  ```
</CodeGroup>

## Understanding the Parameters

| Parameter   | Type   | Required | Description                                                  |
| ----------- | ------ | -------- | ------------------------------------------------------------ |
| `videoName` | string | Yes      | A descriptive name for your video project                    |
| `brandName` | string | Yes      | Exact name of your saved brand preset from Pictory account   |
| `scenes`    | array  | Yes      | Video scene configuration (story text, scene creation rules) |

<Warning>
  **Brand Name is Case-Sensitive:** The brand name must exactly match the name saved in your Pictory account, including capitalization and spacing.
</Warning>

## Brand Preset Components

Brand presets automatically apply these elements to your videos:

| Element             | What It Includes                      | Example                            |
| ------------------- | ------------------------------------- | ---------------------------------- |
| **Logo**            | Position, size, and placement         | Company logo in top-right corner   |
| **Colors**          | Primary and secondary brand colors    | Specific hex codes for consistency |
| **Fonts**           | Text styling and typography           | Branded font families and sizes    |
| **Intro/Outro**     | Branded opening and closing sequences | 5-second branded intro video       |
| **Subtitle Styles** | Consistent caption formatting         | Font, color, position, animations  |
| **Voice Settings**  | Preferred AI voice configuration      | Specific voice, speed, volume      |

## Finding Your Brand Presets

### Option 1: Using the Pictory Web Interface

1. Log in to your Pictory account
2. Navigate to **Brand Kits** or **Brand Settings**
3. View your saved brand presets
4. Note the exact brand name to use in your API calls

### Option 2: Using the API

Retrieve all your brand presets programmatically:

<CodeGroup>
  ```javascript Node.js theme={null}
  const brandsResponse = await axios.get(
    `${API_BASE_URL}/v1/brands/video`,
    { headers: { Authorization: API_KEY } }
  );

  console.log('Your brand presets:');
  brandsResponse.data.forEach(brand => {
    console.log(`- Name: ${brand.name}`);
    console.log(`  ID: ${brand.id}`);
  });

  // Use the 'name' field in your video creation requests
  ```

  ```python Python theme={null}
  brands_response = requests.get(
      f'{API_BASE_URL}/v1/brands/video',
      headers={'Authorization': API_KEY}
  )

  print('Your brand presets:')
  for brand in brands_response.json():
      print(f"- Name: {brand['name']}")
      print(f"  ID: {brand['id']}")

  # Use the 'name' field in your video creation requests
  ```
</CodeGroup>

See [Get Video Brands](/api-reference/branding/get-video-brands) for complete API documentation.

## Common Use Cases

### Maintaining Brand Consistency

```javascript theme={null}
{
  videoName: "company_announcement",
  brandName: "Corporate Brand"
}
```

**Result:** All company videos use identical branding, ensuring professional consistency.

### Quick Video Production

```javascript theme={null}
{
  videoName: "social_media_post",
  brandName: "Social Media Brand"
}
```

**Result:** Instantly create videos with pre-configured social media styling.

### Multi-Brand Management

```javascript theme={null}
// Client A video
{ brandName: "Client A Brand" }

// Client B video
{ brandName: "Client B Brand" }
```

**Result:** Agencies can manage multiple client brands easily with separate presets.

### Team Collaboration

```javascript theme={null}
{
  videoName: "team_training",
  brandName: "Internal Training Brand"
}
```

**Result:** All team members use the same brand guidelines automatically.

## Best Practices

<AccordionGroup>
  <Accordion title="Create Multiple Brand Presets">
    Organize brand presets for different use cases:

    * **Corporate:** Professional presentations and announcements
    * **Social Media:** Casual content for Instagram, TikTok, LinkedIn
    * **Training:** Educational and internal training videos
    * **Marketing:** Promotional and sales videos
    * **Events:** Conference and webinar content

    This allows you to quickly select the appropriate branding for each video type.
  </Accordion>

  <Accordion title="Use Descriptive Brand Names">
    Name your brand presets clearly:

    * **Good:** "Corporate - Blue Theme", "Social - Casual Style"
    * **Avoid:** "Brand1", "Test", "New"

    Clear names make it easier to select the right preset and maintain your API code.
  </Accordion>

  <Accordion title="Test Brand Presets Before API Use">
    Before using a brand preset via the API:

    * Create a test video in the Pictory web interface
    * Verify all brand elements appear correctly
    * Confirm colors, fonts, and logos are as expected
    * Make any adjustments in the brand settings
    * Then use the finalized preset in your API calls
  </Accordion>

  <Accordion title="Keep Brand Presets Updated">
    Maintain your brand presets over time:

    * Update logos when branding changes
    * Refresh color schemes seasonally if needed
    * Adjust subtitle styles based on platform trends
    * Test updated presets before using in production
    * Document changes for your team
  </Accordion>

  <Accordion title="Document Brand Preset Usage">
    Create a reference guide for your team:

    * List all available brand presets with descriptions
    * Specify which preset to use for which content type
    * Include example API requests for common scenarios
    * Note any special requirements or restrictions
    * Update documentation when adding new presets
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Error: Brand not found">
    **Problem:** API returns an error that the brand preset does not exist.

    **Solution:**

    * Verify the brand name is spelled exactly as saved in Pictory
    * Check for case sensitivity (e.g., "Corporate" vs "corporate")
    * Use the Get Video Brands API to see all available presets
    * Ensure the brand preset exists in your account
    * Try copying the name directly from the Pictory interface
  </Accordion>

  <Accordion title="Brand elements not appearing in video">
    **Problem:** Video does not show logo, colors, or other brand elements.

    **Solution:**

    * Check that the brand preset is fully configured in Pictory
    * Verify all brand elements are saved in the preset
    * Test the preset in the Pictory web interface first
    * Ensure the preset includes the specific elements you expect
    * Review the completed video - some elements may be subtle
  </Accordion>

  <Accordion title="Brand preset works in UI but not via API">
    **Problem:** Brand works in Pictory interface but not through API calls.

    **Solution:**

    * Confirm you are using the exact brand name (check spelling and case)
    * Use the Get Video Brands API to retrieve the correct name
    * Ensure your API key has access to that brand preset
    * Check that the preset has not been deleted or renamed
    * Verify no special characters or extra spaces in the name
  </Accordion>

  <Accordion title="Wrong brand applied to video">
    **Problem:** Video uses a different brand preset than specified.

    **Solution:**

    * Double-check the `brandName` parameter in your request
    * Ensure you are not overriding brand elements with other parameters
    * Verify the brand name is in quotes and properly formatted
    * Check for typos or autocomplete errors in your code
    * Review the request payload before sending
  </Accordion>

  <Accordion title="Cannot access brand presets">
    **Problem:** Get Video Brands API returns empty or errors.

    **Solution:**

    * Confirm you have created brand presets in your Pictory account
    * Check that your API key is valid and active
    * Ensure you are using the correct API endpoint
    * Verify your account has access to brand features
    * Contact support if the issue persists
  </Accordion>
</AccordionGroup>

## Next Steps

Explore more branding customization options:

<CardGroup cols={2}>
  <Card title="Custom Logo" icon="image" href="/guides/branding-customization/logo">
    Add and position logos without brand presets
  </Card>

  <Card title="Subtitle Styles" icon="closed-captioning" href="/guides/branding-customization/subtitle-styles">
    Apply saved subtitle styling to videos
  </Card>

  <Card title="Custom Subtitle Style" icon="font" href="/guides/branding-customization/custom-subtitle-style">
    Create inline subtitle styles without presets
  </Card>

  <Card title="Highlight Keywords" icon="highlighter" href="/guides/branding-customization/highlight-keywords">
    Emphasize important words in subtitles
  </Card>
</CardGroup>

## API Reference

For complete technical details, see:

* [Get Video Brands](/api-reference/branding/get-video-brands) - List all your brand presets
* [Render Storyboard Video](/api-reference/videos/render-storyboard-video) - Full API specification
* [Get Job Status](/api-reference/jobs/get-video-render-job-by-id) - Monitor job status and progress