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

# Setup Project

> Initialize dubbing projects through the API for seamless editing and management in CAMB.AI Studio. This endpoint creates the foundation for your dubbing workflow by analyzing source media and establishing optimal configuration parameters.

Bridge the gap between API automation and hands-on creative control with our Project Setup endpoint. This powerful tool allows you to programmatically initialize dubbing projects that seamlessly integrate with CAMB.AI Studio, giving you the best of both worlds: automated project creation through your existing workflows and the flexibility to fine-tune results through our visual interface.

Think of this endpoint as your content's intelligent onboarding system. It analyzes your media, validates configurations, and creates a fully-prepared project ready for detailed editing in CAMB.AI Studio. This approach transforms how content teams work, enabling developers to handle project initialization while creative professionals focus on perfecting the final output.

## Why Project Setup Matters for API Users

The traditional dubbing workflow often creates friction between technical teams managing content pipelines and creative teams perfecting the final product. Project Setup eliminates this friction by establishing a clear handoff point where technical configuration meets creative refinement.

When you submit a project through this endpoint, you're not just uploading media—you're creating a structured workspace in CAMB.AI Studio that contains all the analysis, configuration, and preparation work needed for efficient dubbing. Your creative team receives a project that's already optimized and ready for detailed editing, rather than starting from scratch with raw media files.

## The API-to-Studio Workflow

Understanding how Project Setup connects API automation with Studio editing helps you design more efficient content workflows. The process creates a seamless bridge between programmatic project creation and visual editing tools.

**Automated Project Initialization**: Your API request handles all the technical groundwork—media analysis, language configuration, and optimization parameter selection. This automation ensures consistent project setup across your entire content library while eliminating manual configuration errors.

**Studio-Ready Project Creation**: The endpoint generates a fully-prepared project workspace in CAMB.AI Studio, complete with analyzed audio tracks, configured language settings, and optimized processing parameters. Your creative team can immediately begin working with the content rather than spending time on technical setup.

**Preserved Configuration Context**: All API-specified parameters, including custom dictionaries and advanced audio track settings, carry forward into the Studio environment. This continuity ensures that your technical requirements remain intact while enabling creative refinement.

## Media Source Compatibility

Project Setup accommodates diverse media sources, making it easy to integrate with existing content management systems. Whether your media lives on YouTube, Google Drive, or professional storage systems, the endpoint handles ingestion automatically.

The system supports both consumer formats like MP4 and professional broadcast formats including MXF files for Enterprise customers. This broad compatibility means you can standardize your project creation process regardless of your content's origin or quality level.

<Info>Enterprise plan customers enjoy exclusive access to MXF format support, bringing professional broadcast standards to organizations with specialized media requirements.</Info>

## Implementation Example

Let's examine how to create a project that leverages both API efficiency and Studio flexibility. This example demonstrates the essential parameters while showing how your configuration translates into a Studio-ready workspace.

```python [expandable] theme={null}
import requests
import json

# Configure API authentication
headers = {
    "x-api-key": "your-api-key",  # Replace with your actual API key
    "Content-Type": "application/json"
}

# Define project configuration
# This setup creates a project optimized for Studio editing
project_config = {
    "project_name": "Product Launch Campaign",  # Project name visible in Studio
    "project_description": "Multi-language product demo for global markets",  # Context for Studio users
    "media_url": "https://your-storage.com/product-demo.mp4",  # Source media location
    "source_language": 1,      # English - get IDs from /source-languages
    "target_languages": [5, 76, 12],   # Spanish, French, German - check /target-languages
}

def create_studio_project(payload):
    """
    Creates a project configured for optimal Studio editing experience.
    The resulting project appears in CAMB.AI Studio with all technical setup complete.
    """
    try:
        response = requests.post(
            "https://client.camb.ai/apis/project-setup",
            headers=headers,
            data=json.dumps(payload)
        )

        response.raise_for_status()
        result = response.json()

        task_id = result.get("task_id")
        return task_id

    except requests.exceptions.RequestException as e:
        print(f"Project creation failed: {e}")
        return None

# Create the project
project_setup_task_id = create_studio_project(project_config)

if not project_setup_task_id:
    print(f"Failed to create project '{project_config['project_name']}'. Please check your API key and configuration.")
else:
    print(f"Project '{project_config['project_name']}' task is created successfully! Task ID: {project_setup_task_id}")
```

## Best Practices for API-Studio Integration

Successful integration between API project creation and Studio editing depends on understanding how your configuration choices impact the creative editing experience. Several strategies can significantly improve your team's efficiency and output quality.

**Descriptive Project Naming**: Use clear, descriptive names and descriptions that help Studio users understand project context immediately. This clarity becomes crucial when managing multiple projects or coordinating between team members with different responsibilities.

**Optimal Language Configuration**: Verify language IDs using the dedicated endpoints before submitting projects. Accurate language configuration ensures that Studio users receive projects with properly configured voice options and translation models.

**Quality-Focused Media Selection**: Choose the highest quality source media available, as compression artifacts and audio issues in source material become more apparent during the detailed editing process in Studio. Starting with quality media enables better creative decisions throughout the editing workflow.

Project Setup represents the ideal fusion of API automation and creative control. By handling the technical groundwork programmatically, you enable your creative team to focus on the nuanced decisions that determine final quality, while ensuring consistent, professional results across your entire content pipeline.


## OpenAPI

