[metadata]
apple-mobile-web-app-title: Pinecone Docs
application-name: Pinecone Docs
description: Reference for Pinecone Database limits, covering upsert, query, fetch, delete, import, namespace, and rate limits for serverless indexes.
generator: Mintlify
google-site-verification: woTBImNAcYO-gseVfFKIzQrDRUmLWzFjBWrYbYkOTlI
msapplication-TileColor: #002BFF
msapplication-config: /mintlify-assets/_mintlify/favicons/pinecone/JqxxUxUkDTnX7oN2/_generated/favicon/browserconfig.xml
og:description: Reference for Pinecone Database limits, covering upsert, query, fetch, delete, import, namespace, and rate limits for serverless indexes.
og:image: https://www.pinecone.io/images/docs_og_image_v2.png
og:image:height: 630
og:image:width: 1200
og:site_name: Pinecone Docs
og:title: Pinecone Database limits - Pinecone Docs
og:type: website
og:url: https://docs.pinecone.io/reference/api/database-limits
twitter:card: summary_large_image
twitter:description: Search through billions of items for similar matches to any object, in milliseconds. It's the next generation of search, an API call away.
twitter:image: https://www.pinecone.io/images/docs_og_image_v2.png
twitter:image:height: 630
twitter:image:width: 1200
twitter:title: The vector database to build knowledgeable AI | Pinecone
viewport: width=device-width, initial-scale=1, viewport-fit=cover

[canonical-links]
https://docs.pinecone.io/reference/api/database-limits

[document-links]
/llms.txt: /llms.txt
Authentication: /reference/api/authentication
Authentication: /reference/cli/authentication
Command reference: /reference/cli/command-reference
Database limits: /reference/api/database-limits
Dedicated Read Nodes: /guides/index-data/dedicated-read-nodes
Design for multi-tenancy: /guides/index-data/data-modeling#design-for-multi-tenancy
Design for multi-tenancy: /guides/index-data/data-modeling#use-access-control-groups-instead-of-individual-ids
Error Handling Guide: /guides/production/error-handling#implement-retry-logic
Errors: /reference/api/errors
Examples: /examples/notebooks
Fetch records by metadata: /guides/manage-data/fetch-data#fetch-records-by-metadata
Guides: /guides/get-started/overview
Index: /guides/get-started/concepts#index
Integrations: /integrations/overview
Introduction: /reference/api/introduction
JSONL files: /guides/search/full-text-search#bulk-import
Known limitations: /reference/api/known-limitations
Log In: https://app.pinecone.io/?sessionType=login
Models: /models/overview
Namespace: /guides/get-started/concepts#namespace
Namespaces per serverless index: /reference/api/database-limits#namespaces-per-serverless-index
Organization: /guides/get-started/concepts#organization
Pinecone Docs home page: https://www.pinecone.io
Pinecone SDKs overview: /reference/pinecone-sdks
Pinecone console: https://app.pinecone.io/organizations/-/projects
Project: /guides/get-started/concepts#project
Quickstart: /reference/cli/quickstart
Read units: /guides/manage-cost/understanding-cost#read-units
Record: /guides/get-started/concepts#record
Reference: /reference/api/introduction
Releases: /release-notes/2026
See details: /guides/manage-cost/understanding-cost#imports
Sign up free: https://app.pinecone.io/?sessionType=signup
Spark-Pinecone connector: /reference/tools/pinecone-spark-connector
Status: https://status.pinecone.io
Support: https://app.pinecone.io/organizations/-/settings/support
Target context: /reference/cli/target-context
Troubleshooting: /guides/index-data/import-data#troubleshooting
Troubleshooting: /troubleshooting/contact-support
Versioning: /reference/api/versioning
Write units: /guides/manage-cost/understanding-cost#write-units
batch size: /guides/index-data/upsert-data#upsert-in-batches
check the query response: /guides/manage-cost/monitor-usage-and-costs#read-units
contact Support: https://app.pinecone.io/organizations/-/settings/support/ticket
create collections: /guides/manage-data/back-up-an-index
create projects: /guides/projects/create-a-project
create serverless backups: /guides/manage-data/back-up-an-index
create serverless indexes: /guides/index-data/create-an-index#create-a-serverless-index
dedicated read nodes: /guides/index-data/dedicated-read-nodes
delete by metadata: /guides/manage-data/delete-data#delete-records-by-metadata
delete records: /guides/manage-data/delete-data
delete: /guides/manage-data/delete-data
describe index stats: /reference/api/2024-10/data-plane/describeindexstats
embedding model: /guides/index-data/create-an-index#embedding-models
fetch: /guides/manage-data/fetch-data
github: https://github.com/pinecone-io
implement retry logic with exponential backoff: /guides/production/error-handling#implement-retry-logic
implementing retry logic with exponential backoff: /guides/production/error-handling#implement-retry-logic
linkedin: https://www.linkedin.com/company/pinecone-io
list: /guides/manage-data/list-record-ids
metadata filter expressions: /guides/search/filter-by-metadata#metadata-filter-expressions
namespaces: /guides/index-data/create-an-index#namespaces
objects in Pinecone: /guides/get-started/concepts
pricing plan: https://www.pinecone.io/pricing/
query: /guides/search/search-overview
read units: /guides/manage-cost/understanding-cost#read-units
reranking model: /guides/search/rerank-results#reranking-models
serverless indexes: /guides/index-data/indexing-overview
supported region: /guides/index-data/create-an-index#cloud-regions
update by metadata: /guides/manage-data/update-data#update-metadata-across-multiple-records
update: /guides/manage-data/update-data
upgrade your plan: /guides/organizations/manage-billing/upgrade-billing-plan
upsert records into a new namespace: /guides/index-data/upsert-data
upsert: /guides/index-data/upsert-data
x: https://x.com/pinecone?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor
youtube: https://www.youtube.com/@pinecone-io

