Configure an index

# pip install --upgrade pinecone
import os
from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Enable deletion protection
pc.indexes.configure(
    name="articles",
    deletion_protection="enabled",
)

# Convert read capacity from OnDemand to Dedicated
pc.indexes.configure(
    name="articles",
    read_capacity={
        "mode": "Dedicated",
        "dedicated": {
            "node_type": "b1",
            "scaling": "Manual",
            "manual": {"shards": 1, "replicas": 1},
        },
    },
)

// npm install @pinecone-database/pinecone
import { Pinecone } from '@pinecone-database/pinecone';

// Reads PINECONE_API_KEY from the environment
const pc = new Pinecone();

// Enable deletion protection
await pc.indexes.configure('articles', {
  deletionProtection: 'enabled',
});

// Convert read capacity from OnDemand to Dedicated
await pc.indexes.configure('articles', {
  readCapacity: {
    mode: 'Dedicated',
    dedicated: {
      nodeType: 'b1',
      scaling: 'Manual',
      manual: { shards: 1, replicas: 1 },
    },
  },
});

package main

import (
    "context"
    "log"
    "os"

    "github.com/pinecone-io/go-pinecone/v7/pinecone"
)

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: os.Getenv("PINECONE_API_KEY"),
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

    // Enable deletion protection
    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        DeletionProtection: pinecone.DeletionProtectionEnabled,
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }

    // Convert read capacity from OnDemand to Dedicated
    nodeType := "b1"
    shards := int32(1)
    replicas := int32(1)

    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        ReadCapacity: &pinecone.ReadCapacityParams{
            Dedicated: &pinecone.ReadCapacityDedicatedConfig{
                NodeType: &nodeType,
                Scaling: &pinecone.ReadCapacityScaling{
                    Manual: &pinecone.ReadCapacityManualScaling{
                        Shards:   &shards,
                        Replicas: &replicas,
                    },
                },
            },
        },
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }
}

PINECONE_API_KEY="YOUR_API_KEY"

# Enable deletion protection
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{ "deletion_protection": "enabled" }'

# Convert read capacity from OnDemand to Dedicated
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{
    "read_capacity": {
      "mode": "Dedicated",
      "dedicated": {
        "node_type": "b1",
        "scaling": "Manual",
        "manual": { "shards": 1, "replicas": 1 }
      }
    }
  }'

{
  "deletion_protection": "disabled",
  "deployment": {
    "cloud": "aws",
    "deployment_type": "managed",
    "region": "us-east-1"
  },
  "host": "my-index-abc123.svc.pinecone.io",
  "name": "my-index",
  "read_capacity": {
    "mode": "OnDemand",
    "status": {
      "state": "Ready"
    }
  },
  "schema": {
    "fields": {
      "title": {
        "full_text_search": {
          "language": "en",
          "stemming": false,
          "stop_words": false
        },
        "store_text": true,
        "type": "string"
      },
      "your_vector": {
        "dimension": 1536,
        "metric": "cosine",
        "type": "dense_vector"
      }
    }
  },
  "status": {
    "ready": true,
    "state": "Ready"
  }
}

PATCH

indexes

{index_name}

# pip install --upgrade pinecone
import os
from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Enable deletion protection
pc.indexes.configure(
    name="articles",
    deletion_protection="enabled",
)

# Convert read capacity from OnDemand to Dedicated
pc.indexes.configure(
    name="articles",
    read_capacity={
        "mode": "Dedicated",
        "dedicated": {
            "node_type": "b1",
            "scaling": "Manual",
            "manual": {"shards": 1, "replicas": 1},
        },
    },
)

// npm install @pinecone-database/pinecone
import { Pinecone } from '@pinecone-database/pinecone';

// Reads PINECONE_API_KEY from the environment
const pc = new Pinecone();

// Enable deletion protection
await pc.indexes.configure('articles', {
  deletionProtection: 'enabled',
});

// Convert read capacity from OnDemand to Dedicated
await pc.indexes.configure('articles', {
  readCapacity: {
    mode: 'Dedicated',
    dedicated: {
      nodeType: 'b1',
      scaling: 'Manual',
      manual: { shards: 1, replicas: 1 },
    },
  },
});

package main

import (
    "context"
    "log"
    "os"

    "github.com/pinecone-io/go-pinecone/v7/pinecone"
)

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: os.Getenv("PINECONE_API_KEY"),
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

    // Enable deletion protection
    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        DeletionProtection: pinecone.DeletionProtectionEnabled,
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }

    // Convert read capacity from OnDemand to Dedicated
    nodeType := "b1"
    shards := int32(1)
    replicas := int32(1)

    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        ReadCapacity: &pinecone.ReadCapacityParams{
            Dedicated: &pinecone.ReadCapacityDedicatedConfig{
                NodeType: &nodeType,
                Scaling: &pinecone.ReadCapacityScaling{
                    Manual: &pinecone.ReadCapacityManualScaling{
                        Shards:   &shards,
                        Replicas: &replicas,
                    },
                },
            },
        },
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }
}

