# OpenSea NFT Data Scraper (`aerodynamic_tripod/opensea-scraper`) Actor

Extract OpenSea NFT metadata, traits, images, collection stats, floor price, volume, sales, owners, and up to 1,000 NFTs per collection with automatic pagination.

- **URL**: https://apify.com/aerodynamic\_tripod/opensea-scraper.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🐧 OpenSea NFT Scraper

**OpenSea NFT Scraper** extracts structured NFT collection data, NFT metadata, traits, images, and collection statistics from OpenSea using collection URLs or collection slugs.

Use it for **NFT research, collection analysis, dataset building, automation, APIs, spreadsheets, and data pipelines** without manually browsing OpenSea.

- 🖼 **Collect NFT metadata:** token IDs, names, descriptions, images, metadata URLs, and OpenSea asset links
- 📊 **Analyze collection statistics:** floor price, total volume, total sales, and owner count
- 🧬 **Extract NFT traits:** structured trait arrays plus CSV-friendly text
- 🔗 **Preserve collection context:** collection name, slug, category, image, URL, and contract
- 📄 **Clean Dataset output:** one NFT is stored as one Apify Dataset row
- 🔁 **Automatic pagination:** request hundreds of NFTs without manually handling cursors
- ⚡ **Automation-ready:** use the Dataset through Apify API, exports, and integrations

***

### 📦 What data does OpenSea NFT Scraper extract?

| | |
| --- | --- |
| 🖼 **NFT image** | 🆔 **Token ID** |
| 🏷 **NFT name** | 📝 **NFT description** |
| 🔗 **OpenSea NFT URL** | 📜 **Contract address** |
| ⚙️ **Token standard** | 🧬 **NFT traits** |
| 🧾 **Traits text** | 🔗 **Metadata URL** |
| 🎞 **Animation URL** when available | 💵 **Estimated USD value** when available |
| 🚫 **Disabled status** | 🔞 **NSFW status** |
| 🕒 **NFT update timestamp** | 🐧 **Collection name** |
| 🔎 **Collection slug** | 🔗 **Collection URL** |
| 🖼 **Collection image** | 🏷 **Collection category** |
| Ξ **Floor price** | 💱 **Floor currency** |
| 📈 **Total collection volume** | 💱 **Volume currency** |
| 🧾 **Total collection sales** | 👥 **Owner count** |
| ➡️ **Has next page** | 🔁 **Next cursor** |
| 🕒 **Scrape timestamp** | 📥 **Original collection reference** |

> **Missing fields are returned as `null` when OpenSea does not provide them.** The Actor does not invent NFT or collection data.

***

### 🚀 Features

OpenSea NFT Scraper is designed for **NFT collection extraction and normalized NFT datasets**.

- **Collection URL or slug input**
- **Multiple collections in one run**
- **Up to 1,000 NFT items per collection**
- **Automatic cursor pagination**
- **One NFT per Dataset row**
- **Collection statistics repeated on every NFT row for easy exports**
- **Raw structured NFT traits**
- **CSV-friendly `traitsText`**
- **NFT and collection image URLs**
- **OpenSea NFT and collection links**
- **Predictable normalized Dataset schema**
- **Partial failure protection between collections**
- **Apify API-friendly output**
- **HTTP/API-first architecture without browser automation for the normal collection workflow**

***

## ⬇️ Input

You can configure OpenSea NFT Scraper directly from the **Apify Console** or send input programmatically through the **Apify API**.

### 🐧 OpenSea collection URLs or slugs

Use either a collection slug:

```text
pudgypenguins
```

or a full OpenSea collection URL:

```text
https://opensea.io/collection/pudgypenguins
```

You can provide multiple collections:

```text
pudgypenguins
azuki
doodles-official
```

Each collection is processed independently.

***

### 🔢 Maximum NFT Items

Set the total maximum number of NFTs to return **per collection**.

```text
Minimum: 1
Default: 20
Maximum: 1000
```

Example:

```text
Collection:
pudgypenguins

Maximum NFT Items:
250
```

can return up to:

```text
250 Dataset rows
```

The requested number is a **maximum, not a guarantee**. If OpenSea returns fewer available NFT items, the Actor stops naturally instead of generating fake records.

***

### 🧪 Example input