[structured-data]
{"@context":"https://schema.org","@graph":[{"@id":"https://docs.pinecone.io/#organization","@type":"Organization","logo":{"@type":"ImageObject","url":"https://mintcdn.com/pinecone/HsZKO51bNmpAasdT/logo/Pinecone-Full-Logo-Black.svg?fit=max&auto=format&n=HsZKO51bNmpAasdT&q=85&s=211d0e7bbefc29ce3b8feee1a05d76ee"},"name":"Pinecone Docs","url":"https://docs.pinecone.io"},{"@id":"https://docs.pinecone.io#website","@type":"WebSite","name":"Pinecone Docs","publisher":{"@id":"https://docs.pinecone.io/#organization"},"url":"https://docs.pinecone.io"},{"@id":"https://docs.pinecone.io/reference/api/database-limits#webpage","@type":"WebPage","breadcrumb":{"@id":"https://docs.pinecone.io/reference/api/database-limits#breadcrumb"},"dateModified":"2026-08-11T14:29:35.139Z","description":"Reference for Pinecone Database limits, covering upsert, query, fetch, delete, import, namespace, and rate limits for serverless indexes.","isPartOf":{"@id":"https://docs.pinecone.io#website"},"name":"Pinecone Database limits","url":"https://docs.pinecone.io/reference/api/database-limits"},{"@id":"https://docs.pinecone.io/reference/api/database-limits#breadcrumb","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","item":"https://docs.pinecone.io/reference/api/introduction","name":"APIs","position":1},{"@type":"ListItem","item":"https://docs.pinecone.io/reference/api/database-limits","name":"Pinecone Database limits","position":2}]},{"@id":"https://docs.pinecone.io/reference/api/database-limits#article","@type":["Article","TechArticle"],"dateModified":"2026-08-11T14:29:35.139Z","description":"Reference for Pinecone Database limits, covering upsert, query, fetch, delete, import, namespace, and rate limits for serverless indexes.","headline":"Pinecone Database limits","image":"https://www.pinecone.io/images/docs_og_image_v2.png","isPartOf":{"@id":"https://docs.pinecone.io#website"},"mainEntityOfPage":{"@id":"https://docs.pinecone.io/reference/api/database-limits#webpage"},"name":"Pinecone Database limits","publisher":{"@id":"https://docs.pinecone.io/#organization"},"url":"https://docs.pinecone.io/reference/api/database-limits"}]}

