Migrate a pod-based index to serverless ↗

    pip show pinecone  
    ```

```shell
    npm list | grep @pinecone-database/pinecone  
    ```

```shell
    # Check your dependency file or classpath
    ```

```shell
    go list -u -m all | grep go-pinecone
    ```
  

2. If your SDK version is less than 3.0.0 for [Python](https://github.com/pinecone-io/pinecone-python-client), 2.0.0 for [Node.js](https://sdk.pinecone.io/typescript/), 1.0.0 for [Java](https://github.com/pinecone-io/pinecone-java-client), or 1.0.0 for [Go](https://github.com/pinecone-io/go-pinecone), upgrade the SDK as follows:

  
```Python
    pip install "pinecone[grpc]" --upgrade  
    ```

```JavaScript
    npm install @pinecone-database/pinecone@latest  
    ```

```shell
    # Maven
    <dependency>
      <groupId>io.pinecone</groupId>
      <artifactId>pinecone-client</artifactId>
      <version>5.0.0</version>
    </dependency>

    # Gradle
    implementation "io.pinecone:pinecone-client:5.0.0"
    ```

```go
    go get -u github.com/pinecone-io/go-pinecone/v4/pinecone@latest
    ```
  

  If you are using the [.NET SDK](/reference/sdks/dotnet/overview), add a package reference to your project file:

  ```shell
  dotnet add package Pinecone.Client 

    from pinecone.grpc import PineconeGRPC as Pinecone
    from pinecone import ServerlessSpec, PodSpec  
    # ServerlessSpec and PodSpec are required only when  
    # creating serverless and pod-based indexes.  
    pc = Pinecone(api_key="YOUR_API_KEY")  
    ```

```JavaScript
    import { Pinecone } from '@pinecone-database/pinecone';  

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

```java
    import io.pinecone.clients.Pinecone;
    import org.openapitools.db_control.client.model.*;

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

```go
    package main

    import (
        "context"
        "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)
        }
    }
    ```

```csharp
    using Pinecone;

    var pinecone = new PineconeClient("YOUR_API_KEY");
    ```
  

2. [Listing indexes](/guides/manage-data/manage-indexes) now fetches a complete description of each index. If you were relying on the output of this operation, you'll need to adapt your code.

  
```Python
    from pinecone.grpc import PineconeGRPC as Pinecone

    pc = Pinecone(api_key="YOUR_API_KEY")

    index_list = pc.list_indexes()

    print(index_list)
    ```

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

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

    const indexList = await pc.listIndexes();

    console.log(indexList);
    ```

```java
    import io.pinecone.clients.Pinecone;
    import org.openapitools.db_control.client.model.*;

    public class ListIndexesExample {
        public static void main(String[] args) {
            Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
            IndexList indexList = pc.listIndexes();
            System.out.println(indexList);
        }
    }
    ```

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

        idxs, err := pc.ListIndexes(ctx)
        if err != nil {
            log.Fatalf("Failed to list indexes: %v", err)
        } else {
            for _, index := range idxs {
                fmt.Printf("index: %v\n", prettifyStruct(index))
            }
        }
    }
    ```

```csharp
    using Pinecone;

    var pinecone = new PineconeClient("YOUR_API_KEY");

    var indexList = await pinecone.ListIndexesAsync();

    Console.WriteLine(indexList);
    ```

```shell
    PINECONE_API_KEY="YOUR_API_KEY"

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

  The `list_indexes` operation now returns a response like the following:

  
```python
    [{
        "name": "docs-example-sparse",
        "metric": "dotproduct",
        "host": "docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io",
        "spec": {
            "serverless": {
                "cloud": "aws",
                "region": "us-east-1"
            }
        },
        "status": {
            "ready": true,
            "state": "Ready"
        },
        "vector_type": "sparse",
        "dimension": null,
        "deletion_protection": "disabled",
        "tags": {
            "environment": "development"
        }
    }, {
        "name": "docs-example-dense",
        "metric": "cosine",
        "host": "docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io",
        "spec": {
            "serverless": {
                "cloud": "aws",
                "region": "us-east-1"
            }
        },
        "status": {
            "ready": true,
            "state": "Ready"
        },
        "vector_type": "dense",
        "dimension": 1536,
        "deletion_protection": "disabled",
        "tags": {
            "environment": "development"
        }
    }]
    ```