```json
{
  "collectionReferences": [
    "pudgypenguins"
  ],
  "maxItems": 250
}
```

Multiple collections:

```json
{
  "collectionReferences": [
    "https://opensea.io/collection/pudgypenguins",
    "https://opensea.io/collection/azuki"
  ],
  "maxItems": 100
}
```

With two collections and `maxItems: 100`, the Actor can return up to:

```text
100 NFTs from collection 1
+
100 NFTs from collection 2
=
200 Dataset rows
```

***

## ⬆️ Output

Results are stored in the Actor's default **Apify Dataset**.

You can access results from:

```text
Output
Storage
Apify API
Integrations
Export
```

Each successful Dataset row represents **one NFT**.

This structure works well for:

```text
JSON
CSV
Excel
Databases
Data warehouses
Google Sheets
Make
Zapier
AI workflows
Custom applications
```

***

### 📊 Example result

```json
{
  "collectionReference": "pudgypenguins",
  "slug": "pudgypenguins",
  "collectionName": "Pudgy Penguins",
  "collectionUrl": "https://opensea.io/collection/pudgypenguins",
  "collectionImageUrl": "https://i2c.seadn.io/collection/...",
  "category": "pfps",
  "floorPrice": 3.80399999,
  "floorCurrency": "ETH",
  "totalVolume": 520657.3285229603,
  "volumeCurrency": "ETH",
  "totalSales": 92084,
  "owners": 5085,
  "tokenId": "8887",
  "nftName": "Pudgy Penguin #8887",
  "nftDescription": "A collection 8888 Cute Chubby Pudgy Penquins sliding around on the freezing ETH blockchain.",
  "nftUrl": "https://opensea.io/assets/ethereum/0xbd3531da5cf5857e7cfaa92426877b022e612cf8/8887",
  "nftImageUrl": "https://i2c.seadn.io/ethereum/...",
  "contract": "0xbd3531da5cf5857e7cfaa92426877b022e612cf8",
  "tokenStandard": "erc721",
  "metadataUrl": "https://opensea-private.mypinata.cloud/ipfs/...",
  "animationUrl": null,
  "traits": [
    {
      "trait_type": "Body",
      "display_type": null,
      "max_value": null,
      "value": "Puffer Green"
    },
    {
      "trait_type": "Background",
      "display_type": null,
      "max_value": null,
      "value": "Blue"
    }
  ],
  "traitsText": "Body: Puffer Green, Background: Blue",
  "estimatedValueUsd": null,
  "isNsfw": false,
  "isDisabled": false,
  "nftUpdatedAt": "2026-09-07T06:33:29.473903",
  "hasNextPage": true,
  "nextCursor": "WyIyMDIxLTA3LTIyVDIwOjE4OjE0WiIs...",
  "observedAt": "2026-09-07T06:33:29.865Z"
}
```

***

### 🧬 NFT traits

The Actor returns NFT traits in two formats.

#### Structured traits

```json
[
  {
    "trait_type": "Body",
    "value": "Puffer Green"
  },
  {
    "trait_type": "Background",
    "value": "Blue"
  }
]
```

Useful for:

```text
Databases
JSON APIs
Trait filtering
Rarity research
Data science
Custom applications
```

#### Traits text

The same traits are also returned in:

```text
traitsText
```

Example:

```text
Body: Puffer Green, Face: Handlebar Bear, Head: Flat Cap Tan, Skin: Olive Green, Background: Blue
```

Useful for:

```text
CSV
Excel
Google Sheets
Simple automation workflows
```

***

### 📊 Collection statistics

Each NFT row includes collection-level statistics observed during the same run:

```text
floorPrice
floorCurrency
totalVolume
volumeCurrency
totalSales
owners
```

These values are repeated on every NFT row intentionally so exported data remains self-contained.

> Collection statistics can change over time. They represent the values observed during that Actor run.

***

### 📄 Pagination

OpenSea NFT Scraper automatically handles **cursor-based pagination**.

The Actor continues until:

- 🎯 the requested `maxItems` total is reached
- 📭 OpenSea returns no additional NFT items
- ⛔ OpenSea stops returning a next cursor
- ⚠️ a request fails
- 🛡 the current 1,000-NFT-per-collection Actor limit is reached

