Create an index

# pip install "pinecone[grpc]"
from pinecone.grpc import PineconeGRPC as Pinecone
from pinecone import ServerlessSpec

pc = Pinecone(api_key="YOUR_API_KEY")

pc.create_index(
  name="docs-example1",
  dimension=1536,
  metric="cosine",
  spec=ServerlessSpec(
    cloud="aws",
    region="us-east-1",
  ),
  deletion_protection="disabled"
)

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

const pc = new Pinecone({
  apiKey: 'YOUR_API_KEY'
});

await pc.createIndex({
  name: 'docs-example1',
  dimension: 1536,
  metric: 'cosine',
  spec: {
    serverless: {
      cloud: 'aws',
      region: 'us-east-1'
    }
  },
  deletionProtection: 'disabled',
});

import io.pinecone.clients.Pinecone;

public class CreateServerlessIndexExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        pc.createServerlessIndex("docs-example1", "cosine", 1536, "aws", "us-east-1", DeletionProtection.disabled);
    }
}

package main

import (
    "context"
    "fmt"
    "log"

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

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

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

    deletionProtection := pinecone.DeletionProtectionDisabled

    idx, err := pc.CreateServerlessIndex(ctx, &pinecone.CreateServerlessIndexRequest{
        Name:      "docs-example1",
        Dimension: 1536,
        Metric:    pinecone.Cosine,
        Cloud:     pinecone.Aws,
        Region:    "us-east-1",
        DeletionProtection: &deletionProtection,
    })
  	if err != nil {
        log.Fatalf("Failed to create serverless index: %v", err)
    } else {
        fmt.Printf("Successfully created serverless index: %v", idx.Name)
    }
}

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

var createIndexRequest = await pinecone.CreateIndexAsync(new CreateIndexRequest
{
    Name = "docs-example1",
    Dimension = 1536,
    Metric = MetricType.Cosine,
    Spec = new ServerlessIndexSpec
    {
        Serverless = new ServerlessSpec
        {
            Cloud = ServerlessSpecCloud.Aws,
            Region = "us-east-1",
        }
    },
    DeletionProtection = DeletionProtection.Disabled
});

PINECONE_API_KEY="YOUR_API_KEY"

# Serverless index
curl -X POST "https://api.pinecone.io/indexes" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     -H "Api-Key: $PINECONE_API_KEY" \
     -H "X-Pinecone-Api-Version: 2025-04" \
     -d '{
           "name": "docs-example1",
           "vector_type": "dense",
           "dimension": 1536,
           "metric": "cosine",
           "spec": {
               "serverless": {
                   "cloud": "aws",
                   "region": "us-east-1"
               }
           },
           "tags": {
               "example": "tag"
           },
           "deletion_protection": "disabled"
         }'

# BYOC index
curl -X POST"https://api.pinecone.io/indexes" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     -H "Api-Key: $PINECONE_API_KEY" \
     -H "X-Pinecone-Api-Version: 2025-04" \
     -d '{
           "name": "example-byoc-index",
           "vector_type": "dense",
           "dimension": 1536,
           "metric": "cosine",
           "spec": {
               "byoc": {
                   "environment": "aws-us-east-1-b921"
               }
           },
           "tags": {
               "example": "tag"
           },
           "deletion_protection": "disabled"
         }'

# Target the project where you'd like to create the index.
pc target -o "example-org" -p "example-project"
# Create the index.
pc index create \
  --name "docs-example1" \
  --dimension 1536 \
  --metric "cosine" \
  --cloud "aws" \
  --region "us-east-1" \
  --deletion_protection "disabled" \
  --tags "example=tag,example2=tag2"

# Serverless index
{
    "name": "docs-example1",
    "vector_type": "dense",
    "metric": "cosine",
    "dimension": 1536,
    "status": {
        "ready": true,
        "state": "Ready"
    },
    "host": "example-serverless-index-govk0nt.svc.aped-4627-b74a.pinecone.io",
    "spec": {
        "serverless": {
            "region": "us-east-1",
            "cloud": "aws"
        }
    },
    "deletion_protection": "disabled",
    "tags": {
        "example": "tag"
    }
}

# BYOC index
{
    "name": "example-byoc-index",
    "vector_type": "dense",
    "metric": "cosine",
    "dimension": 1536,
    "status": {
        "ready": true,
        "state": "Ready"
    },
    "host": "example-byoc-index-govk0nt.svc.private.aped-4627-b74a.pinecone.io",
    "spec": {
        "byoc": {
            "environment": "aws-us-east-1-b921"
        }
    },
    "deletion_protection": "disabled",
    "tags": {
        "example": "tag"
    }
}