```javascript
    {
      indexes: [
        {
          name: 'docs-example-sparse',
          dimension: undefined,
          metric: 'dotproduct',
          host: 'docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io',
          deletionProtection: 'disabled',
          tags: { environment: 'development', example: 'tag' },
          embed: undefined,
          spec: { pod: undefined, serverless: { cloud: 'aws', region: 'us-east-1' } },
          status: { ready: true, state: 'Ready' },
          vectorType: 'sparse'
        },
        {
          name: 'docs-example-dense',
          dimension: 1536,
          metric: 'cosine',
          host: 'docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io',
          deletionProtection: 'disabled',
          tags: { environment: 'development', example: 'tag' },
          embed: undefined,
          spec: { pod: undefined, serverless: { cloud: 'aws', region: 'us-east-1' } },
          status: { ready: true, state: 'Ready' },
          vectorType: 'dense'
        }
      ]
    }
    ```

```java
    class IndexList {
        indexes: [class IndexModel {
            name: docs-example-sparse
            dimension: null
            metric: dotproduct
            host: docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io
            deletionProtection: disabled
            tags: {environment=development}
            embed: null
            spec: class IndexModelSpec {
                pod: null
                serverless: class ServerlessSpec {
                    cloud: aws
                    region: us-east-1
                    additionalProperties: null
                }
                additionalProperties: null
            }
            status: class IndexModelStatus {
                ready: true
                state: Ready
                additionalProperties: null
            }
            vectorType: sparse
            additionalProperties: null
        }, class IndexModel {
            name: docs-example-dense
            dimension: 1536
            metric: cosine
            host: docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io
            deletionProtection: disabled
            tags: {environment=development}
            embed: null
            spec: class IndexModelSpec {
                pod: null
                serverless: class ServerlessSpec {
                    cloud: aws
                    region: us-east-1
                    additionalProperties: null
                }
                additionalProperties: null
            }
            status: class IndexModelStatus {
                ready: true
                state: Ready
                additionalProperties: null
            }
            vectorType: dense
            additionalProperties: null
        }]
        additionalProperties: null
    }
    ```

```go
    index: {
      "name": "docs-example-sparse",
      "host": "docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io",
      "metric": "dotproduct",
      "vector_type": "sparse",
      "deletion_protection": "disabled",
      "dimension": null,
      "spec": {
        "serverless": {
          "cloud": "aws",
          "region": "us-east-1"
        }
      },
      "status": {
        "ready": true,
        "state": "Ready"
      },
      "tags": {
        "environment": "development"
      }
    }
    index: {
      "name": "docs-example-dense",
      "host": "docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io",
      "metric": "cosine",
      "vector_type": "dense",
      "deletion_protection": "disabled",
      "dimension": 1536,
      "spec": {
        "serverless": {
          "cloud": "aws",
          "region": "us-east-1"
        }
      },
      "status": {
        "ready": true,
        "state": "Ready"
      },
      "tags": {
        "environment": "development"
      }
    }
    ```

```csharp
    {
      "indexes": [
        {
          "name": "docs-example-sparse",
          "metric": "dotproduct",
          "host": "docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io",
          "deletion_protection": "disabled",
          "tags": {
            "environment": "development"
          },
          "spec": {
            "serverless": {
              "cloud": "aws",
              "region": "us-east-1"
            }
          },
          "status": {
            "ready": true,
            "state": "Ready"
          },
          "vector_type": "sparse"
        },
        {
          "name": "docs-example-dense",
          "dimension": 1536,
          "metric": "cosine",
          "host": "docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io",
          "deletion_protection": "disabled",
          "tags": {
            "environment": "development"
          },
          "spec": {
            "serverless": {
              "cloud": "aws",
              "region": "us-east-1"
            }
          },
          "status": {
            "ready": true,
            "state": "Ready"
          },
          "vector_type": "dense"
        }
      ]
    }
    ```

```json
    {
      "indexes": [
        {
          "name": "docs-example-sparse",
          "vector_type": "sparse",
          "metric": "dotproduct",
          "dimension": null,
          "status": {
            "ready": true,
            "state": "Ready"
          },
          "host": "docs-example-sparse-govk0nt.svc.aped-4627-b74a.pinecone.io",
          "spec": {
            "serverless": {
              "region": "us-east-1",
              "cloud": "aws"
            }
          },
          "deletion_protection": "disabled",
          "tags": {
            "environment": "development"
          }
        },
        {
          "name": "docs-example-dense",
          "vector_type": "dense",
          "metric": "cosine",
          "dimension": 1536,
          "status": {
            "ready": true,
            "state": "Ready"
          },
          "host": "docs-example-dense-govk0nt.svc.aped-4627-b74a.pinecone.io",
          "spec": {
            "serverless": {
              "region": "us-east-1",
              "cloud": "aws"
            }
          },
          "deletion_protection": "disabled",
          "tags": {
            "environment": "development"
          }
        }
      ]
    }
    ```
  