Example:

```text
Requested total: 250 NFTs
```

The Actor can fetch multiple API pages and combine them into:

```text
250 NFT Dataset rows
```

You do not need to manually provide or manage OpenSea pagination cursors.

***

### ➡️ `hasNextPage` and `nextCursor`

Every returned NFT row includes:

```text
hasNextPage
nextCursor
```

These describe whether OpenSea indicated that more NFT results remained after the final page fetched for the requested batch.

Example:

```json
{
  "hasNextPage": true,
  "nextCursor": "WyIyMDIxLTA3LTIyVDIwOjE4OjE0WiIs..."
}
```

***

### 🔍 Multiple collections

Example:

```json
{
  "collectionReferences": [
    "pudgypenguins",
    "azuki",
    "doodles-official"
  ],
  "maxItems": 100
}
```

Each collection is processed independently.

Every NFT row preserves:

```text
collectionReference
slug
collectionName
collectionUrl
```

so downstream systems can identify the source collection.

***

### 🧹 Dataset structure

The Actor uses:

```text
1 NFT = 1 Dataset row
```

So:

```text
250 NFTs
```

returns up to:

```text
250 Dataset rows
```

instead of putting hundreds of NFTs inside one nested Dataset item.

This makes results easier to:

```text
Filter
Sort
Export
Search
Analyze
Store
Transform
Automate
```

***

### ⚡ Performance

OpenSea NFT Scraper uses an **HTTP/API-first architecture**.

It communicates with OpenSea data endpoints without launching browser automation for the normal collection workflow.

Benefits include:

```text
Fast startup
Low browser overhead
Lower memory requirements
Structured API responses
Efficient pagination
Clean Dataset output
```

A verified Actor test requested 250 Pudgy Penguins NFT items and returned **250 separate Dataset rows**.

Actual runtime can vary depending on the requested NFT count, number of collections, OpenSea response time, and Apify platform conditions.

***

### 🛡 Reliability

Each collection is processed independently.

If one collection fails, successful results from other collections can remain in the Dataset.

Failed collection rows include available context such as:

```text
collectionReference
slug
observedAt
error
```

Invalid OpenSea collection URLs are handled without fabricating data.

***

## 🔌 API & integrations

OpenSea NFT Scraper can be used programmatically through the **Apify API**.

Connect results to workflows such as:

- Google Sheets
- Make
- Zapier
- Airtable
- Databases
- Data warehouses
- Internal APIs
- NFT analytics tools
- Research pipelines
- AI agents
- MCP workflows
- Custom dashboards

Every Actor run stores structured NFT results in the default Apify Dataset.

***

## 💡 Example use cases

#### 📊 NFT collection research

Analyze:

```text
Floor price
Collection volume
Total sales
Owner count
NFT names
Token IDs
Traits
Images
Contracts
```

***

#### 🧬 Trait analysis

Use the raw `traits` array or `traitsText` to study:

```text
Trait frequency
Trait combinations
Background distribution
Body types
Head traits
Skin traits
Other collection-specific attributes
```

***

#### 📈 Collection monitoring

Run the Actor at different times and compare:

```text
Floor price
Total volume
Sales
Owner count
NFT metadata changes
```

Use `observedAt` to identify when the dataset was collected.

***

#### 🗃 NFT dataset building

Build datasets for:

```text
Machine learning
Research
Analytics
Search systems
Recommendation systems
Data enrichment
NFT dashboards
Internal databases
```

***

#### ⚙️ Automation workflows

Send one-NFT-per-row data to:

```text
Make
Zapier
Google Sheets
Data warehouses
Internal services
Custom APIs
AI systems
```

***

## ⚠️ Current limitations

The current version focuses on **collection NFT extraction and normalized NFT metadata**.

It does **not currently provide dedicated modes for**:

```text
Wallet portfolio scraping
Wallet activity history
Individual account profiles
NFT ownership history
Full sale-event history
Bid history
Offer history
Listing history
Marketplace order execution
NFT buying or selling
Trait rarity scoring
Cross-marketplace price comparison
Historical floor-price charts
Automatic image downloading
More than 1,000 NFTs per collection in one run
```

The current Actor is intentionally focused on reliable collection NFT data rather than combining every OpenSea feature into one workflow.

