# Coinbase Exchange Products Scraper (`parseforge/coinbase-exchange-products-scraper`) Actor

Scrape every spot trading product on Coinbase Exchange (Advanced Trade) plus live ticker and 24h stats per product. Returns base/quote, increments, last price, bid/ask, 24h high/low/open/volume. No API key required.

- **URL**: https://apify.com/parseforge/coinbase-exchange-products-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $23.25 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/raw/main/banner.jpg)

## 🪙 Coinbase Exchange Products Scraper

> 🚀 **Export every spot product on Coinbase Exchange in seconds.** Pull the full Coinbase Exchange (Advanced Trade) product catalog plus a live ticker and 24h stats per pair: **last price, bid, ask, 24h high/low/open, 24h volume, 30-day volume, percent change**. No API key, no OAuth, no manual aggregation.

> 🕒 **Last updated:** 2026-05-13 · **📊 28 fields** per product · **🪙 700+ active products** · **💵 Spot only (USD, EUR, GBP, USDT, USDC, BTC, ETH quotes)**

The **Coinbase Exchange Products Scraper** queries Coinbase Exchange's public `products`, `ticker`, and `stats` endpoints. It returns the full product catalog with base/quote currencies, base/quote increments, status flags (online, offline, internal, delisted), margin/post-only/limit-only/cancel-only flags, and (optionally) a live ticker with bid/ask plus 24h open/high/low/volume and 30-day volume. Sort by 24h volume, last price, or product ID; filter to a single quote currency; or pull the lot.

Filters cover the same dimensions the Coinbase Pro web app exposes: status (`online`/`offline`/`internal`/`delisted`) and quote currency (USD, EUR, GBP, USDT, USDC, BTC, ETH). The `fetchDetails` toggle decides whether the run enriches each product with live ticker + 24h stats (slower, but adds 11 trading metrics per product). Download CSV, Excel, JSON, or XML.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Crypto traders, fintech apps, treasury teams, market-data engineers, quant analysts, portfolio dashboards, exchange aggregators | Spot tickers, market coverage audits, listing tracking, 24h leaderboard dashboards, treasury rebalance pricing, exchange-comparison feeds |

---

### 📋 What the Coinbase Exchange Products Scraper does

Four workflows in a single run:

- 🪙 **Full catalog dump.** Every Coinbase Exchange spot product with base/quote, increments, status, and trade flags.
- 💵 **Quote-currency filter.** Restrict to USD, EUR, GBP, USDT, USDC, BTC, or ETH pairs.
- ⚙️ **Status filter.** Filter to `online`, `offline`, `internal`, or `delisted` products.
- 📊 **Live ticker + 24h stats.** Optional enrichment that adds last price, bid, ask, 24h open/high/low/volume, 30-day volume, and percent change.
- 🔽 **Sort.** 24h volume, last price, or product ID before the maxItems slice.

Each product record carries the product ID (e.g. `BTC-USD`), display name, base/quote symbols, status flags, increments, last trade ID and timestamp, and (when enrichment is on) full 24h trading statistics with computed percent change.

> 💡 **Why it matters:** Coinbase Exchange supports hundreds of spot pairs across multiple quote currencies. Manually pulling and joining `products`, `ticker`, and `stats` endpoints is tedious. This Actor does the joins, normalizes types, and ships clean records ready for dashboards, alerts, or treasury systems.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to pull every USD-quoted product, sort by 24h volume, and pipe results into Google Sheets._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>quoteCurrency</code></td><td>string (enum)</td><td><code>""</code></td><td>Filter by quote currency. Options: USD, EUR, GBP, USDT, USDC, BTC, ETH. Empty = all.</td></tr>
<tr><td><code>statusFilter</code></td><td>string (enum)</td><td><code>"online"</code></td><td>One of online, offline, internal, delisted. Empty = all.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>fetchDetails</code></td><td>boolean</td><td><code>true</code></td><td>If true, calls ticker + stats per product. Adds 11 live trading fields. Slower.</td></tr>
<tr><td><code>sortBy</code></td><td>string (enum)</td><td><code>""</code></td><td>Order before maxItems. Options: volume24h, priceLast, id.</td></tr>
</tbody>
</table>

