# Twelve Data Cryptocurrency Pairs Scraper (`acquistion-automation/twelve-data-cryptocurrency-pairs-scraper`) Actor

Scrapes cryptocurrency pair listings from the Twelve Data API. Returns each pair as a flat row with symbol, currency\_base, currency\_quote, and available\_exchanges. Supports an optional symbol filter and exports to JSON, CSV, Excel, or XML.

- **URL**: https://apify.com/acquistion-automation/twelve-data-cryptocurrency-pairs-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.62 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![Acquisition Automation](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)](https://apify.com/acquistion-automation)

### Twelve Data Cryptocurrency Pairs Scraper

**Scrape cryptocurrency pairs from Twelve Data, up to a million symbols per run.** Every pair comes with its base and quote currency, available exchanges, and the full symbol string. No browser needed, an API key.

Twelve Data's cryptocurrency pairs endpoint lists every supported trading pair across hundreds of exchanges. This Actor calls that endpoint directly, lets you filter by symbol, and returns each matching pair as a clean row. It is the fastest way to get a machine-readable catalog of crypto pairs for market surveillance or exchange mapping.

| Who uses it | What they scrape Twelve Data for |
|---|---|
| Quantitative traders | Build a universe of tradeable pairs for backtesting strategies. |
| Exchange operators | Audit which pairs competitors list and on which venues. |
| Market data resellers | Normalize crypto pair identifiers across dozens of exchanges. |
| Crypto index providers | Determine constituent eligibility by checking exchange availability. |

### What it does

This Actor collects cryptocurrency pair listings from the Twelve Data API and returns each one as a flat row with its symbol, base currency, quote currency, and available exchanges.

- 📋 **Full catalog dump:** Pull every cryptocurrency pair Twelve Data supports, up to a million rows.
- 🔍 **Symbol filter:** Pass a single symbol like BTC/USD to retrieve only that pair's details.
- ⚡ **Direct API access:** Reads the verified REST endpoint with a simple GET request, no headless browser overhead.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Twelve Data data

**📊 Map exchange coverage.**

A data analyst pulls all pairs and pivots on available\_exchanges to see which venues list the most altcoins, then prioritizes integration work.

**🔗 Normalize pair identifiers.**

A backend engineer runs the scraper weekly, stores symbol, base, and quote in a lookup table, and uses it to translate between exchange-specific ticker formats.

**🧪 Audit new listings.**

A crypto fund runs the Actor daily with a high maxItems, diffs the output against the previous day, and flags newly added pairs for fundamental review.

**📈 Feed a trading universe.**

A quant researcher pulls the full catalog, filters for pairs available on at least three major exchanges, and uses the list as the starting universe for a momentum strategy.

### Why choose this scraper

| | What you get |
|---|---|
| **Exchange coverage** | See every exchange where a pair is traded, returned as an array of exchange names. |
| **Base and quote** | Get the currency\_base and currency\_quote for every symbol, ready for database joins. |
| **Flat output** | Each pair is one row in JSON, CSV, Excel, or XML, no nested parsing required. |
| **Free tier preview** | Free Apify users can pull up to 10 pairs to test the schema before scaling. |

### What a Twelve Data record looks like

Every record returns as one flat JSON row. Here is a real one from a run:

```json
{
 "symbol": "0xBTC/USD",
 "availableExchanges": "Synthetic",
 "currencyBase": "0xBitcoin",
 "currencyQuote": "US Dollar",
 "scrapedAt": "2026-09-26T10:15:33.189Z"
}
```

Every value above comes from a real run. A field a record does not have comes back as `null`.

### Configure the run

Drive the Actor with an optional symbol filter and a max items cap. The symbol filter runs server-side on the Twelve Data API, so only matching pairs count toward your usage. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up).
2. Open the [Twelve Data Cryptocurrency Pairs Scraper](https://apify.com/acquistion-automation/twelve-data-cryptocurrency-pairs-scraper).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Twelve Data through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/twelve-data-cryptocurrency-pairs-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**I get an authentication error.**

Confirm your Twelve Data API key is valid and has not expired. Check your Twelve Data dashboard to ensure your plan includes the cryptocurrencies endpoint.

**The run returns only 10 items even though I set a higher maxItems.**

You are likely on the Apify free plan, which caps results at 10 items for preview. Upgrade to a paid Apify plan to unlock the full maxItems range.

**My symbol filter returns no results.**

Verify the symbol format. Twelve Data uses a slash separator like BTC/USD, not a dash. Check the Twelve Data documentation for the exact symbol string.

**The available\_exchanges array is empty for some pairs.**

This is expected. Some pairs may have no active exchange listings at the time of the API call. The field is returned as an empty array, not null.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Twelve Data API key? | Yes. This Actor calls the official Twelve Data API, which requires an API key. You can sign up for a free tier on twelvedata.com and pass your key in the Actor's configuration. |
| How many pairs can I pull in one run? | Free Apify users are limited to 10 items for preview. Paid Apify users can set maxItems up to 1,000,000, which covers the entire Twelve Data cryptocurrency catalog. |
| What fields does each row contain? | Every row includes symbol, currency\_base, currency\_quote, and available\_exchanges. The available\_exchanges field is an array of exchange names where that pair trades. |
| Can I filter for a specific pair? | Yes. Use the optional Symbol filter input to request a single pair like BTC/USD or ETH/BTC. Leave it empty to retrieve all pairs. |
| Does this scraper respect Twelve Data's rate limits? | The Actor makes a single API call per run. It does not hammer the endpoint. You are responsible for staying within your Twelve Data plan's daily credit allowance. |
| What output formats are supported? | You can export your dataset to JSON, CSV, Excel, or XML directly from the Apify platform. |
| Is this an official Twelve Data integration? | No. This is an independent Actor built on the public Twelve Data API. It is not endorsed by or affiliated with Twelve Data Pte. Ltd. |
| Can I schedule this Actor to run daily? | Yes. Apify's scheduler lets you set a cron expression to run the Actor automatically, so your pair catalog stays current without manual intervention. |

### Related actors

Browse the full [Acquisition Automation collection](https://apify.com/acquistion-automation) for more scrapers.

🆘 **Need help?** Open an issue in the Issues tab of this Actor with your run ID, your input, and what you expected.

### Pricing

This Actor uses **pay-per-result** pricing: **$0.004 per result** collected. You are billed only for the results you receive, so a run that returns nothing costs nothing.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Twelve Data Pte. Ltd. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

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

## `symbol` (type: `string`):

Optional symbol to filter results (e.g., BTC/USD). Leave empty to retrieve all pairs.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

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

Complete dataset of all scraped records.

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/twelve-data-cryptocurrency-pairs-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/twelve-data-cryptocurrency-pairs-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 '{
  "maxItems": 10
}' |
apify call acquistion-automation/twelve-data-cryptocurrency-pairs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/twelve-data-cryptocurrency-pairs-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/2AJvUnge5hUvng0qJ/builds/bUtOCgUGW8H5sVcfM/openapi.json