3. [Describing an index](/guides/manage-data/manage-indexes) now returns a description of an index in a different format. It also returns the index host needed to run data plane operations against the index. If you were relying on the output of this operation, you'll need to adapt your code.

  
```Python
    from pinecone.grpc import PineconeGRPC as Pinecone

    pc = Pinecone(api_key="YOUR_API_KEY")

    pc.describe_index(name="docs-example")
    ```

```JavaScript
    import { Pinecone } from '@pinecone-database/pinecone';

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

    await pc.describeIndex('docs-example');
    ```

```java
    import io.pinecone.clients.Pinecone;
    import org.openapitools.db_control.client.model.*;

    public class DescribeIndexExample {
        public static void main(String[] args) {
            Pinecone pc = new Pinecone.Builder("YOURE_API_KEY").build();
            IndexModel indexModel = pc.describeIndex("docs-example");
            System.out.println(indexModel);
        }
    }
    ```

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

        idx, err := pc.DescribeIndex(ctx, "docs-example")
        if err != nil {
            log.Fatalf("Failed to describe index \"%v\": %v", idx.Name, err)
        } else {
            fmt.Printf("index: %v\n", prettifyStruct(idx))
        }
    }
    ```

```csharp
    using Pinecone;

    var pinecone = new PineconeClient("YOUR_API_KEY");

    var indexModel = await pinecone.DescribeIndexAsync("docs-example");

    Console.WriteLine(indexModel);
    ```

```bash
    PINECONE_API_KEY="YOUR_API_KEY"

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

## 6. Use your new index

When you're ready to cutover to your new serverless index:

1. Your new serverless index has a different name and unique endpoint than your pod-based index. Update your code to target the new serverless index:

  
```Python
    index = pc.Index("YOUR_SERVERLESS_INDEX_NAME")  
    ```

```JavaScript
    const index = pc.index("YOUR_SERVERLESS_INDEX_NAME");
    ```

```java
    import io.pinecone.clients.Index;
    import io.pinecone.clients.Pinecone;

    public class TargetIndexExample {
        public static void main(String[] args) {
            Pinecone pc = new Pinecone.Builder("YOUR_API_KEY").build();
            Index index = pc.getIndexConnection("YOUR_SERVERLESS_INDEX_NAME");
    ```

```go
    package main

    import (
        "context"
        "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)
        }

        idx, err := pc.DescribeIndex(ctx, "YOUR_SERVERLESS_INDEX_NAME")
        if err != nil {
            log.Fatalf("Failed to describe index \"%v\": %v", idx.Name, err)
        }

        idxConnection, err := pc.Index(pinecone.NewIndexConnParams{Host: idx.Host, Namespace: "example-namespace"})
        if err != nil {
            log.Fatalf("Failed to create IndexConnection for Host %v: %v", idx.Host, err)
        }
    }
    ```

```csharp
    using Pinecone;

    var pinecone = new PineconeClient("YOUR_API_KEY");

    var index = pinecone.Index("YOUR_SERVERLESS_INDEX_NAME");
    ```

```bash
    # When using the API directly, you need the unique endpoint for your new serverless index. 
    # See https://docs.pinecone.io/guides/manage-data/target-an-index for details.
    PINECONE_API_KEY="YOUR_API_KEY"
    INDEX_HOST="INDEX_HOST"

    curl -X POST "https://$INDEX_HOST/describe_index_stats" \  
        -H "Api-Key: $PINECONE_API_KEY" \
        -H "X-Pinecone-Api-Version: 2025-10" 
    ```
  

2. Reinitialize your clients.

3. If you logged writes to the pod-based index during migration, replay the logged writes to your serverless index.

4. [Delete the pod-based index](/guides/manage-data/manage-indexes#delete-an-index) to avoid paying for unused resources.

  <span class="callout-start" data-callout-type="warning"></span>
It is not possible to save a serverless index as a collection, so if you want to retain the option to recreate your pod-based index, be sure to keep the collection you created earlier.
  <span class="callout-end"></span>

## See also

* [Limits](/reference/api/database-limits)
* [Serverless architecture](/guides/get-started/database-architecture)
* [Understanding serverless cost](/guides/manage-cost/understanding-cost)