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

# Create a backup of an index

> Create a backup of an index.
The backup records the schema of the index it is taken from and reports it as `schema`. An index created from the backup with [Create index from backup](https://docs.pinecone.io/reference/api/2026-07/control-plane/create_index_from_backup) inherits that schema.


<RequestExample>
  ```bash curl theme={null}
  PINECONE_API_KEY="YOUR_API_KEY"
  INDEX_NAME="docs-example"

  curl "https://api.pinecone.io/indexes/$INDEX_NAME/backups" \
      -H "Api-Key: $PINECONE_API_KEY" \
      -H 'accept: application/json' \
      -H 'Content-Type: application/json' \
      -H "X-Pinecone-Api-Version: 2026-07" \
      -d '{
        "name": "example-backup", 
        "description": "Monthly backup of production index"
        }'
  ```
</RequestExample>


## OpenAPI

````yaml https://raw.githubusercontent.com/pinecone-io/pinecone-api/refs/heads/main/2026-07/db_control_2026-07.oas.yaml post /indexes/{index_name}/backups
openapi: 3.0.3
info:
  title: Pinecone Control Plane API
  description: >-
    Pinecone is a vector database that makes it easy to search and retrieve
    billions of high-dimensional vectors.
  contact:
    name: Pinecone Support
    url: https://support.pinecone.io
    email: support@pinecone.io
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0
  version: 2026-07
servers:
  - url: https://api.pinecone.io
    description: Production API endpoints
security:
  - ApiKeyAuth: []
tags:
  - name: Manage Indexes
    description: Actions that manage indexes
externalDocs:
  description: More Pinecone.io API docs
  url: https://docs.pinecone.io/introduction
paths:
  /indexes/{index_name}/backups:
    post:
      tags:
        - Manage Indexes
      summary: Create a backup of an index
      description: >
        Create a backup of an index.

        The backup records the schema of the index it is taken from and reports
        it as `schema`. An index created from the backup with [Create index from
        backup](https://docs.pinecone.io/reference/api/2026-07/control-plane/create_index_from_backup)
        inherits that schema.
      operationId: create_backup
      parameters:
        - in: header
          name: X-Pinecone-Api-Version
          description: Required date-based version header
          required: true
          schema:
            default: 2026-07
            type: string
          style: simple
        - in: path
          name: index_name
          description: Name of the index to backup
          required: true
          schema:
            type: string
          style: simple
      requestBody:
        description: The desired configuration for the backup.
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateBackupRequest'
            examples:
              backup-index-no-name:
                summary: Creating a backup of an index with no name
                value: {}
              backup-index-with-name:
                summary: Creating a backup of an index with a name
                value:
                  name: backup-index
              backup-index-with-name-and-description:
                summary: Creating a backup of an index with a name and description
                value:
                  description: Backup of the index
                  name: backup-index
        required: true
      responses:
        '200':
          description: >-
            The backup was created. The returned backup starts in status
            `Initializing`; poll it until the status is `Ready`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BackupModel'
        '400':
          description: Bad request. The request body included invalid request parameters.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                index-metric-validation-error:
                  summary: Validation error
                  value:
                    error:
                      code: INVALID_ARGUMENT
                      message: >-
                        Bad request. The request body included invalid request
                        parameters.
                    status: 400
        '401':
          description: 'Unauthorized. Possible causes: missing or invalid API key.'
          content:
            text/plain:
              schema:
                $ref: '#/components/schemas/UnauthorizedMessage'
        '403':
          description: >-
            Forbidden. Possible causes: the organization's plan does not include
            backups, or the project's backup quota is exhausted.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                quota-exceeded:
                  summary: Backup quota exhausted
                  value:
                    error:
                      code: FORBIDDEN
                      message: Increase your quota or upgrade to create more backups.
                    status: 403
                plan-does-not-include-backups:
                  summary: Plan does not include backups
                  value:
                    error:
                      code: PERMISSION_DENIED
                      message: >-
                        Your organization's plan does not include backups.
                        Upgrade your plan to create backups.
                    status: 403
        '422':
          description: Unprocessable entity. The request body could not be deserialized.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                missing-field:
                  summary: Unprocessable entity
                  value:
                    error:
                      code: UNPROCESSABLE_ENTITY
                      message: >-
                        Failed to deserialize the JSON body into the target
                        type: missing field `metric` at line 1 column 16
                    status: 422
        '500':
          description: Internal server error.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                internal-server-error:
                  summary: Internal server error
                  value:
                    error:
                      code: UNKNOWN
                      message: Internal server error
                    status: 500
components:
  schemas:
    CreateBackupRequest:
      description: The configuration needed to create a backup of an index.
      type: object
      properties:
        name:
          example: backup-2025-03-15
          description: >-
            The name of the backup. Must be 1-45 characters long, start and end
            with an alphanumeric character, and consist only of lower case
            alphanumeric characters or `-`; any other value is rejected with
            `400`.
          type: string
          minLength: 1
          maxLength: 45
        description:
          description: A description of the backup.
          type: string
    BackupModel:
      description: >-
        The BackupModel describes the configuration and status of a Pinecone
        backup.
      type: object
      properties:
        backup_id:
          example: 670e8400-e29b-41d4-a716-446655440001
          description: Unique identifier for the backup.
          type: string
        source_index_name:
          example: my-index
          description: Name of the index from which the backup was taken.
          type: string
        source_index_id:
          example: 670e8400-e29b-41d4-a716-446655440000
          description: ID of the index from which the backup was taken.
          type: string
        source_index_deleted_at:
          example: '2024-03-05T12:00:00.000Z'
          description: >-
            The deletion timestamp when the source index has been deleted. Not
            present for backups associated with an active index.
          type: string
          format: date-time
        name:
          example: backup-2025-02-04
          description: Optional user-defined name for the backup.
          type: string
        description:
          example: Backup before bulk update.
          description: Optional description providing context for the backup.
          type: string
        status:
          example: Ready
          description: Current status of the backup.
          x-enum:
            - Initializing
            - Ready
            - InitializationFailed
          type: string
        cloud:
          example: aws
          description: Cloud provider where the backup is stored.
          type: string
        region:
          example: us-east-1
          description: Cloud region where the backup is stored.
          type: string
        schema:
          $ref: '#/components/schemas/IndexSchema'
        record_count:
          example: 120000
          description: Total number of records in the backup.
          type: integer
          format: int64
        namespace_count:
          example: 3
          description: Number of namespaces in the backup.
          type: integer
          format: int64
        size_bytes:
          example: 10000000
          description: Size of the backup in bytes.
          type: integer
          format: int64
        tags:
          $ref: '#/components/schemas/IndexTags'
        created_at:
          example: '2025-02-04T10:30:00.000Z'
          description: Timestamp when the backup was created.
          type: string
          format: date-time
      required:
        - backup_id
        - source_index_name
        - source_index_id
        - status
        - cloud
        - region
    ErrorResponse:
      example:
        error:
          code: INVALID_ARGUMENT
          message: >-
            Index name must contain only lowercase alphanumeric characters or
            hyphens, and must not begin or end with a hyphen.
        status: 400
      description: The response shape used for all error responses.
      type: object
      properties:
        status:
          example: 500
          description: The HTTP status code of the error.
          type: integer
        error:
          example:
            code: INVALID_ARGUMENT
            message: >-
              Index name must contain only lowercase alphanumeric characters or
              hyphens, and must not begin or end with a hyphen.
          description: Detailed information about the error that occurred.
          type: object
          properties:
            code:
              description: >-
                The error code.

                Possible values: `OK`, `UNKNOWN`, `INVALID_ARGUMENT`,
                `DEADLINE_EXCEEDED`, `NOT_FOUND`, `ALREADY_EXISTS`,
                `PERMISSION_DENIED`, `UNAUTHENTICATED`, `RESOURCE_EXHAUSTED`,
                `FAILED_PRECONDITION`, `ABORTED`, `OUT_OF_RANGE`, `INTERNAL`,
                `FORBIDDEN`, `PAYMENT_REQUIRED`, `SERVICE_UNAVAILABLE`,
                `PAYLOAD_TOO_LARGE`, or `UNPROCESSABLE_ENTITY`.
              x-enum:
                - OK
                - UNKNOWN
                - INVALID_ARGUMENT
                - DEADLINE_EXCEEDED
                - NOT_FOUND
                - ALREADY_EXISTS
                - PERMISSION_DENIED
                - UNAUTHENTICATED
                - RESOURCE_EXHAUSTED
                - FAILED_PRECONDITION
                - ABORTED
                - OUT_OF_RANGE
                - INTERNAL
                - FORBIDDEN
                - PAYMENT_REQUIRED
                - SERVICE_UNAVAILABLE
                - PAYLOAD_TOO_LARGE
                - UNPROCESSABLE_ENTITY
              type: string
            message:
              example: >-
                Index name must contain only lowercase alphanumeric characters
                or hyphens, and must not begin or end with a hyphen.
              description: A human-readable description of the error
              type: string
            details:
              description: >-
                Additional information about the error. This field is not
                guaranteed to be present.
              type: object
          required:
            - code
            - message
      required:
        - status
        - error
    UnauthorizedMessage:
      example: Invalid API key
      description: >-
        The plain-text body of a `401` response. Authentication failures are
        rejected before the request reaches the API, so they carry a short
        message rather than an `ErrorResponse`.
      type: string
    IndexSchema:
      example:
        fields:
          embedding:
            dimension: 1536
            metric: cosine
            type: dense_vector
          title:
            full_text_search:
              language: en
              stemming: false
              stop_words: false
            type: string
      description: >-
        The schema of a Pinecone index. The schema defines the typed fields that
        documents in the index can contain, including vector fields, semantic
        text fields, and metadata fields.
      type: object
      properties:
        fields:
          description: >-
            A map of field names to their configurations.

            Indexes that are served by the vectors API — created with the
            reserved `_values` / `_sparse_values` schema, or created by an
            earlier API version from `dimension`, `metric`, and `vector_type` —
            report their vector fields under the reserved names `_values`
            (dense) and `_sparse_values` (sparse), and any metadata fields
            configured for filtering as legacy fields carrying only
            `filterable`. Dense vectors-API indexes always report both `_values`
            and `_sparse_values`, regardless of how they were created.
          type: object
          additionalProperties:
            $ref: '#/components/schemas/IndexSchemaField'
      required:
        - fields
    IndexTags:
      nullable: true
      example:
        tag0: val0
        tag1: val1
      description: >-
        Custom user tags added to an index, at most 20 per index. Keys must be
        80 characters or less and alphanumeric, '_', or '-'. Values must be 120
        characters or less and consist of printable ASCII characters or spaces.
        To unset a key, set the value to be an empty string. `null` in responses
        when the index has no tags.
      type: object
      additionalProperties:
        type: string
    IndexSchemaField:
      description: >-
        The configuration of a single field in the index schema.

        Most fields carry a `type` property that identifies the field type:

        - `dense_vector`: Fixed-dimension floating-point vectors for ANN search.
        - `sparse_vector`: Sparse vectors for keyword or hybrid search. -
        `semantic_text`: Text field backed by an integrated embedding model. -
        `string`: String field for full-text search or metadata filtering. -
        `string_list`: String array field. - `float`: Numeric field. -
        `integer`: Legacy numeric field from older indexes (pre-dating float

          normalization). Will not appear in new indexes.
        - `boolean`: Boolean field.

        Fields in older indexes may omit `type` entirely. These are legacy
        metadata fields from before typed schemas were introduced.
      anyOf:
        - $ref: '#/components/schemas/TypedIndexSchemaField'
        - $ref: '#/components/schemas/LegacyMetadataField'
    TypedIndexSchemaField:
      title: Typed field
      description: >-
        A schema field that carries a `type` discriminator. This covers all
        field types in current use. See `IndexSchemaField` for the full union
        that also includes legacy untyped fields.
      discriminator:
        propertyName: type
        mapping:
          dense_vector:
            $ref: '#/components/schemas/DenseVectorField'
          sparse_vector:
            $ref: '#/components/schemas/SparseVectorField'
          semantic_text:
            $ref: '#/components/schemas/SemanticTextField'
          string:
            $ref: '#/components/schemas/ResponseStringField'
          string_list:
            $ref: '#/components/schemas/StringListField'
          float:
            $ref: '#/components/schemas/FloatField'
          integer:
            $ref: '#/components/schemas/IntegerField'
          boolean:
            $ref: '#/components/schemas/BooleanField'
      oneOf:
        - $ref: '#/components/schemas/DenseVectorField'
        - $ref: '#/components/schemas/SparseVectorField'
        - $ref: '#/components/schemas/SemanticTextField'
        - $ref: '#/components/schemas/ResponseStringField'
        - $ref: '#/components/schemas/StringListField'
        - $ref: '#/components/schemas/FloatField'
        - $ref: '#/components/schemas/IntegerField'
        - $ref: '#/components/schemas/BooleanField'
    LegacyMetadataField:
      example:
        filterable: true
      title: Legacy metadata
      description: >-
        A legacy metadata field from indexes created before typed schema fields
        were introduced. The original data type of the field (string, float,
        boolean, etc.) was not recorded. Only the `filterable` flag is
        available. This field type will not appear in new indexes; it may appear
        in responses for older indexes pending schema migration.
      type: object
      properties:
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - filterable
      additionalProperties: false
    DenseVectorField:
      example:
        dimension: 1536
        metric: cosine
        type: dense_vector
      title: Dense vector
      description: >-
        A dense vector field configuration. Stores fixed-dimension
        floating-point vectors for approximate nearest-neighbor (ANN) search.
      type: object
      properties:
        type:
          description: Identifies this as a dense vector field. Must be `dense_vector`.
          type: string
          enum:
            - dense_vector
        description:
          nullable: true
          description: >-
            Optional description for this field, at most 256 bytes. `null` in
            responses when none was set.
          type: string
          maxLength: 256
        dimension:
          example: 1536
          description: The number of dimensions in the dense vectors stored in this field.
          type: integer
          format: int32
          minimum: 1
          maximum: 20000
        metric:
          example: cosine
          description: |-
            The distance metric used for similarity search.
            Possible values: `cosine`, `dotproduct`, or `euclidean`.
          x-enum:
            - cosine
            - dotproduct
            - euclidean
          type: string
      required:
        - type
        - dimension
        - metric
    SparseVectorField:
      example:
        type: sparse_vector
      title: Sparse vector
      description: >-
        A sparse vector field configuration. Stores sparse vectors for keyword
        or hybrid search.
      type: object
      properties:
        type:
          description: Identifies this as a sparse vector field. Must be `sparse_vector`.
          type: string
          enum:
            - sparse_vector
        description:
          nullable: true
          description: >-
            Optional description for this field, at most 256 bytes. `null` in
            responses when none was set.
          type: string
          maxLength: 256
      required:
        - type
    SemanticTextField:
      example:
        model: multilingual-e5-large
        type: semantic_text
      title: Semantic text
      description: >-
        A semantic text field, as returned when describing an index created with
        an integrated embedding model. Backed by an integrated embedding model
        that embeds text at write and query time, enabling semantic similarity
        search without separate embedding calls. Cannot be declared when
        creating an index; use the create-for-model operation.
      type: object
      properties:
        type:
          description: Identifies this as a semantic text field. Must be `semantic_text`.
          type: string
          enum:
            - semantic_text
        description:
          nullable: true
          description: >-
            Optional description for this field, at most 256 bytes. `null` in
            responses when none was set.
          type: string
          maxLength: 256
        model:
          example: multilingual-e5-large
          description: The name of the integrated embedding model to use for this field.
          type: string
        dimension:
          nullable: true
          example: 1024
          description: >-
            The dimension of the vectors the model produces. `null` for models
            that produce sparse vectors.
          type: integer
          format: int32
        metric:
          example: cosine
          description: >-
            The distance metric used for similarity search. Defaults to the
            model's preferred metric if not specified.

            Possible values: `cosine`, `dotproduct`, or `euclidean`.
          x-enum:
            - cosine
            - dotproduct
            - euclidean
          type: string
        write_parameters:
          nullable: true
          example:
            input_type: passage
          description: >-
            Model-specific parameters applied at write time, such as
            `input_type`.
          type: object
        read_parameters:
          nullable: true
          example:
            input_type: query
          description: >-
            Model-specific parameters applied at query time, such as
            `input_type`.
          type: object
      required:
        - type
        - model
    ResponseStringField:
      example:
        full_text_search:
          language: en
          stemming: false
          stop_words: false
        type: string
      title: String
      description: >-
        A string field as returned in index schema responses. String fields
        configured for full-text search include a `full_text_search` object;
        string fields used for metadata filtering only include a `filterable`
        flag.
      type: object
      properties:
        type:
          description: Identifies this as a string field. Must be `string`.
          type: string
          enum:
            - string
        description:
          nullable: true
          description: Optional description for this field. `null` when none was set.
          type: string
        full_text_search:
          description: >-
            Full-text search configuration. Present when the field is indexed
            for full-text search.
          type: object
          properties:
            language:
              example: en
              description: The language used for text analysis. Defaults to `en`.
              default: en
              type: string
            stemming:
              description: Whether stemming is applied during text analysis.
              type: boolean
            stop_words:
              description: >-
                Whether stop words are filtered during text analysis. Only
                `true` if `stemming: true`.
              type: boolean
            ngram:
              description: >-
                Character n-gram tokenization configuration. Present only when
                the field is configured for n-gram substring matching.
              type: object
              properties:
                min_gram:
                  example: 2
                  description: Minimum n-gram length.
                  type: integer
                max_gram:
                  example: 3
                  description: Maximum n-gram length.
                  type: integer
                prefix_only:
                  description: >-
                    Whether only prefix n-grams anchored at the start of the
                    token are generated.
                  type: boolean
              required:
                - min_gram
                - max_gram
                - prefix_only
              additionalProperties: false
          required:
            - language
            - stemming
            - stop_words
          additionalProperties: false
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - type
    StringListField:
      example:
        filterable: true
        type: string_list
      title: String array
      description: >-
        A string array field configuration. String array values are not declared
        in the index schema; include them as document metadata instead — they
        are indexed automatically at upsert time.
      type: object
      properties:
        type:
          description: Identifies this as a string array field. Must be `string_list`.
          type: string
          enum:
            - string_list
        description:
          nullable: true
          description: Optional description for this field. `null` when none was set.
          type: string
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - type
    FloatField:
      example:
        type: float
      title: Float
      description: >-
        A numeric (floating-point) field configuration. Numeric values are not
        declared in the index schema; include them as document metadata instead
        — they are indexed automatically at upsert time.
      type: object
      properties:
        type:
          description: Identifies this as a float field. Must be `float`.
          type: string
          enum:
            - float
        description:
          nullable: true
          description: Optional description for this field. `null` when none was set.
          type: string
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - type
    IntegerField:
      example:
        filterable: true
        type: integer
      title: Integer
      description: >-
        A legacy integer field configuration. Integer fields were used in older
        index schemas before numeric values were normalized to `float` at upsert
        time. New indexes will not produce this field type; it may appear in
        responses for indexes created before that normalization was introduced.
      type: object
      properties:
        type:
          description: Identifies this as an integer field. Must be `integer`.
          type: string
          enum:
            - integer
        description:
          nullable: true
          description: Optional description for this field. `null` when none was set.
          type: string
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - type
    BooleanField:
      example:
        type: boolean
      title: Boolean
      description: >-
        A boolean field configuration. Boolean values are not declared in the
        index schema; include them as document metadata instead — they are
        indexed automatically at upsert time.
      type: object
      properties:
        type:
          description: Identifies this as a boolean field. Must be `boolean`.
          type: string
          enum:
            - boolean
        description:
          nullable: true
          description: Optional description for this field. `null` when none was set.
          type: string
        filterable:
          description: Whether this field is indexed for metadata filtering.
          type: boolean
      required:
        - type
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: Api-Key
      description: >-
        An API Key is required to call Pinecone APIs. Get yours from the
        [console](https://app.pinecone.io/).

````