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

# Back up a pod-based index

> Legacy guide for backing up Pinecone pod-based indexes using collections. Collections are a pod-only feature not available for serverless indexes.

> [!WARNING]
>
> Pod-based indexes are legacy. Customers who signed up for a Standard or Enterprise plan on or after August 18, 2025 cannot create them. [Create a serverless index](https://docs.pinecone.io/guides/indexes/create-an-index.md) instead. Serverless indexes use on-demand read capacity by default, or [dedicated read nodes](https://docs.pinecone.io/guides/optimize/dedicated-read-nodes/overview.md) for sustained high query rates and workloads of millions of records or more.

> [!NOTE]
>
> SDKs that target API version `2026-07` don't support creating pod-based indexes, and they reject creating an index from a collection. You can still list, describe, and delete existing collections. To create or restore a pod-based index, use an [SDK version](https://docs.pinecone.io/reference/pinecone-sdks.md#sdk-versions) that targets an earlier API version, or send an earlier `X-Pinecone-Api-Version` with the REST API. To move a pod-based index to serverless, see [Migrate a pod-based index to serverless](https://docs.pinecone.io/guides/legacy/pod-based-indexes/migrate-a-pod-based-index-to-serverless.md).

This page describes how to create a static copy of a pod-based index, also known as a [collection](https://docs.pinecone.io/guides/legacy/pod-based-indexes/understanding-collections.md).

## Create a collection

To create a backup of your pod-based index, use the [Create a collection](https://docs.pinecone.io/reference/api/latest/control-plane/create_collection.md) operation.

The following example creates a [collection](https://docs.pinecone.io/guides/legacy/pod-based-indexes/understanding-collections.md) named `example-collection` from an index named `docs-example`:

```python Python theme={null}
# pip install pinecone
from pinecone.grpc import PineconeGRPC as Pinecone

pc = Pinecone(api_key="API_KEY")
pc.create_collection("example-collection", "docs-example")
```

```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.createCollection({
  name: "example-collection",
  source: "docs-example",
});
```

```java Java theme={null}
import io.pinecone.clients.Pinecone;

public class CreateCollectionExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();

        pc.createCollection("example-collection", "docs-example");
    }
}
```

```go Go theme={null}
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v7/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)
    }

    collection, err := pc.CreateCollection(ctx, &pinecone.CreateCollectionRequest{
        Name: "example-collection", 
        Source: "docs-example",
    })
    if err != nil {
        log.Fatalf("Failed to create collection: %v", err)
    } else {
        fmt.Printf("Successfully created collection: %v", collection.Name)
    }
}
```

```shell curl theme={null}
PINECONE_API_KEY="YOUR_API_KEY"

curl -s POST "https://api.pinecone.io/collections" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "X-Pinecone-Api-Version: 2025-10" \
  -d '{
        "name": "example-collection",
        "source": "docs-example"
  }'
```

> [!TIP]
>
> You can create a collection using the [Pinecone console](https://app.pinecone.io/organizations/-/projects/-/backups).

## Check the status of a collection

To retrieve the status of the process creating a collection and the size of the collection, use the [Describe a collection](https://docs.pinecone.io/reference/api/latest/control-plane/describe_collection.md) operation. Specify the name of the collection to check. You can only call `describe_collection` on a collection in the current project.

The `describe_collection` operation returns an object containing key-value pairs representing the name of the collection, the size in bytes, and the creation status of the collection.

The following example gets the creation status and size of a collection named `example-collection`.

```python Python theme={null}
# pip install pinecone
from pinecone.grpc import PineconeGRPC as Pinecone

pc = Pinecone(api_key='API_KEY')
pc.describe_collection(name="example-collection")
```

```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.describeCollection('example-collection');
```

```java Java theme={null}
import io.pinecone.clients.Pinecone;
import org.openapitools.client.model.CollectionModel;

public class DescribeCollectionExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        CollectionModel collectionModel = pc.describeCollection("example-collection");
        System.out.println(collectionModel);
    }
}
```

```go Go theme={null}
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v7/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)
    }

    collectionName := "example-collection"

    collection, err := pc.DescribeCollection(ctx, collectionName)
    if err != nil {
        log.Fatalf("Error describing collection %v: %v", collectionName, err)
    } else {
        fmt.Printf("Collection: %+v", collection)
    }
}
```

```shell curl theme={null}
PINECONE_API_KEY="YOUR_API_KEY"

curl -i -X GET "https://api.pinecone.io/collections/example-collection" \
    -H "Api-Key: $PINECONE_API_KEY" \
    -H "X-Pinecone-Api-Version: 2025-10"
```

> [!TIP]
>
> You can check the status of a collection using the [Pinecone console](https://app.pinecone.io/organizations/-/projects/-/backups).

## List your collections

To get a list of the collections in the current project, use the [List collections](https://docs.pinecone.io/reference/api/latest/control-plane/list_collections.md) operation.

```python Python theme={null}
from pinecone.grpc import PineconeGRPC as Pinecone

pc = Pinecone(api_key='API_KEY')
pc.list_collections()
```

```javascript JavaScript theme={null}
import { Pinecone } from '@pinecone-database/pinecone'

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

await pc.listCollections();
```

```java Java theme={null}
import io.pinecone.clients.Pinecone;
import org.openapitools.client.model.CollectionModel;

public class ListCollectionsExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        List<CollectionModel> collectionList = pc.listCollections().getCollections();
    }
}
```

```go Go theme={null}
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

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

func prettifyStruct(obj interface{}) string {
    bytes, _ := json.MarshalIndent(obj, "", "  ")
    return string(bytes)
}

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)
    }

    collections, err := pc.ListCollections(ctx)
    if err != nil {
	    log.Fatalf("Failed to list collections: %v", err)
    } else {
        if len(collections) == 0 {
            fmt.Printf("No collections found in project")
        } else {
            for _, collection := range collections {
                fmt.Printf("collection: %v\n", prettifyStruct(collection))
            }
        }
    }
}
```

```shell curl theme={null}
PINECONE_API_KEY="YOUR_API_KEY"

curl -i -X GET "https://api.pinecone.io/collections" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "X-Pinecone-Api-Version: 2025-10"
```

> [!TIP]
>
> You can view a list of your collections using the [Pinecone console](https://app.pinecone.io/organizations/-/projects/-/backups).

> [!TIP]
>
> You can view a list of your collections using the [Pinecone console](https://app.pinecone.io/organizations/-/projects/-/backups).

## Delete a collection

To delete a collection, use the [Delete a collection](https://docs.pinecone.io/reference/api/latest/control-plane/delete_collection.md) operation. Specify the name of the collection to delete.

Deleting the collection takes several minutes. During this time, the [`describe_collection`](#check-the-status-of-a-collection) operation returns the status "deleting".

```python Python theme={null}
# pip install pinecone
from pinecone.grpc import PineconeGRPC as Pinecone

pc = Pinecone(api_key='API_KEY')
pc.delete_collection("example-collection")
```

```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.deleteCollection("example-collection");
```

```java Java theme={null}
import io.pinecone.clients.Pinecone;

public class DeleteCollectionExample {
    public static void main(String[] args) {
        Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
        pc.deleteCollection("example-collection");
    }
}
```

```go Go theme={null}
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/pinecone-io/go-pinecone/v7/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)
    }

    collectionName := "example-collection"

    err = pc.DeleteCollection(ctx, collectionName)
    if err != nil {
	    log.Fatalf("Failed to delete collection: %v\n", err)
    } else {
        if len(collections) == 0 {
            fmt.Printf("No collections found in project")
        } else {
            fmt.Printf("Successfully deleted collection \"%v\"\n", collectionName)
        }
    }
}
```

```shell curl theme={null}
PINECONE_API_KEY="YOUR_API_KEY"

curl -i -X DELETE "https://api.pinecone.io/collections/example-collection" \
  -H "Api-Key: $PINECONE_API_KEY" \
  -H "X-Pinecone-Api-Version: 2025-10"
```

> [!TIP]
>
> You can delete a collection using the [Pinecone console](https://app.pinecone.io/organizations/-/projects/-/backups).