***

## ❓ FAQ

### How does OpenSea NFT Scraper work?

The Actor:

```text
Accepts collection URLs or slugs
Resolves the collection slug
Fetches collection information
Fetches collection statistics
Fetches NFT items
Follows pagination cursors when needed
Normalizes NFT metadata
Creates one Dataset row per NFT
Stores results in Apify Dataset
```

***

### How many NFTs can I scrape?

Current input range:

```text
Minimum: 1 per collection
Default: 20 per collection
Maximum: 1000 per collection
```

The requested value is a maximum. If fewer NFT items are available, the Actor returns fewer rows.

***

### Can I scrape more than 200 NFTs?

**Yes.**

Pagination is automatic.

For example:

```json
{
  "collectionReferences": ["pudgypenguins"],
  "maxItems": 250
}
```

can return:

```text
250 Dataset rows
```

without manually providing a cursor.

***

### Can I scrape multiple collections in one run?

**Yes.**

Example:

```json
{
  "collectionReferences": [
    "pudgypenguins",
    "azuki"
  ],
  "maxItems": 100
}
```

***

### Can I use full OpenSea collection URLs?

**Yes.**

Supported:

```text
pudgypenguins
```

and:

```text
https://opensea.io/collection/pudgypenguins
```

***

### Why are some fields null?

OpenSea does not expose every field for every NFT.

For example:

```text
animationUrl
estimatedValueUsd
metadataUrl
```

can be unavailable.

The Actor returns `null` instead of inventing missing values.

***

### Why is collection data repeated on every NFT row?

This is intentional.

Fields such as:

```text
collectionName
floorPrice
totalVolume
totalSales
owners
```

are repeated so each exported NFT row is self-contained.

***

### What does `traitsText` contain?

It converts structured NFT traits into readable text.

Example:

```text
Body: Puffer Green, Face: Handlebar Bear, Head: Flat Cap Tan, Skin: Olive Green, Background: Blue
```

The raw `traits` array is still included.

***

### What does `hasNextPage` mean?

`hasNextPage: true` means OpenSea indicated that more results remained beyond the final batch fetched in the current run.

The corresponding cursor is stored in:

```text
nextCursor
```

***

### Can I export the results?

Yes.

Apify Dataset supports exports such as:

```text
JSON
CSV
Excel
XML
HTML
```

***

### Can I use the scraper through an API?

Yes.

The Actor can be started through the **Apify API**, and its Dataset can be accessed programmatically.

***

### Does the Actor use browser automation?

Not for the normal collection workflow.

The current Actor uses an HTTP/API-first approach.

***

### Does it buy, sell, or transfer NFTs?

**No.**

This Actor is for **data extraction and analysis** only.

***

## 🧭 Recommended workflow

Start with a small test:

```json
{
  "collectionReferences": [
    "pudgypenguins"
  ],
  "maxItems": 20
}
```

Verify the fields you need, then increase the amount:

```json
{
  "collectionReferences": [
    "pudgypenguins"
  ],
  "maxItems": 250
}
```

Remember that `maxItems` is applied **per collection**.

Example:

```text
3 collections
×
250 NFTs maximum each
=
up to 750 Dataset rows
```

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Potential future additions:

```text
Wallet mode
Activity/event mode
Collection history
Listings
Offers
Sales history
Trait rarity analysis
More configurable output modes
Higher per-collection limits
Additional NFT marketplace intelligence
```

***

### 🚀 OpenSea NFT data without the manual searching

Enter one or more OpenSea collection URLs or slugs, choose how many NFT items you want, run the Actor, and receive **structured OpenSea NFT data** ready for **research, analytics, APIs, automation, spreadsheets, and data pipelines**.

# Actor input Schema

## `collectionReferences` (type: `array`):

Enter one or more OpenSea collection URLs or slugs.

## `maxItems` (type: `integer`):

Total maximum number of NFT items to return per collection. Pagination is handled automatically.

## Actor input object example

```json
{
  "collectionReferences": [
    "pudgypenguins"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/opensea-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/opensea-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call aerodynamic_tripod/opensea-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aerodynamic_tripod/opensea-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Dx0x31XjzHHeIPTFI/builds/XaVsvAVCqf6EQhUIs/openapi.json