[content]
Pinecone Database limits - Pinecone Docs
Documentation Index
Fetch the complete documentation index at:
/llms.txt
Use this file to discover all available pages before exploring further.
Skip to main content
🎉 New: Standard and Enterprise orgs get a one-time
$250 bulk import credit
(1 TB), valid through August 30, 2026.
See details
Pinecone Docs
home page
2026-04 (latest)
Search...
⌘
K
Ask Assistant
Status
Support
Log In
Sign up free
Sign up free
Search...
Navigation
Limits
Pinecone Database limits
Guides
Reference
Examples
Models
Integrations
Troubleshooting
Releases
Pinecone Database
APIs
Introduction
Authentication
Versioning
Limits
Database limits
Known limitations
Errors
Database
Indexes
Namespaces
Vectors
Search
Imports
Backups
Backup schedules
Inference
Embed
Rerank
Models
Admin
API keys
Projects
Service accounts
Users
Invites
Role bindings
SDKs
Pinecone SDKs overview
Python
Node.js
Java
Go
CLI
Quickstart
Command reference
Authentication
Target context
Tools
Spark-Pinecone connector
On this page
Rate limits
Data plane operations: request-per-second limits
Affected operations
Error response
How request-per-second limits work with limits on read and write units
Recommendations
All rate limits
Monthly usage limits
Data operation throughput limits
Model throughput limits
Read units per month per org
Write units per month per org
Upsert size per second per namespace
Query read units per second per index
Query requests per second per namespace
Update records per second per namespace
Update requests per second per namespace
Update by metadata requests per second per namespace
Update by metadata requests per second per index
Upsert requests per second per namespace
Fetch requests per second per index
List requests per second per index
Describe index stats requests per second per index
Delete requests per second per namespace
Delete records per second per namespace
Delete records per second per index
Delete by metadata requests per second per namespace
Delete by metadata requests per second per index
Embedding tokens per minute per model
Embedding tokens per month per model
Rerank requests per minute per model
Rerank requests per month per model
Inference requests per second or minute, per project
Object limits
Projects per organization
Users per organization
Serverless indexes per project
Serverless index storage per org
Namespaces per serverless index
Serverless backups per project
Collections per project
Operation limits
Upsert limits
Import limits
Query limits
Fetch limits
Delete limits
Metadata filter limits
Rationale
Alternative approaches
Identifier limits
Limits
Pinecone Database limits
Copy page
Copy page
Reference for Pinecone Database limits, covering upsert, query, fetch, delete, import, namespace, and rate limits for serverless indexes.
Copy page
Copy page
This page describes different types of limits for Pinecone Database.
Looking for a specific limit?
To compare monthly included usage by plan, start with
read units
,
write units
, and
model usage limits
.
If you received a
429
error, check
rate limits
, especially request-per-second limits for query, upsert, update, delete, fetch, and list.
For projects, users, indexes, namespaces, storage, backups, and collections, see
object limits
.
For batch sizes, metadata filters, and identifier lengths, see
operation limits
and
identifier limits
.
​
Rate limits
Rate limits help protect your applications from misuse and maintain the health of our shared serverless infrastructure. These limits are designed to support typical production workloads while ensuring reliable performance for all users.
Most rate limits can be adjusted upon request.
If you need higher limits to scale your application,
contact Support
with details about your use case. Pinecone is committed to supporting your growth and can often accommodate higher throughput requirements.
Rate limits vary based on
pricing plan
and apply to
serverless indexes
only.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
Data plane operations: request-per-second limits
Pinecone enforces rate limits on the number of API requests per second at the namespace level for data plane operations (query, upsert, delete, and update). These limits provide protection against excessive request rates.
​
Affected operations
The following operations are subject to request-per-second rate limiting:
Operation
Scope
Limit
Query
Per namespace
100
Upsert
Per namespace
100
Delete
Per namespace
100
Update
Per namespace
100
​
Error response
When you exceed the request-per-second limit, you’ll receive an HTTP
429 - TOO_MANY_REQUESTS
response. The error message indicates which operation exceeded the limit and includes the namespace name and limit value. See the individual limit sections below for specific error message formats.
​
How request-per-second limits work with limits on read and write units
Request-per-second limits are enforced in addition to existing read unit and write unit limits. Requests must not exceed any applicable limits:
Index-level limits - read and write unit limits, per index
Namespace-level limits - read and write unit limits, per namespace
Request-per-second limits - requests per second, per namespace
If any limit is exceeded, the request fails with a 429 error.
​
Recommendations
If you’re hitting request-per-second limits:
Implement retry logic. Use exponential backoff to handle rate limit errors gracefully. See
Error Handling Guide
.
Pace your requests. Add client-side rate limiting to stay under limits.
Consider
Dedicated Read Nodes
, which don’t have request-per-second limits and provide dedicated capacity for high-throughput workloads.
If you need higher limits,
contact Support
with details about your use case.
​
All rate limits
​
Monthly usage limits
Metric
Starter plan
Builder plan
Standard plan
Enterprise plan
Read units per month per org
1,000,000
2,000,000
Unlimited
Unlimited
Write units per month per org
2,000,000
5,000,000
Unlimited
Unlimited
Embedding tokens per month per model
5,000,000
10,000,000
Unlimited
Unlimited
Rerank requests per month per model
Model-specific
Model-specific
Model-specific
Model-specific
​
Data operation throughput limits
Metric
Starter plan
Builder plan
Standard plan
Enterprise plan
Upsert size per second per namespace
50 MB
50 MB
50 MB
50 MB
Query read units per second per index
2,000
2,000
2,000
2,000
Query requests per second per namespace
100
100
100
100
Update records per second per namespace
100
100
100
100
Update requests per second per namespace
100
100
100
100
Update by metadata requests per second per namespace
5
5
5
5
Update by metadata requests per second per index
500
500
500
500
Upsert requests per second per namespace
100
100
100
100
Fetch requests per second per index
100
100
100
100
List requests per second per index
200
200
200
200
Describe index stats requests per second per index
100
100
100
100
Delete requests per second per namespace
100
100
100
100
Delete records per second per namespace
5,000
5,000
5,000
5,000
Delete records per second per index
5,000
5,000
5,000
5,000
Delete by metadata requests per second per namespace
5
5
5
5
Delete by metadata requests per second per index
500
500
500
500
​
Model throughput limits
Metric
Starter plan
Builder plan
Standard plan
Enterprise plan
Embedding tokens per minute per model
Model-specific
Model-specific
Model-specific
Model-specific
Rerank requests per minute per model
Model-specific
Model-specific
Model-specific
Model-specific
​
Read units per month per org
Starter plan
Builder plan
Standard plan
Enterprise plan
1,000,000
2,000,000
Unlimited
Unlimited
Read units
measure the compute, I/O, and network resources used by
fetch
,
query
, and
list
requests to serverless indexes. When you reach the monthly read unit limit for an organization, fetch, query, and list requests to serverless indexes in the organization will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached your read unit limit for the current month limit.
To continue reading data, upgrade your plan.
To continue reading from serverless indexes in the organization,
upgrade your plan
.
To check how close you are to the monthly read unit limit for your organization, do the following:
Open the
Pinecone console
.
Select the project.
Select any index in the project.
Look under
Usage
.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
Write units per month per org
Starter plan
Builder plan
Standard plan
Enterprise plan
2,000,000
5,000,000
Unlimited
Unlimited
Write units
measure the storage and compute resources used by
upsert
,
update
, and
delete
requests to serverless indexes. When you reach the monthly write unit limit for an organization, upsert, update, and delete requests to serverless indexes in the organization will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached your write unit limit for the current month.
To continue writing data, upgrade your plan.
To continue writing data to serverless indexes in the organization,
upgrade your plan
.
To check how close you are to the monthly write unit limit for your organization, do the following:
Open the
Pinecone console
.
Select the project.
Select any index in the project.
Look under
Usage
.
​
Upsert size per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
50 MB
50 MB
50 MB
50 MB
When you reach the per second
upsert
size for a namespace in an index, additional upserts will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max upsert size limit per second for index <index name>.
Pace your upserts or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Query read units per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
2,000
2,000
2,000
2,000
Pinecone measures
query
usage in
read units
. When you reach the per second limit for queries across all namespaces in an index, additional queries will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max query read units per second for index <index name>.
Pace your queries or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
To check how many read units a query consumes,
check the query response
.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
Query requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
query
limit for a namespace in an index, additional queries will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the query QPS limit for namespace {namespace_name} ({limit} QPS). Pace your queries,
consider Dedicated Read Nodes for your index, or contact Pinecone Support
(https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
Update records per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
update
limit for a namespace in an index, additional updates will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max update records per second for namespace <namespace name>.
Pace your update requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Update requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
update
request limit for a namespace in an index, additional update requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the update QPS limit for namespace {namespace_name} ({limit} QPS). Pace your update requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
If you need to update most of the records in a large namespace,
contact Support
for help creating an export to enable a faster and more cost-effective approach.
​
Update by metadata requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
5
5
5
5
When you reach the per second
update by metadata
request limit for a namespace in an index, additional update by metadata requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max update by metadata requests per second for namespace <namespace name>. Pace your update by metadata requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Update by metadata requests per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
500
500
500
500
When you reach the per second
update by metadata
request limit across all namespaces in an index, additional update by metadata requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max update by metadata requests per second for index <index name>. Pace your update by metadata requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Upsert requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
upsert
request limit for a namespace in an index, additional upsert requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the upsert QPS limit for namespace {namespace_name} ({limit} QPS). Pace your upsert requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Fetch requests per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
fetch
limit across all namespaces in an index, additional fetch requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max fetch requests per second for index <index name>.
Pace your fetch requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
List requests per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
200
200
200
200
When you reach the per second
list
limit across all namespaces in an index, additional list requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max list requests per second for index <index name>.
Pace your list requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
Indexes built on
Dedicated Read Nodes
are not subject to read unit limits for query, fetch, and list operations. For sizing and capacity planning guidance, see the
Dedicated Read Nodes
guide.
​
Describe index stats requests per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
describe index stats
limit across all namespaces in an index, additional describe index stats requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max describe_index_stats requests per second for index <index>.
Pace your describe_index_stats requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Delete requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
100
100
100
100
When you reach the per second
delete
request limit for a namespace in an index, additional delete requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the delete QPS limit for namespace {namespace_name} ({limit} QPS). Pace your delete requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Delete records per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
5000
5000
5000
5000
When you reach the per second
delete
limit for a namespace in an index, additional deletes will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max delete records per second for namespace <namespace name>.
Pace your delete requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Delete records per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
5000
5000
5000
5000
When you reach the per second
delete
limit across all namespaces in an index, additional deletes will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max delete records per second for index <index name>.
Pace your delete requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Delete by metadata requests per second per namespace
Starter plan
Builder plan
Standard plan
Enterprise plan
5
5
5
5
When you reach the per second
delete by metadata
request limit for a namespace in an index, additional delete by metadata requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max delete by metadata requests per second for namespace <namespace name>. Pace your delete by metadata requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Delete by metadata requests per second per index
Starter plan
Builder plan
Standard plan
Enterprise plan
500
500
500
500
When you reach the per second
delete by metadata
request limit across all namespaces in an index, additional delete by metadata requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max delete by metadata requests per second for index <index name>. Pace your delete by metadata requests or contact Pinecone Support (https://app.pinecone.io/organizations/-/settings/support/ticket) to request a higher limit.
To handle this limit,
implement retry logic with exponential backoff
. If you need a higher limit for your use case,
contact Support
.
​
Embedding tokens per minute per model
Embedding model
Input type
Starter plan
Builder plan
Standard plan
Enterprise plan
llama-text-embed-v2
Passage
250,000
250,000
1,000,000
1,000,000
Query
50,000
50,000
250,000
250,000
multilingual-e5-large
Passage
250,000
250,000
1,000,000
1,000,000
Query
50,000
50,000
250,000
250,000
pinecone-sparse-english-v0
Passage
250,000
250,000
3,000,000
3,000,000
Query
250,000
250,000
3,000,000
3,000,000
When you reach the per minute token limit for an
embedding model
hosted by Pinecone, additional embeddings will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max embedding tokens per minute (<limit>) model '<model name>'' and input type '<passage|query>' for the current project.
To increase this limit, upgrade your plan.
To increase this limit,
upgrade your plan
. Otherwise, you can handle this limit by
implementing retry logic with exponential backoff
.
​
Embedding tokens per month per model
Starter plan
Builder plan
Standard plan
Enterprise plan
5,000,000
10,000,000
Unlimited
Unlimited
When you reach the monthly token limit for an
embedding model
hosted by Pinecone, additional embeddings will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the embedding token limit (<limit>) for model <model name> for the current month.
To continue using this model, upgrade your plan.
To increase this limit,
upgrade your plan
or
contact Support
.
​
Rerank requests per minute per model
Reranking model
Starter plan
Builder plan
Standard plan
Enterprise plan
cohere-rerank-4-fast
Not available
Not available
300
300
cohere-rerank-3.5
Not available
Not available
300
300
bge-reranker-v2-m3
60
60
60
60
pinecone-rerank-v0
60
Not available
60
60
When you reach the per minute request limit for a
reranking model
hosted by Pinecone, additional reranking requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max rerank requests per minute (<limit>) for model '<model name>' for the current project.
To increase this limit, upgrade your plan.
To increase this limit,
upgrade your plan
.
​
Rerank requests per month per model
Reranking model
Starter plan
Builder plan
Standard plan
Enterprise plan
cohere-rerank-4-fast
Not available
Not available
Unlimited
Unlimited
cohere-rerank-3.5
Not available
Not available
Unlimited
Unlimited
bge-reranker-v2-m3
500
1,000
Unlimited
Unlimited
pinecone-rerank-v0
500
Not available
Unlimited
Unlimited
When you reach the monthly request limit for a
reranking model
hosted by Pinecone, additional reranking requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the rerank request limit (<limit>) for model <model name> for the current month.
To continue using this model, upgrade your plan.
To increase this limit,
upgrade your plan
or
contact Support
.
​
Inference requests per second or minute, per project
Metric
Starter plan
Builder plan
Standard plan
Enterprise plan
Inference requests per second
100
100
100
100
Inference requests per minute
2000
2000
2000
2000
When you reach the per second or per minute request limit, inference requests will fail and return a
429 - TOO_MANY_REQUESTS
status with the following error:
Error response
Request failed. You've reached the max inference requests per second (<limit>) for the current project.
This error indicates per second or per minute, as applicable.
To handle this limit,
implement retry logic with exponential backoff
.
​
Object limits
Object limits are restrictions on the number or size of objects in Pinecone. Object limits vary based on
pricing plan
.
Metric
Starter plan
Builder plan
Standard plan
Enterprise plan
Projects per organization
1
5
20
100
Users per organization
2
5
Unlimited
Unlimited
Serverless indexes per project
1
5
10
20
200
Serverless index storage per org
2 GB
10 GB
N/A
N/A
Namespaces per serverless index
100
1,000
100,000
100,000
Serverless backups per project
N/A
N/A
500
1000
Collections per project
100
N/A
N/A
N/A
1 On the Starter plan, all serverless indexes must be in the
us-east-1
region of AWS. Builder, Standard, and Enterprise plans can create indexes in any
supported region
.
​
Projects per organization
Starter plan
Builder plan
Standard plan
Enterprise plan
1
5
20
100
When you reach this quota for an organization, trying to
create projects
will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Request failed. You've reached the max projects allowed in organization <org name>.
To add more projects, upgrade your plan.
To increase this quota,
upgrade your plan
or
contact Support
.
​
Users per organization
Starter plan
Builder plan
Standard plan
Enterprise plan
2
5
Unlimited
Unlimited
When you reach this quota for an organization, trying to add users to the organization will fail. To increase this quota,
upgrade your plan
.
​
Serverless indexes per project
Starter plan
Builder plan
Standard plan
Enterprise plan
5
10
20
200
When you reach this quota for a project, trying to
create serverless indexes
in the project will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Request failed. You've reached the max serverless indexes allowed in project <project>.
Use namespaces to partition your data into logical groups, or upgrade your plan to add more serverless indexes.
To stay under this quota, consider using
namespaces
instead of creating multiple indexes. Namespaces let you partition your data into logical groups within a single index. This approach not only helps you stay within index limits, but can also improve query performance and lower costs by limiting searches to relevant data subsets.
To increase this quota,
upgrade your plan
.
​
Serverless index storage per org
This limit applies to organizations on the Starter and Builder plans only.
Starter plan
Builder plan
Standard plan
Enterprise plan
2 GB
10 GB
N/A
N/A
When you’ve reached this quota for an organization, updates and upserts into serverless indexes will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Request failed. You've reached the max storage allowed for organization <org name>.
To update or upsert new data, delete records or upgrade your plan.
To continue writing data into your serverless indexes,
delete records
to bring your organization under the limit or
upgrade your plan
.
​
Namespaces per serverless index
Starter plan
Builder plan
Standard plan
Enterprise plan
100
1,000
100,000
100,000
When you reach this quota for a serverless index, trying to
upsert records into a new namespace
in the index will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Request failed. You've reached the max namespaces allowed in serverless index <index name>.
To add more namespaces, upgrade your plan.
To increase this quota,
upgrade your plan
.
Namespaces per serverless index
vary by plan. On the Standard and Enterprise plans, Pinecone can accommodate million-scale namespaces and beyond for specific use cases. If your application requires more than 100,000 namespaces,
contact Support
.
​
Serverless backups per project
Starter plan
Builder plan
Standard plan
Enterprise plan
N/A
N/A
500
1000
Backups are not available on the Starter or Builder plans. On the Standard and Enterprise plans, when you reach this quota for a project, trying to
create serverless backups
in the project will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Backup failed to create. Quota for number of backups per index exceeded.
​
Collections per project
Starter plan
Builder plan
Standard plan
Enterprise plan
100
N/A
N/A
N/A
When you reach this quota for a project, trying to
create collections
in the project will fail and return a
403 - QUOTA_EXCEEDED
status with the following error:
Error response
Request failed. You've reached the max collections allowed in project <project name>.
To add more collections, upgrade your plan.
To increase this quota,
upgrade your plan
.
​
Operation limits
Operation limits are restrictions on the size, number, or other characteristics of operations in Pinecone. Operation limits are fixed and do not vary based on pricing plan.
​
Upsert limits
Metric
Limit
Max
batch size
2 MB or 1000 records with vectors
96 records with text
Max documents per upsert request
1000
Max document upsert request size
2 MB
Max document size
2 MB
Max
full_text_search
string fields per schema
100
Max size per
full_text_search
string field
100 KB
Max tokens per
full_text_search
string field
10,000
Max bytes per token
256 bytes
Max filterable metadata size per document
40 KB
Max length for a record ID
512 characters
Max dimensionality for dense vectors
20,000
Max non-zero values for sparse vectors
2048
Max dimensionality for sparse vectors
4.2 billion
The 40 KB filterable metadata limit does not apply to
full_text_search
text fields.
​
Import limits
If your import exceeds these limits, you’ll get an error specifying the limit exceeded. See
Troubleshooting
for details.
Metric
Limit
Max namespaces per import
10,000
Max total input data size (on-demand indexes)
1 TB
Max total input data size (DRN indexes)
Unlimited
Max files per import
100,000
Max size per file
10 GB
The total input data size limit does not apply to indexes with
dedicated read nodes
.
Bulk import supports indexes without a schema definition (Parquet files) and indexes with document schemas (
JSONL files
). Semantic-text (auto-embedded) fields are not yet supported in document schemas.
​
Query limits
Metric
Limit
Max
top_k
value
10,000
Max result size
4MB
The query result size is affected by the dimension of the dense vectors and whether or not dense vector values and metadata are included in the result.
If a query fails due to exceeding the 4MB result size limit, choose a lower
top_k
value, or use
include_metadata=False
or
include_values=False
to exclude metadata or values from the result. For better performance, especially with higher
top_k
values, avoid including vector values unless you need them.
​
Fetch limits
Fetch by ID limits:
Metric
Limit
Max record IDs per fetch request
1,000
Fetch by metadata limits:
Metric
Limit
Max records per response
10,000
Max response size
4 MB
Max request rate
5 requests per second per namespace
To retrieve more than 10,000 matching records, paginate through results using the
paginationToken
parameter. See
Fetch records by metadata
.
​
Delete limits
Metric
Limit
Max record IDs per delete request
1,000
​
Metadata filter limits
The following limits apply to
metadata filter expressions
used in query, delete, update, and fetch operations.
Limit
Value
Description
Maximum values per
$in
or
$nin
operator
10,000
Each
$in
or
$nin
operator accepts up to 10,000 values in its array. This limit applies per operator—if you have multiple
$in
operators in a single filter, each is independently limited to 10,000 values.
When you exceed this limit, the request will fail and return a
400 - BAD_REQUEST
error.
​
Rationale
Large
$in
operators can impact query performance and cost. Filters with thousands of values increase request payload size and end-to-end latency. Additionally, using large filters typically indicates a shared namespace architecture, which increases query costs—queries scan the entire namespace regardless of filters.
​
Alternative approaches
If you need to filter by more than 10,000 values, consider these alternatives:
Use namespaces for tenant isolation
: Instead of filtering by tenant IDs within a single namespace, create separate namespaces for each tenant or tenant group. This can also reduce query costs. See
Design for multi-tenancy
.
Use broader access control groups
: Instead of filtering by individual user IDs, filter by organization, project, or role. This reduces the number of values in your
$in
filter. See
Design for multi-tenancy
.
Post-filter client-side
: Retrieve a larger top K without filtering (for example, top 1000), then filter results client-side.
Run multiple queries
: Split your filter into multiple queries with smaller
$in
operators and combine the results client-side.
To avoid hitting this limit in production, validate the size of your
$in
and
$nin
arrays in your application code before making the request to Pinecone.
​
Identifier limits
An identifier is a string of characters used to identify “named”
objects in Pinecone
. The following Pinecone objects use strings as identifiers:
Object
Field
Max # characters
Allowed characters
Organization
name
512
UTF-8 except
\0
Cannot be empty
Project
name
512
UTF-8 except
\0
Cannot be empty
Index
name
45
a-z
,
0-9
, and
-
Must be lowercase
Cannot start or end with
-
Cannot be empty
Namespace
namespace
512
ASCII except
\0
For the default namespace, use
""
(or
"__default__"
, in API versions
2025-04
and later)
Record
id
512
ASCII except
\0
Cannot be empty
Was this page helpful?
Yes
No
Versioning
Known limitations
⌘
I
x
linkedin
youtube
github
Assistant
Responses are generated using AI and may contain mistakes.
