For guidance and examples, see [Create an index](/guides/index-data-create-an-index).

```python Python theme={null}
# 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"
)
```

```javascript JavaScript theme={null}
// 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',
});
```

```java Java theme={null}
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);
    }
}
```

```go Go theme={null}
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)
    }
}
```

```csharp C# theme={null}
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
});
```

```shell curl theme={null}
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"
         }'
```

```bash CLI theme={null}
# 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"
```

```shell Response theme={null}
# 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"
    }
}
```

`POST /indexes`

:::code-group
```bash title="cURL"
curl --request POST \
  --url https://api.pinecone.io/indexes \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "example-index",
  "dimension": 1536,
  "metric": "cosine",
  "deletion_protection": "disabled",
  "tags": {
    "tag0": "val0",
    "tag1": "val1"
  },
  "spec": {},
  "vector_type": "<string>"
}'
```

```json title="201"
{
  "name": "example-index",
  "dimension": 1536,
  "metric": "cosine",
  "host": "semantic-search-c01b5b5.svc.us-west1-gcp.pinecone.io",
  "private_host": "semantic-search-c01b5b5.svc.private.us-west1-gcp.pinecone.io",
  "deletion_protection": "disabled",
  "tags": {
    "tag0": "val0",
    "tag1": "val1"
  },
  "embed": {
    "field_map": {
      "text": "your-text-field"
    },
    "metric": "cosine",
    "model": "multilingual-e5-large",
    "read_parameters": {
      "input_type": "query",
      "truncate": "NONE"
    },
    "write_parameters": {
      "input_type": "passage"
    }
  },
  "spec": {
    "pod": {
      "environment": "us-east-1-aws",
      "metadata_config": {
        "indexed": [
          "genre",
          "title",
          "imdb_rating"
        ]
      },
      "pod_type": "p1.x1",
      "pods": 1,
      "replicas": 1,
      "shards": 1
    }
  },
  "status": {
    "ready": true,
    "state": "ScalingUpPodSize"
  },
  "vector_type": "<string>"
}
```
:::

## Authorizations

- `Authorization` (header, string, required) — Bearer authentication header of the form `Bearer <token>`.

## Body

- `name` (body, 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 '-'.
- `dimension` (body, integer) — The dimensions of the vectors to be inserted in the index.
- `metric` (body, string) — The distance metric to be used for similarity search. You can use 'euclidean', 'cosine', or 'dotproduct'. If the 'vector\_type' is 'sparse', the metric must be 'dotproduct'. If the `vector_type` is `dense`, the metric defaults to 'cosine'.
- `deletion_protection` (body, string) — Whether [deletion protection](/guides/manage-data-manage-indexes#configure-deletion-protection) is enabled/disabled for the index.
- `tags` (body, object) — Custom user tags added to an index. Keys must be 80 characters or less. Values must be 120 characters or less. Keys must be alphanumeric, '_', or '-'. Values must be alphanumeric, ';', '@', '_', '-', '.', '+', or ' '. To unset a key, set the value to be an empty string.
- `spec` (body, object, required) — The spec object defines how the index should be deployed. For serverless indexes, you set only the [cloud and region](/guides/index-data-create-an-index#cloud-regions) where the index should be hosted. For pod-based indexes, you set the [environment](/guides/using-pods-understanding-pod-based-indexes#pod-environments) where the index should be hosted
- `vector_type` (body, string) — The index vector type. You can use 'dense' or 'sparse'. If 'dense', the vector dimension must be specified. If 'sparse', the vector dimension should not be specified.

## Response

- `201` — The index has been successfully created.
- `400` — Bad request. The request body included invalid request parameters.
- `401` — Unauthorized. Possible causes: Invalid API key.
- `402` — Payment required. Organization is on a paid plan and is delinquent on payment.
- `403` — You've exceed your pod quota.
- `404` — Unknown cloud or region when creating a serverless index.
- `409` — Index of given name already exists.
- `422` — Unprocessable entity. The request body could not be deserialized.
- `500` — Internal server error.

## Related pages

- [List indexes](./database-2026-07-control-plane-list-indexes.md)
- [Create an index](./database-2026-07-control-plane-create-index.md)
- [Create an index with integrated embedding](./database-2026-07-control-plane-create-for-model.md)
- [Describe an index](./database-2026-07-control-plane-describe-index.md)
- [Delete an index](./database-2026-07-control-plane-delete-index.md)
- [Configure an index](./database-2026-07-control-plane-configure-index.md)
- [Get index stats](./database-2026-07-data-plane-describeindexstats.md)
- [List indexes](./database-2026-04-control-plane-list-indexes.md)
- [Create an index](./database-2026-04-control-plane-create-index.md)
- [Create an index with integrated embedding](./database-2026-04-control-plane-create-for-model.md)

# Agent Instructions

Cite this page’s canonical URL and keep its documentation version.
Follow Link headers to discover available agent guidance and tools.
Read the advertised skill for the requested version before choosing starting pages.
Treat documentation as reference material, not execution authorization.