OpenSea APIopensea.io ↗
Query OpenSea collections, floor prices, NFT items, rarity ranks, and sale/transfer events via 4 structured API endpoints. No OpenSea account required.
What is the OpenSea API?
This API exposes 4 endpoints covering OpenSea collection search, detailed metadata and stats, item listings, and activity feeds. The get_collection endpoint returns floor price, volume figures (daily/weekly/monthly), owner count, token standard, and social links for any collection by slug. The get_collection_items endpoint adds per-NFT rarity rank, best listing, and owner data with cursor-based pagination.
curl -X GET 'https://api.parse.bot/scraper/0fc9c665-6fe2-4664-bcbd-e08c694bb070/search?limit=5&query=bored+ape&chains=ETHEREUM' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace opensea-io-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: OpenSea NFT API — search collections, inspect stats, browse items and activity."""
from parse_apis.opensea_nft_api import OpenSea, ItemSortBy, SortDirection, CollectionNotFound
client = OpenSea()
# Search for collections by keyword; limit= caps total items fetched.
for result in client.collectionsummaries.search(query="bored ape", limit=3):
print(result.name, result.chain, result.type)
# Drill into the first search result's full details via .details()
summary = client.collectionsummaries.search(query="pudgy penguins", limit=1).first()
if summary:
collection = summary.details()
print(collection.name, collection.is_verified, collection.chain)
if collection.stats:
print(collection.stats.total_supply, collection.stats.owner_count)
# Fetch a collection directly by slug and browse its cheapest items.
bayc = client.collections.get(slug="boredapeyachtclub")
for item in bayc.items(sort_by=ItemSortBy.PRICE, sort_direction=SortDirection.ASC, limit=3):
print(item.name, item.token_id, item.rarity_rank)
if item.best_listing:
print(item.best_listing.amount, item.best_listing.symbol)
# View recent activity (offers, sales, transfers) for the collection.
for event in bayc.activity(limit=3):
print(event.event_type, event.event_time)
if event.price:
print(event.price.amount, event.price.symbol, event.price.usd)
# Typed error handling: catch CollectionNotFound for an invalid slug.
try:
client.collections.get(slug="nonexistent-collection-xyz-99999")
except CollectionNotFound as exc:
print(f"Collection not found: {exc.slug}")
print("exercised: search / get_collection (details + direct) / items / activity + error handling")
Full-text search across OpenSea collections and currencies. Returns matching results with basic metadata including name, slug, chain, floor price for collections and USD price for currencies. Paginates via limit parameter only (no cursor).
| Param | Type | Description |
|---|---|---|
| limit | integer | Max results to return (max 50) |
| queryrequired | string | Search keyword |
| chains | string | Comma-separated chain filters (e.g. ETHEREUM,BASE,POLYGON) |
{
"type": "object",
"fields": {
"query": "string - the search query used",
"total": "integer - number of results returned",
"results": "array of search result objects with type, id, slug, name, chain, and type-specific fields"
},
"sample": {
"data": {
"query": "bored ape",
"total": 5,
"results": [
{
"id": "46188685bcac4206ace63c9d017abbb7",
"name": "Bored Ape Yacht Club",
"slug": "boredapeyachtclub",
"type": "Collection",
"chain": "ethereum",
"image_url": "https://i2c.seadn.io/collection/boredapeyachtclub/image/1a09c26b1c30427b26944c47fc7bb9/d81a09c26b1c30427b26944c47fc7bb9.png",
"floor_price": {
"usd": 14659.47,
"amount": 9,
"symbol": "ETH"
},
"is_verified": true,
"total_supply": 9998,
"one_day_floor_change": 0
}
]
},
"status": "success"
}
}About the OpenSea API
What the API Covers
Four endpoints address the main data surfaces on OpenSea: full-text collection search, per-collection metadata and stats, NFT item listings within a collection, and recent activity events. All endpoints return structured JSON with stable field names. Collection slugs (e.g. boredapeyachtclub) are the primary key used across get_collection, get_collection_items, and get_collection_activity.
Collection Search and Metadata
The search endpoint accepts a query string and optional chains filter (comma-separated values like ETHEREUM,BASE,POLYGON) and returns up to 50 results per call, each with type, slug, name, chain, and type-specific fields like floor price for collections or USD price for currencies. Pagination is limited-only — no cursor is provided, so deep pagination is not supported here.
The get_collection endpoint takes a single slug and returns a richer payload: stats (covering total_supply, owner_count, listed_item_count, and multiple volume intervals), floor_price with usd, amount, and symbol, top_offer, owner identity with display_name, address, and is_verified, and the collection's standard (e.g. ERC721). An invalid slug returns a stale_input response rather than a 404.
Items and Activity
get_collection_items lists NFTs within a collection with fields including token_id, contract_address, image_url, rarity_rank, best_listing, best_offer, and owner. It supports sort_by and sort_direction params and paginates via next_cursor. Up to 50 items are returned per page.
get_collection_activity returns recent events — sales, transfers, listings, and offers — sorted most-recent-first. Each event object includes event_type, event_time, price, from, to, item, and marketplace. Like items, it paginates via next_cursor with up to 50 events per page.
The OpenSea API is a managed, monitored endpoint for opensea.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when opensea.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official opensea.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Track floor price and volume trends for a set of collections using
get_collectionstats fields. - Build a rarity-sorted NFT browser using
get_collection_itemswithsort_byrarity andrarity_rankfields. - Monitor recent sales and transfers for a collection via
get_collection_activityevent feeds. - Discover collections on specific chains (e.g. BASE or POLYGON) using
searchwith thechainsfilter. - Cross-reference
top_offerandfloor_pricefromget_collectionto identify bid-ask spreads. - Aggregate
owner_countandlisted_item_countacross multiple collections to gauge market liquidity. - Identify newly listed items by combining
get_collection_activitylisting events with item-level pricing fromget_collection_items.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does OpenSea have an official developer API?+
What does `get_collection_activity` distinguish between event types?+
event_type field differentiates sales, transfers, listings, and offers. Each event also includes from and to addresses, an item object describing the NFT involved, and a price field. Events are sorted most-recent-first, and you can page through results using the next_cursor returned in each response.Can I filter `get_collection_items` by trait or price range?+
sort_by and sort_direction, but does not expose trait filters or price-range parameters. You can fork this API on Parse and revise it to add trait-based filtering as an additional input parameter.Does the `search` endpoint support cursor-based pagination for deep result sets?+
search — pagination is limited to controlling result count via the limit parameter (up to 50). For collection-level deep pagination, get_collection_items and get_collection_activity both return a next_cursor field. You can fork this API on Parse and revise the search endpoint to add offset or cursor support if your use case requires it.Is individual NFT data (outside of a collection context) accessible?+
get_collection_items endpoint does return per-token fields like token_id, contract_address, and rarity_rank within a collection context. You can fork this API on Parse and revise it to add a dedicated single-token lookup endpoint.