**Example: top 50 USD-quoted products by 24h volume with full ticker enrichment.**

```json
{
    "quoteCurrency": "USD",
    "statusFilter": "online",
    "maxItems": 50,
    "fetchDetails": true,
    "sortBy": "volume24h"
}
````

**Example: full product catalog, no enrichment, A to Z.**

```json
{
    "maxItems": 1000,
    "fetchDetails": false,
    "sortBy": "id"
}
```

> ⚠️ **Good to Know:** `fetchDetails: true` calls 2 extra endpoints per product. A 100-product run takes ~15 seconds, 1,000 products takes a few minutes. Disable when you only need the static catalog.

***

### 📊 Output

Each product record contains up to **28 fields** (17 catalog + 11 trading metrics when `fetchDetails` is on). Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"BTC-USD"` |
| 🔗 `url` | string | `"https://exchange.coinbase.com/trade/BTC-USD"` |
| 🏷️ `displayName` | string | `"BTC/USD"` |
| 🪙 `base` | string | `"BTC"` |
| 💵 `quote` | string | `"USD"` |
| 🚦 `status` | string | `"online"` |
| ✉️ `statusMessage` | string (optional) | `"Trading temporarily disabled..."` |
| 🚫 `tradingDisabled` | boolean | `false` |
| 💼 `marginEnabled` | boolean | `false` |
| 📌 `postOnly` | boolean | `false` |
| 📌 `limitOnly` | boolean | `false` |
| 📌 `cancelOnly` | boolean | `false` |
| 🔨 `auctionMode` | boolean | `false` |
| 💲 `fxStablecoin` | boolean | `false` |
| 🔢 `baseIncrement` | number | null | `0.00000001` |
| 🔢 `quoteIncrement` | number | null | `0.01` |
| 💸 `minMarketFunds` | number | null | `1` |
| 📉 `maxSlippagePercentage` | number | null | `0.03` |
| 💵 `priceLast` | number | null | `60000.00` |
| 📊 `bid` | number | null | `59999.00` |
| 📊 `ask` | number | null | `60001.00` |
| 📦 `lastTradeSize` | number | null | `0.05` |
| 🆔 `lastTradeId` | number | null | `22180491` |
| 🕒 `lastTradeTime` | ISO 8601 | `"2026-05-13T22:10:07.828Z"` |
| ⏰ `open24h` | number | null | `59000.00` |
| 🔺 `high24h` | number | null | `61000.00` |
| 🔻 `low24h` | number | null | `58500.00` |
| 📊 `volume24h` | number | null | `1582294.68` |
| 📊 `volume30day` | number | null | `248042581.61` |
| 📈 `priceChange24h` | number | null | `1000.00` |
| 📈 `priceChangePercent24h` | number | null | `1.6949` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T22:20:57.467Z"` |

#### 📦 Sample records

<details>
<summary><strong>🪙 DEXT/USD with live ticker + stats</strong></summary>

```json
{
    "id": "DEXT-USD",
    "url": "https://exchange.coinbase.com/trade/DEXT-USD",
    "displayName": "DEXT-USD",
    "base": "DEXT",
    "quote": "USD",
    "status": "online",
    "tradingDisabled": false,
    "marginEnabled": false,
    "baseIncrement": 0.1,
    "quoteIncrement": 0.0001,
    "minMarketFunds": 1,
    "maxSlippagePercentage": 0.05,
    "priceLast": 0.1218,
    "bid": 0.1216,
    "ask": 0.1239,
    "lastTradeSize": 226.3,
    "lastTradeId": 622781,
    "lastTradeTime": "2026-05-13T21:01:00.524149632Z",
    "open24h": 0.1211,
    "high24h": 0.1251,
    "low24h": 0.1196,
    "volume24h": 52952.3,
    "volume30day": 13473611.9,
    "priceChange24h": 0.0007,
    "priceChangePercent24h": 0.578,
    "scrapedAt": "2026-05-13T22:20:57.467Z"
}
```

