# Twelve Data Instruments Scraper (`acquistion-automation/twelve-data-instruments-scraper`) Actor

Scrape instrument listings from Twelve Data by exchange and type. Returns symbol, name, currency, exchange, MIC code, country, type, FIGI, CFI, ISIN, and CUSIP. No API key needed.

- **URL**: https://apify.com/acquistion-automation/twelve-data-instruments-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Business
- **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 Instruments Scraper

**Scrape instrument lists from Twelve Data by exchange and type.** Every instrument comes with its symbol, name, currency, exchange, MIC code, country, type, FIGI, CFI, ISIN, and CUSIP. Export to CSV, JSON, Excel, or XML.

The Twelve Data API requires registration, an API key, and rate limits. This Actor reads the public instrument lists directly by exchange (e.g., NASDAQ, NYSE, LSE) and instrument type (stocks, ETFs, indices), returning each match in one fixed schema.

| Who uses it | What they scrape Twelve Data for |
|---|---|
| Financial analysts | Build a master list of all stocks on NASDAQ for portfolio screening. |
| Data engineers | Populate a database with instrument metadata including ISIN and CUSIP for cross-referencing. |
| Quantitative researchers | Gather ETF and index listings from multiple exchanges for backtesting universes. |

### What it does

This Actor collects instrument listings from Twelve Data by exchange and type, and returns each one as a flat row with all available identifiers.

- 📊 **Exchange filter:** Choose any exchange code (NASDAQ, NYSE, LSE, etc.) to scope the instrument list.
- 📂 **Instrument type:** Select stocks, ETFs, or indices to narrow the dataset.
- 🔢 **Max items control:** Free users get a 10-item preview; paid users can pull more records.

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

### What you can do with Twelve Data data

**📈 Build a stock universe.**

A quantitative analyst runs the Actor with exchange=NASDAQ and type=stocks to get every listed symbol for backtesting.

**📋 Cross-reference instrument identifiers.**

A data engineer pulls all ETFs from NYSE with ISIN and CUSIP fields to match against internal databases.

**🌍 Monitor global indices.**

A market researcher collects indices from LSE, TSE, and HKEX to track benchmark composition changes.

**🔍 Validate instrument metadata.**

A compliance officer uses the FIGI and CFI codes to verify instrument classifications for reporting.

### Why choose this scraper

| | What you get |
|---|---|
| **Full identifiers** | Each instrument includes symbol, name, currency, exchange, MIC code, country, type, FIGI, CFI, ISIN, and CUSIP. |
| **No API key needed** | The Actor accesses the public Twelve Data API directly. |
| **Bulk export** | Download instruments as CSV, JSON, Excel, or XML. |

### 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": "AACG",
 "name": "ATA Creativity Global",
 "currency": "USD",
 "exchange": "NASDAQ",
 "mic_code": "XNCM",
 "country": "United States",
 "type": "American Depositary Receipt",
 "figi_code": "BBG000V2S786",
 "cfi_code": "EDMXDR",
 "isin": "request_access_via_add_ons",
 "cusip": "request_access_via_add_ons",
 "scrapedAt": "2026-09-28T03:38:34.725Z"
}
```

A field a record does not have comes back as `null`.

### Configure the run

Set an exchange code and instrument type. The max items limit controls how many records are returned so you only get the data you need. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "exchange": "NASDAQ",
 "instrumentType": "stocks",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "exchange": "NASDAQ",
 "instrumentType": "stocks",
 "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 more results per run.

### Run it

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open the [Twelve Data Instruments Scraper](https://apify.com/acquistion-automation/twelve-data-instruments-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-instruments-scraper"
```

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

### Troubleshooting

**I got only 10 items even though I set maxItems higher.**

The free tier limits output to 10 items. Upgrade to a paid Apify plan to access the full limit.

**The exchange code I entered returned no results.**

Verify the exchange code is correct (e.g., NASDAQ, NYSE, LSE). Twelve Data may not support every exchange; try a common one first.

**The output is empty.**

Check that the instrumentType is set correctly (stocks, etf, or indices). Some exchanges may not list all types.

**I see an error about rate limiting.**

The public API has rate limits. Reduce maxItems or add a delay between runs. If the issue persists, contact Twelve Data.

**The fields are missing ISIN or CUSIP.**

Not all instruments have these identifiers. The Actor returns them when available from the API.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Twelve Data API key? | The Actor uses the public API endpoint that does not require authentication. |
| What exchanges are supported? | Any exchange code that Twelve Data recognizes, such as NASDAQ, NYSE, LSE, TSE, HKEX, and many more. |
| Can I scrape ETFs and indices too? | Yes. Use the instrumentType selector to choose stocks, ETFs, or indices. |
| How many instruments can I get? | Free users are limited to 10 items as a preview. Paid users can set maxItems higher. |
| What fields are returned? | Each instrument includes symbol, name, currency, exchange, MIC code, country, type, FIGI, CFI, ISIN, and CUSIP. |
| Can I export to CSV? | Yes. The dataset can be downloaded as CSV, JSON, Excel, or XML. |
| Is the data real-time? | This Actor returns the instrument list, which is updated periodically by Twelve Data, not real-time prices. |
| What is the MIC code? | The Market Identifier Code (MIC) is a unique code for the exchange where the instrument is traded. |
| Does it include delisted instruments? | The API returns currently listed instruments only. |
| Can I run it on a schedule? | Yes. You can schedule the Actor to run daily or weekly to keep your instrument list updated. |

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

## `exchange` (type: `string`):

The exchange code to fetch instruments from, such as NASDAQ, NYSE, or LSE.

## `instrumentType` (type: `string`):

The type of instruments to retrieve: stocks, ETFs, or indices.

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

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

## Actor input object example

```json
{
  "exchange": "NASDAQ",
  "instrumentType": "stocks",
  "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 = {
    "exchange": "NASDAQ",
    "instrumentType": "stocks",
    "maxItems": 10
};

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

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/twelve-data-instruments-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 '{
  "exchange": "NASDAQ",
  "instrumentType": "stocks",
  "maxItems": 10
}' |
apify call acquistion-automation/twelve-data-instruments-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-instruments-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/7xoUt3sQwLjZxtEbL/builds/xK4gSQ1E3bixViDuy/openapi.json