> ## 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.

# Create Folder

> Establish organizational containers within your CAMB.AI workspace to structure audiobook projects effectively. This endpoint creates the foundational filing system that enables efficient project management and team collaboration across your growing content library.

## Overview

Folders serve as the organizational backbone of your CAMB.AI workspace, functioning as digital filing cabinets that contain and categorize your audiobook projects. These containers become increasingly valuable as your content library expands, providing the structural foundation that transforms chaotic project lists into navigable, logical hierarchies that support both individual productivity and collaborative workflows.

The Create Folder endpoint addresses a fundamental workspace management need by establishing these organizational containers before project creation, enabling you to implement consistent categorization strategies that scale effectively as your audiobook production grows from individual projects to comprehensive content libraries.

## When to Create Folders

Strategic folder creation occurs at multiple points in your workflow evolution. During initial workspace setup, you'll establish foundational organizational structures that reflect your content strategy and production approach. As your library grows, you'll create specialized folders that accommodate new content categories, collaboration partnerships, or workflow refinements that emerge from operational experience.

The endpoint proves particularly valuable when implementing systematic project organization strategies. Rather than creating projects first and organizing them later, proactive folder creation enables immediate categorization that maintains structural clarity throughout your production pipeline.

## Implementation and Response Structure

Creating folders requires minimal configuration while providing comprehensive feedback for workflow integration. The endpoint accepts a simple folder name and returns complete organizational information including the unique folder identifier needed for subsequent project assignments.

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

headers = {
    "x-api-key": "your-api-key",
    "Content-Type": "application/json"
}

def create_project_folder(folder_name):
    """Establishes a new organizational container for audiobook projects"""

    try:
        response = requests.post(
            "https://client.camb.ai/apis/folders/create",
            headers=headers,
            json={"folder_name": folder_name}
        )

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

        print(f"Created folder '{result.get('folder_name')}' with ID: {result.get('folder_id')}")
        return result

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

# Strategic folder creation for audiobook organization
organizational_folders = [
    "Fiction - Mystery Series",
    "Educational Content - Science",
    "Corporate Training - Q2 2024"
]

for folder_name in organizational_folders:
    create_project_folder(folder_name)
```

## Strategic Integration with Project Workflows

The Create Folder endpoint integrates seamlessly with broader project management strategies by establishing organizational foundations before project creation. This proactive approach ensures that audiobook projects inherit appropriate categorization from inception, eliminating the need for retrospective organization that often leads to inconsistent project structures.

Effective folder creation considers both immediate organizational needs and long-term scalability requirements. Folders created with strategic naming conventions and clear categorization logic provide lasting value that compounds as your workspace grows, supporting efficient project discovery and collaborative access patterns that enhance rather than complicate your creative workflows.

Understanding folder creation as a foundational workspace management activity enables more sophisticated organizational strategies that support complex audiobook production pipelines while maintaining the simplicity needed for efficient daily operations.


## OpenAPI

````yaml post /folders/create
openapi: 3.1.0
info:
  title: FastAPI
  version: 0.1.0
servers:
  - url: https://client.camb.ai/apis
security: []
paths:
  /folders/create:
    post:
      tags:
        - APIs
        - Folders
      summary: Create Folder
      operationId: create_folder_folders_create_post
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateFolderPayload'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateFolderResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - APIKeyHeader: []
components:
  schemas:
    CreateFolderPayload:
      properties:
        folder_name:
          type: string
          maxLength: 255
          minLength: 3
          title: Folder Name
          description: >-
            Display name for the folder as it appears in your CAMB.AI workspace
            dashboard. Choose meaningful names that reflect the folder's purpose
            or project category, such as 'Marketing Audio Projects' or 'Podcast
            Transcriptions', to help you and your team quickly identify and
            navigate to the right organizational container for your tasks.
      type: object
      required:
        - folder_name
      title: CreateFolderPayload
    CreateFolderResponse:
      type: object
      properties:
        status:
          type: string
          description: >-
            Indicates the outcome of the folder creation operation. Returns
            'success' when the folder is created successfully, enabling your
            application to implement appropriate success handling, user
            notifications, and workflow continuation logic.
        folder_id:
          type: integer
          minimum: 1
          description: >-
            The unique identifier assigned to your newly created folder. This ID
            serves as the primary reference for all subsequent folder
            operations, including adding projects to the folder, retrieving
            folder contents, or managing folder permissions. Store this value
            for future API calls that require folder specification.
          example: <number>
        folder_name:
          type: string
          description: >-
            The exact name assigned to your folder as stored in the system. This
            field confirms the final folder name after any processing,
            validation, or normalization that may have occurred during creation,
            ensuring your application displays the precise name that appears in
            CAMB.AI Studio and other system interfaces.
        message:
          type: string
          description: >-
            Human-readable feedback about the folder creation operation. This
            field provides descriptive information suitable for displaying to
            users in success notifications, logging for debugging purposes, or
            integration with monitoring systems that track workspace
            organization activities.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    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.

````