</details>

<details>
<summary><strong>🐸 MOG/USD micro-cap with 9-decimal pricing</strong></summary>

```json
{
    "id": "MOG-USD",
    "url": "https://exchange.coinbase.com/trade/MOG-USD",
    "displayName": "MOG/USD",
    "base": "MOG",
    "quote": "USD",
    "status": "online",
    "baseIncrement": 1,
    "quoteIncrement": 1e-08,
    "priceLast": 1.6e-07,
    "bid": 1.6e-07,
    "ask": 1.7e-07,
    "open24h": 1.7e-07,
    "high24h": 1.8e-07,
    "low24h": 1.6e-07,
    "volume24h": 1965451017782,
    "volume30day": 61084741567017,
    "priceChange24h": -1e-08,
    "priceChangePercent24h": -5.8824,
    "scrapedAt": "2026-05-13T22:20:57.467Z"
}
```

</details>

<details>
<summary><strong>🦍 APE/USD with bid/ask and 24h stats</strong></summary>

```json
{
    "id": "APE-USD",
    "url": "https://exchange.coinbase.com/trade/APE-USD",
    "displayName": "APE-USD",
    "base": "APE",
    "quote": "USD",
    "status": "online",
    "baseIncrement": 0.01,
    "quoteIncrement": 0.001,
    "priceLast": 0.147,
    "bid": 0.147,
    "ask": 0.148,
    "open24h": 0.158,
    "high24h": 0.16,
    "low24h": 0.146,
    "volume24h": 1582294.68,
    "volume30day": 248042581.61,
    "priceChange24h": -0.011,
    "priceChangePercent24h": -6.962,
    "scrapedAt": "2026-05-13T22:20:57.467Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🪙 | **Full product catalog.** Every spot product Coinbase Exchange supports, with base/quote, increments, and trade flags. |
| 📊 | **Live ticker + 24h stats.** Optional enrichment adds bid/ask, 24h OHLV, 30-day volume, and computed percent change. |
| 💵 | **7 quote-currency filters.** USD, EUR, GBP, USDT, USDC, BTC, ETH. |
| 🚦 | **Status-aware.** Filter to online, offline, internal, or delisted (great for tracking listings/delistings). |
| ⚡ | **Concurrent enrichment.** 8 parallel ticker+stats calls. 100 products in ~15 seconds. |
| 🔁 | **Always fresh.** Every run hits live endpoints. No caching. |
| 🚫 | **No API key.** Works against Coinbase's public exchange endpoints. |

> 📊 Coinbase Exchange is a benchmark venue for crypto pricing. Clean, normalized product data is the foundation of every trading dashboard, fintech onboarding flow, and treasury rebalance pipeline.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Coinbase Exchange Products Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **700+ products** | **Live per run** | quote, status, sort, fetchDetails | ⚡ 2 min |
| Coinbase Exchange web app | Free | Same | Live | Manual click-through | 🐢 Browser only |
| Coinbase Advanced Trade API direct | Free | Same | Live | None - you write code | 🛠️ Hours |
| Aggregator APIs (CoinGecko, CMC) | Free or paid | Cross-exchange | Often delayed | Varies | ⏳ Multi-step |

Pick this Actor when you want clean, joined product + ticker + stats data with one click.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Coinbase Exchange Products Scraper on the Apify Store.
3. 🎯 **Set input.** Pick a quote currency or status filter, toggle `fetchDetails`, and set `maxItems`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab CSV, Excel, JSON, or XML from the **Dataset** tab.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 💼 Trading & Quant

- 24h volume leaderboards on USD-quoted pairs
- Bid/ask spread snapshots across the venue
- Coinbase-vs-other-exchange arbitrage scans
- Backtest universes from current product lists

</td>
<td width="50%" valign="top">

#### 🏦 Treasury & Finance

- Pull current bid/ask for treasury swap pricing
- Track 30-day volume for liquidity tiering
- Audit which quote currencies your treasury can land in
- Verify a product's status before placing orders

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Market Data & Aggregators

- Daily product-catalog snapshots for changelog
- Detect new listings or delistings as they happen
- Cross-exchange product mapping
- Feed downstream tickers into a multi-venue index

</td>
<td width="50%" valign="top">

#### 🚨 Apps, Alerts & Dashboards

- Power autocomplete with the live product list
- Build "top movers" widgets per quote currency
- Slack/Discord bots for big % movers
- Onboarding flows that show real bid/ask quotes

</td>
</tr>
</table>

***

### 🔌 Automating Coinbase Exchange Products Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Minute-level for trading dashboards, hourly for analytics, or daily for catalog snapshots.

***

### 🌟 Beyond business use cases

The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical studies on listing/delisting price impact
- Spread/depth analysis across quote currencies
- Reproducible event studies on Coinbase listings
- Coursework on crypto market microstructure

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, indie trading apps, portfolio dashboards
- "What's listed on Coinbase right now?" Twitter bots
- Travel-funding portfolio rebalancers
- Hobbyist research on coin coverage trends

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency dashboards on crypto-asset coverage
- Investigative journalism on listing patterns
- DAO treasury monitoring with clean public data
- Open data contributions on listings history

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on cross-exchange price signals
- Prototype on-chain + CEX arbitrage agents
- Test dashboard concepts with real ticker feeds
- Build personal "favorite pairs" widgets

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Coinbase%20Exchange%20Products%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Coinbase%20Exchange%20Products%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Coinbase%20Exchange%20Products%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Coinbase%20Exchange%20Products%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

The Actor calls Coinbase Exchange's public `products` endpoint, filters by quote currency and status, and (when `fetchDetails` is on) hits `ticker` and `stats` per product in parallel. Each product gets one clean record with catalog data plus live trading metrics.

#### 🪙 Which markets are covered?

Coinbase Exchange (formerly Coinbase Pro / Advanced Trade) spot products only. Derivatives and futures are not in scope. Quote currencies enumerated: USD, EUR, GBP, USDT, USDC, BTC, ETH.

#### ⚙️ What does `fetchDetails` actually add?

11 live trading fields: `priceLast`, `bid`, `ask`, `lastTradeSize`, `lastTradeId`, `lastTradeTime`, `open24h`, `high24h`, `low24h`, `volume24h`, `volume30day`, plus computed `priceChange24h` and `priceChangePercent24h`. Disabling it leaves only the static catalog (faster).

#### 🚫 Do I need an API key?

No. The Actor uses Coinbase's public exchange API. No key, no OAuth, no signing.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (minute, hour, day). Great for keeping a downstream database in sync.

#### 🔁 How fresh is the data?

Every run hits live endpoints. Ticker and stats reflect the moment of the call, not a cached snapshot.

#### 📉 Why is `priceChangePercent24h` sometimes negative?

It is the percent change from `open24h` to `priceLast`. Negative means the price has fallen over the last 24 hours.

#### 🛑 What does status `internal` mean?

Coinbase reserves a few products for internal routing or testing. They are not tradable by retail. Filter them out with `statusFilter: "online"`.

#### 🔁 What happens if a run fails?

Apify retries transient errors automatically. If a run still fails, inspect the log, adjust input, and re-run. Partial datasets are preserved.

#### 💳 Do I need a paid Apify plan?

No. Free plan covers 10 records per run. Paid plans unlock up to 1,000,000 items and scheduling.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Coinbase Exchange Products Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Pipe price alerts into channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Land catalog + ticker data in your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from CI events
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🏦 Binance Crypto Prices Scraper**](https://apify.com/parseforge/binance-prices-scraper) - Live spot tickers on the largest CEX
- [**🐙 Kraken Crypto Exchange Scraper**](https://apify.com/parseforge/kraken-exchange-scraper) - Kraken spot + USD/EUR quotes
- [**🦎 CoinGecko Cryptocurrency Scraper**](https://apify.com/parseforge/coingecko-scraper) - Cross-exchange aggregated coin data
- [**📊 Bitfinex Crypto Tickers Scraper**](https://apify.com/parseforge/bitfinex-tickers-scraper) - Bitfinex spot tickers with deep history
- [**💱 Yahoo Finance Stock & Crypto Scraper**](https://apify.com/parseforge/yahoo-finance-scraper) - Cross-asset quotes for crypto and equities

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more crypto exchange scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Coinbase Global, Inc. All trademarks mentioned are the property of their respective owners. Only publicly available product, ticker, and stats data exposed by the Coinbase Exchange public API is collected. This Actor is for informational use only and does not constitute financial advice.

# Actor input Schema

## `quoteCurrency` (type: `string`):

Filter products by quote currency. Leave empty for all products.

## `statusFilter` (type: `string`):

Only include products with this status.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `fetchDetails` (type: `boolean`):

If enabled, calls ticker and stats endpoints per product. Adds last price, bid, ask, 24h volume, 24h high/low/open. Slower.

## `sortBy` (type: `string`):

Order results before applying maxItems.

## Actor input object example

```json
{
  "quoteCurrency": "",
  "statusFilter": "online",
  "maxItems": 10,
  "fetchDetails": true,
  "sortBy": ""
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "quoteCurrency": "",
    "statusFilter": "online",
    "maxItems": 10,
    "fetchDetails": true,
    "sortBy": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/coinbase-exchange-products-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 = {
    "quoteCurrency": "",
    "statusFilter": "online",
    "maxItems": 10,
    "fetchDetails": True,
    "sortBy": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/coinbase-exchange-products-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "quoteCurrency": "",
  "statusFilter": "online",
  "maxItems": 10,
  "fetchDetails": true,
  "sortBy": ""
}' |
apify call parseforge/coinbase-exchange-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/coinbase-exchange-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coinbase Exchange Products Scraper",
        "description": "Scrape every spot trading product on Coinbase Exchange (Advanced Trade) plus live ticker and 24h stats per product. Returns base/quote, increments, last price, bid/ask, 24h high/low/open/volume. No API key required.",
        "version": "0.0",
        "x-build-id": "X0pQTKCkCNp42s14r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~coinbase-exchange-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-coinbase-exchange-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~coinbase-exchange-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-coinbase-exchange-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~coinbase-exchange-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-coinbase-exchange-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "quoteCurrency": {
                        "title": "Quote Currency Filter",
                        "enum": [
                            "",
                            "USD",
                            "EUR",
                            "GBP",
                            "USDT",
                            "USDC",
                            "BTC",
                            "ETH"
                        ],
                        "type": "string",
                        "description": "Filter products by quote currency. Leave empty for all products.",
                        "default": ""
                    },
                    "statusFilter": {
                        "title": "Status Filter",
                        "enum": [
                            "",
                            "online",
                            "offline",
                            "internal",
                            "delisted"
                        ],
                        "type": "string",
                        "description": "Only include products with this status.",
                        "default": "online"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "fetchDetails": {
                        "title": "Fetch Live Ticker + 24h Stats",
                        "type": "boolean",
                        "description": "If enabled, calls ticker and stats endpoints per product. Adds last price, bid, ask, 24h volume, 24h high/low/open. Slower.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "",
                            "volume24h",
                            "priceLast",
                            "id"
                        ],
                        "type": "string",
                        "description": "Order results before applying maxItems.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