````yaml post /project-setup
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://client.camb.ai/apis
security: []
paths:
  /project-setup:
    post:
      tags:
        - Apis
        - Project Setup
      summary: Create Project
      operationId: create_project_project_setup_post
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateProjectSetupRequestPayload'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TaskID'
                description: >-
                  A JSON that contains the unique identifier for the task. This
                  is used to query the status of the text to voice task that is
                  running. It is returned when a create request is made for
                  setting up a project task.
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - APIKeyHeader: []
components:
  schemas:
    CreateProjectSetupRequestPayload:
      properties:
        project_name:
          type: string
          title: Project Name
          description: >-
            Enter a distinctive name for your project that reflects its purpose
            or content. This name will be displayed in your CAMB.AI workspace
            dashboard and used to organize related assets, transcriptions, etc..
            . Choose something memorable that helps you quickly identify this
            specific project among your other voice, audio and localization
            tasks.
          minLength: 3
          maxLength: 255
          nullable: true
        project_description:
          type: string
          title: Project Description
          description: >-
            Provide details about your project's goals and specifications.
            Include information such as the target languages for translation or
            dubbing, desired voice characteristics, emotional tones to capture,
            or specific audio processing requirements, outlining the workflow
            here can serve as valuable documentation for organizational
            purposes.
          minLength: 3
          maxLength: 5000
          nullable: true
        media_url:
          type: string
          format: uri
          title: Media Url
          description: >-
            The source location of your media content. This URI can point to
            YouTube videos, Google Drive files, or direct media file URLs. The
            system validates accessibility and begins media analysis immediately
            upon receipt. Think of this as telling the system where to find your
            raw material for processing
        source_language:
          $ref: '#/components/schemas/Languages'
          description: >-
            The language identifier for the original audio in your media. This
            selection determines which speech recognition models and analysis
            approaches the system applies to your content. Accurate source
            language specification ensures optimal transcription quality, which
            directly impacts the final dubbing results your team will work with
            in Studio.
        target_languages:
          items:
            $ref: '#/components/schemas/Languages'
          type: array
          title: Target Languages
          description: >-
            An array of language identifiers representing the languages you want
            your content dubbed into. Each language in this array creates a
            separate dubbing track in your Studio project, giving your creative
            team complete control over each language version. The system
            optimizes voice selection and translation models based on these
            choices.
        selected_audio_tracks:
          items:
            type: integer
            required: true
          type: array
          nullable: true
          uniqueItems: true
          description: >-
            Optional array of one or two zero‑based audio track indices to dub.
            Only supported for `MXF` files. If omitted, the first audio track
            (index 0) is used by default.
          minItems: 1
          maxItems: 2
          default: null
        add_output_as_an_audio_track:
          type: boolean
          nullable: true
          default: null
          description: >-
            Optional flag to append the dubbed audio as a new audio track in the
            output file. Only supported for `MXF` files. If `true`, the dubbed
            audio is added as an additional track; if `false` or omitted, the
            source would be returned with only dubbed audio.
        chosen_dictionaries:
          $ref: '#/components/schemas/ChosenDictionariesSchema'
        folder_id:
          type: integer
          title: Folder ID
          description: >-
            Specify the organizational folder within your CAMB.AI workspace
            where this task should be created and stored. The folder must
            already exist in your workspace and be accessible through your
            current API key authentication. This helps maintain project
            organization by grouping related tasks together, making it easier to
            manage and locate your projects.
          minimum: 1
          nullable: true
          example: <number>
      type: object
      required:
        - media_url
        - source_language
        - target_languages
      title: CreateProjectSetupRequestPayload
    TaskID:
      properties:
        task_id:
          type: string
          title: Task ID
      type: object
      title: Task ID
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    Languages:
      type: integer
      enum:
        - 1
        - 2
        - 3
        - 4
        - 5
        - 6
        - 7
        - 8
        - 9
        - 10
        - 11
        - 12
        - 13
        - 14
        - 15
        - 16
        - 17
        - 18
        - 19
        - 20
        - 21
        - 22
        - 23
        - 24
        - 25
        - 26
        - 27
        - 28
        - 29
        - 30
        - 31
        - 32
        - 33
        - 34
        - 35
        - 36
        - 37
        - 38
        - 39
        - 40
        - 41
        - 42
        - 43
        - 44
        - 45
        - 46
        - 47
        - 48
        - 49
        - 50
        - 51
        - 52
        - 53
        - 54
        - 55
        - 56
        - 57
        - 58
        - 59
        - 60
        - 61
        - 62
        - 63
        - 64
        - 65
        - 66
        - 67
        - 68
        - 69
        - 70
        - 71
        - 72
        - 73
        - 74
        - 75
        - 76
        - 77
        - 78
        - 79
        - 80
        - 81
        - 82
        - 83
        - 84
        - 85
        - 86
        - 87
        - 88
        - 89
        - 90
        - 91
        - 92
        - 93
        - 94
        - 95
        - 96
        - 97
        - 98
        - 99
        - 100
        - 101
        - 102
        - 103
        - 104
        - 105
        - 106
        - 107
        - 108
        - 109
        - 110
        - 111
        - 112
        - 113
        - 114
        - 115
        - 116
        - 117
        - 118
        - 119
        - 120
        - 121
        - 122
        - 123
        - 124
        - 125
        - 126
        - 127
        - 128
        - 129
        - 130
        - 131
        - 132
        - 133
        - 134
        - 135
        - 136
        - 139
        - 140
        - 141
        - 142
        - 143
        - 144
        - 145
        - 146
        - 147
        - 148
        - 149
        - 150
      title: Languages
      default: 1
    ChosenDictionariesSchema:
      type: array
      nullable: true
      items:
        type: integer
      uniqueItems: true
      minItems: 1
      default: null
      description: >-
        An optional list of dictionary IDs selected by the user. Each entry must
        be an integer corresponding to a valid dictionary ID. If provided, at
        least one ID is required.
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        The `x-api-key` is a custom header required for authenticating requests
        to our API. Include this header in your request with the appropriate API
        key value to securely access our endpoints. You can find your API key(s)
        in the 'API' section of our studio website.

````