PINECONE_API_KEY="YOUR_API_KEY"

# Enable deletion protection
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{ "deletion_protection": "enabled" }'

# Convert read capacity from OnDemand to Dedicated
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{
    "read_capacity": {
      "mode": "Dedicated",
      "dedicated": {
        "node_type": "b1",
        "scaling": "Manual",
        "manual": { "shards": 1, "replicas": 1 }
      }
    }
  }'

{
  "deletion_protection": "disabled",
  "deployment": {
    "cloud": "aws",
    "deployment_type": "managed",
    "region": "us-east-1"
  },
  "host": "my-index-abc123.svc.pinecone.io",
  "name": "my-index",
  "read_capacity": {
    "mode": "OnDemand",
    "status": {
      "state": "Ready"
    }
  },
  "schema": {
    "fields": {
      "title": {
        "full_text_search": {
          "language": "en",
          "stemming": false,
          "stop_words": false
        },
        "store_text": true,
        "type": "string"
      },
      "your_vector": {
        "dimension": 1536,
        "metric": "cosine",
        "type": "dense_vector"
      }
    }
  },
  "status": {
    "ready": true,
    "state": "Ready"
  }
}

Updates configuration on an existing index. You can update deletion_protection, tags, and read_capacity (for example, converting from OnDemand to Dedicated). The schema itself is immutable — to change field types or add new indexed fields, create a new index and re-upsert. This is a partial update: only the fields you include in the request body are modified. Unspecified fields are left unchanged. To clear tags, send "tags": {}.

# pip install --upgrade pinecone
import os
from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Enable deletion protection
pc.indexes.configure(
    name="articles",
    deletion_protection="enabled",
)

# Convert read capacity from OnDemand to Dedicated
pc.indexes.configure(
    name="articles",
    read_capacity={
        "mode": "Dedicated",
        "dedicated": {
            "node_type": "b1",
            "scaling": "Manual",
            "manual": {"shards": 1, "replicas": 1},
        },
    },
)

// npm install @pinecone-database/pinecone
import { Pinecone } from '@pinecone-database/pinecone';

// Reads PINECONE_API_KEY from the environment
const pc = new Pinecone();

// Enable deletion protection
await pc.indexes.configure('articles', {
  deletionProtection: 'enabled',
});

// Convert read capacity from OnDemand to Dedicated
await pc.indexes.configure('articles', {
  readCapacity: {
    mode: 'Dedicated',
    dedicated: {
      nodeType: 'b1',
      scaling: 'Manual',
      manual: { shards: 1, replicas: 1 },
    },
  },
});

package main

import (
    "context"
    "log"
    "os"

    "github.com/pinecone-io/go-pinecone/v7/pinecone"
)

func main() {
    ctx := context.Background()

    pc, err := pinecone.NewClient(pinecone.NewClientParams{
        ApiKey: os.Getenv("PINECONE_API_KEY"),
    })
    if err != nil {
        log.Fatalf("Failed to create Client: %v", err)
    }

    // Enable deletion protection
    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        DeletionProtection: pinecone.DeletionProtectionEnabled,
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }

    // Convert read capacity from OnDemand to Dedicated
    nodeType := "b1"
    shards := int32(1)
    replicas := int32(1)

    _, err = pc.ConfigureIndex(ctx, "articles", pinecone.ConfigureIndexParams{
        ReadCapacity: &pinecone.ReadCapacityParams{
            Dedicated: &pinecone.ReadCapacityDedicatedConfig{
                NodeType: &nodeType,
                Scaling: &pinecone.ReadCapacityScaling{
                    Manual: &pinecone.ReadCapacityManualScaling{
                        Shards:   &shards,
                        Replicas: &replicas,
                    },
                },
            },
        },
    })
    if err != nil {
        log.Fatalf("Failed to configure index: %v", err)
    }
}

PINECONE_API_KEY="YOUR_API_KEY"

# Enable deletion protection
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{ "deletion_protection": "enabled" }'

# Convert read capacity from OnDemand to Dedicated
curl -X PATCH "https://api.pinecone.io/indexes/articles" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Pinecone-Api-Version: 2026-07" \
  -d '{
    "read_capacity": {
      "mode": "Dedicated",
      "dedicated": {
        "node_type": "b1",
        "scaling": "Manual",
        "manual": { "shards": 1, "replicas": 1 }
      }
    }
  }'

Authorizations

Api-Key

string

header

required

An API Key is required to call Pinecone APIs. Get yours from the console.

Headers

X-Pinecone-Api-Version

string

default:2026-07

required

Required date-based version header

Path Parameters

index_name

string

required

The name of the index to configure.

Body

application/json

Configuration updates to apply to an existing index. All fields are optional; only the fields you include are modified.

