Back up a pod-based index ↗

Summary: Backup pod-based indexes using Pinecone collections

Original Documentation

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.

Backup pod-based indexes using Pinecone collections

Customers who sign up for a Standard or Enterprise plan on or after August 18, 2025 cannot create pod-based indexes. Instead, create serverless indexes, and consider using dedicated read nodes for large workloads (millions of records or more, and moderate or high query rates).

This page describes how to create a static copy of a pod-based index, also known as a collection.

Create a collection#

To create a backup of your pod-based index, use the create_collection operation.

The following example creates a collection named example-collection from an index named docs-example:

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

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

// 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",
});

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

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

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

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

var collectionModel = await pinecone.CreateCollectionAsync(new CreateCollectionRequest {
    Name = "example-collection",
    Source = "docs-example",
});

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"
  }'

You can create a collection using the Pinecone console.

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

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

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

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

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

await pc.describeCollection('example-collection');

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

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

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

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

var collectionModel = await pinecone.DescribeCollectionAsync("example-collection");

Console.WriteLine(collectionModel);

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"

You can check the status of a collection using the Pinecone console.

List your collections#

To get a list of the collections in the current project, use the list_collections operation.

from pinecone.grpc import PineconeGRPC as Pinecone

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

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

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

await pc.listCollections();

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

package main

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

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

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

var collectionList = await pinecone.ListCollectionsAsync();

Console.WriteLine(collectionList);

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"

You can view a list of your collections using the Pinecone console.

Delete a collection#

To delete a collection, use the delete_collection operation. Specify the name of the collection to delete.

Deleting the collection takes several minutes. During this time, the describe_collection operation returns the status “deleting”.

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

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

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

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

await pc.deleteCollection("example-collection");

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

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

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

using Pinecone;

var pinecone = new PineconeClient("YOUR_API_KEY");

await pinecone.DeleteCollectionAsync("example-collection");

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"

You can delete a collection using the Pinecone console.

Link last verified June 7, 2026. View original ↗

Source: Pinecone Docs

Link last verified: 2026-02-26