deployment: Update pod-based scaling parameters (replicas, pod_type). Deployment type and cloud/region cannot be changed.
schema: Update semantic_text field embedding parameters, on a legacy integrated index created via create-for-model. Only write_parameters and read_parameters may be changed; the model cannot be changed after creation.
read_capacity: Update read capacity mode or dedicated node configuration for managed and BYOC indexes. Not applicable to pod-based indexes.
tags: Update or delete index tags. Setting a tag value to "" removes the tag.
deletion_protection: Enable or disable deletion protection.

deployment

Pod-based · object

Deployment update parameters for pod-based indexes. Specify replicas, pod_type, or both. Deployment type, cloud/region, and environment cannot be changed after creation. Do not include a deployment_type field; it is not accepted.

Show child attributes

Example:

{ "replicas": 4 }

schema

object

Schema updates to apply to an existing index. Only semantic_text field parameters, on a legacy integrated index created via create-for-model, can be updated after index creation. The model itself cannot be changed once set; only write_parameters and read_parameters may be updated if the model stays the same. The embed and sparse_embed configurations of a string field are fixed at creation and cannot be updated.

Show child attributes

Example:

{
  "fields": {
    "content": {
      "read_parameters": { "input_type": "query", "truncate": "NONE" },
      "type": "semantic_text",
      "write_parameters": { "input_type": "passage" }
    }
  }
}

read_capacity

On-demand · object

Read capacity changes for an existing managed or BYOC index. Switch to OnDemand, or set Dedicated and change any subset of node_type, scaling, and manual replicas/shards; fields you omit keep their current value. BYOC indexes do not support OnDemand.

On-demand
Dedicated

Show child attributes

Example:

{ "mode": "OnDemand" }

Response

The configuration change was recorded and the updated index is returned. Changes that resize the index (replicas, shards, read capacity) are applied asynchronously; poll the index status to see when they take effect.

The IndexModel describes the configuration and status of a Pinecone index.

name

string

required

The name of the index. Resource name must be 1-45 characters long, start and end with an alphanumeric character, and consist only of lower case alphanumeric characters or '-'.

Required string length: 1 - 45

Example:

"example-index"

host

string

required

The URL address where the index is hosted.

Example:

"semantic-search-c01b5b5.svc.us-west1-gcp.pinecone.io"

status

object

required

The current status of the index.

Show child attributes

Example:

{ "ready": true, "state": "Ready" }

deployment

Pod-based · object

required

The deployment configuration of a Pinecone index. The deployment_type field indicates which infrastructure model the index uses.

pod: Dedicated pod-based infrastructure. Suitable for workloads that require predictable performance.
managed: Serverless infrastructure managed by Pinecone, including full-text search indexes. Scales automatically; billed per usage.
byoc: Bring-your-own-compute. Runs in customer-managed infrastructure.

Pod-based
Serverless
BYOC

Show child attributes

Example:

{
  "deployment_type": "pod",
  "environment": "us-east1-gcp",
  "pod_type": "p1.x1",
  "replicas": 1,
  "shards": 1
}

schema

object

required

The schema of a Pinecone index. The schema defines the typed fields that documents in the index can contain, including vector fields, string fields searched by full-text search or by embeddings, and metadata fields.

Show child attributes

Example:

{
  "fields": {
    "body": {
      "embed": {
        "dimension": 1024,
        "metric": "cosine",
        "model": "llama-text-embed-v2"
      },
      "full_text_search": {
        "language": "en",
        "stemming": false,
        "stop_words": false
      },
      "sparse_embed": { "model": "pinecone-sparse-english-v0" },
      "store_text": true,
      "type": "string"
    },
    "title": {
      "full_text_search": {
        "language": "en",
        "stemming": false,
        "stop_words": false
      },
      "store_text": true,
      "type": "string"
    }
  }
}

deletion_protection

string

default:disabled

required

Whether deletion protection is enabled/disabled for the index.

Possible values: disabled or enabled.

private_host

string

The private endpoint URL of an index.

Example:

"semantic-search-c01b5b5.svc.private.us-west1-gcp.pinecone.io"

read_capacity

On-demand · object

Response containing read capacity configuration

On-demand
Dedicated

Show child attributes

Example:

{
  "mode": "OnDemand",
  "status": { "state": "Ready" }
}

source_collection

string

The name of the collection this index was created from, if any.

Example:

"movie-embeddings"

source_backup_id

string

The ID of the backup this index was restored from, if any.

Example:

"670e8400-e29b-41d4-a716-446655440000"

cmek_id

string

The ID of the customer-managed encryption key (CMEK) used to encrypt this index, if any.

Example:

"arn:aws:kms:us-east-1:123456789012:key/mrk-abc123"

APIs

Database

Inference

Admin

SDKs

CLI

Tools

Authorizations

Headers

Path Parameters

Body

Response