# TickerLayer vs Twelve Data

> TickerLayer scores 71.5 (BB) to Twelve Data's 70 (BB) for market prices. Prices, MCP, x402, uptime and agent notes side by side.

- Canonical: https://www.anchorterminal.com/compare/tickerlayer-vs-twelve-data
- Markdown: https://www.anchorterminal.com/compare/tickerlayer-vs-twelve-data.md (~5,450 tokens)
- Site index for agents: https://www.anchorterminal.com/llms.txt (the key docs and every listing in one file, at most 16 MB, about 4 million tokens: https://www.anchorterminal.com/llms-full.txt)
- API: https://www.anchorterminal.com/api/v1/index.json
- MCP: https://www.anchorterminal.com/mcp (the whole catalogue as tools, no key)
- DNS: dig +short TXT <slug>.grade.anchorterminal.com (the grade as a DNS TXT record, for a sandbox with no HTTP where names still resolve; also top., best.<category>. and <a>.vs.<b>. under the zone, and the same under grade.letme.dev)
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)
- Updated: 2026-11-11

TickerLayer scores 71.5 (BB) on agent readiness against Twelve Data's 70 (BB), and leads in 2 of 7 scored categories. Twelve Data leads on reliability, agent ergonomics, security & auth and transparency & trust. Both do market prices. TickerLayer accepts x402. Twelve Data doesn't.

- TickerLayer: grade BB, 71.5/100, rank #160 of 1520. Markdown https://www.anchorterminal.com/tools/tickerlayer.md · JSON https://www.anchorterminal.com/api/v1/tools/tickerlayer.json
- Twelve Data: grade BB, 70/100, rank #219 of 1520. Markdown https://www.anchorterminal.com/tools/twelve-data.md · JSON https://www.anchorterminal.com/api/v1/tools/twelve-data.json
- Best financial market data APIs for AI agents: https://www.anchorterminal.com/best/market-data/index.md
- All 78 markets comparisons: https://www.anchorterminal.com/compare/market-data/index.md

## Which one, for what

### TickerLayer (BB)

Good for: An agent that needs latest prices, bars and market hours across stocks, forex, crypto, indices, ETFs, commodities, bond yields and perpetual futures from one schema, and wants to pay per call without an account.

Ahead on:
- Schema & documentation, 88 against 83
- Payments & pricing, 92 against 30

Also in its favour:
- An agent can pay per call over x402, with no account

Watch for: The data is derived and indicative from unnamed non-exchange sources, and no page says it is licensed from an exchange

### Twelve Data (BB)

Good for: Agents that need prices and time series across many exchanges and asset classes with one contract, CSV output, and a documented error table.

Ahead on:
- Reliability, 83 against 70
- Agent ergonomics, 84 against 79
- Security & auth, 54 against 49
- Transparency & trust, 67 against 38

Also in its favour:
- Runs on your own machine

Watch for: The REST docs and OpenAPI accept the key as `?apikey=` in the query string alongside the header


## Why the edge

### Payments & pricing: TickerLayer +62

- TickerLayer (92): x402 on the vendor's own gateway, x402.tickerlayer.com, for 41 GET routes. That is six routes for each of stocks, forex, crypto, indices, ETFs and commodities, plus bond yields and four market-calendar routes. Perpetuals, Futures CFDs, the add-ons, the symbol catalogue and WebSocket need a key. Between massive's 30 for US stock routes only and financial-datasets' 35 for every documented data endpoint (32 of 40). Per-call x402 prices from 0.01 to 0.10 USDC in the catalogue and docs, and plan prices per feed on the pricing page, all without a login (20). A Free plan of 3,000 REST calls every 30 days with 'no card', per llms.txt (20). An agent with a funded Base wallet pays per call with no account or key (20). 32+20+20+20 = 92.
- Twelve Data (30): No x402, MPP or L402 (0). Plan prices are public without login in pricing.md and on the pricing page, sold by credits a minute per month rather than per call (10). A free Basic plan at 800 credits a day with no card (20). The key comes from a browser signup and no key API was found; MCP needs an OAuth login by a person (0). 0 + 10 + 20 + 0 = 30.

### Transparency & trust: Twelve Data +29

- TickerLayer (38): The editorial half. A closed service whose terms of use, user agreement and market data disclaimer (all effective 3 November 2026) set out internal, commercial and redistribution rights by plan and a liability cap. They name no legal entity, address or governing law, so the contracting party is unknown. The plugin and npm client are MIT. Soldfetch took 10 in the same position (10 of 30). The privacy policy keeps WebSocket connection records for 7 days but gives no period for request and tool-call logs or account data after closure, says nothing on model training, names no transfer mechanism and has no DPA (12 of 30). No deprecation policy. The terms allow MCP tools to change 'with reasonable notice where practical' and the user agreement promises notice before a plan is materially reduced, and the changelog records changes after the fact. Kite took 4 (4 of 20). Subprocessors are given only as categories (hosting, authentication, card and crypto payments, email, an AI model for support replies), with analytics vendors deferred to the cookie policy, no data locations, and no named data suppliers (4 of 20). 10+12+4+4 = 30. The provenance half is computed from the provenance block.
- Twelve Data (67): A closed service under terms that name the entity, define internal use, business use and redistribution, and were last updated 1 January 2026; the MCP repository is open source but ships no licence file (15 of 30). The privacy policy of 22 September 2026 states retention periods and names its processors, the terms require data deletion within 30 days of termination, and no DPA is named (20 of 30). No deprecation policy or notice period; the terms allow changes and the monthly updates record them after the fact (3 of 20). Subprocessors are named on the privacy policy and the trust centre, with no data locations beyond transfer mechanisms (12 of 20). 15 + 20 + 3 + 12 = 50.

### Reliability: Twelve Data +13

- TickerLayer (70): Read with the hosted lines, on the REST API. status.tickerlayer.com is an UptimeRobot page linked from the site header (20). Its monitors and history load by script from /api/, which its robots.txt disallows, so no incident record was read, as for eodhd and apitemplate-io (5). Limits are published with numbers, 10 requests a second per account on Free and Individual, 100 on Business, and monthly call quotas per feed (15). The OpenAPI file's 429 carries `Retry-After` and a body with `retryAfterMs`, `resetsAt` and a code that separates the per-second limit from the monthly quota, and every response has carried `X-RateLimit-Limit` and `X-RateLimit-Remaining` since 14 September 2026. Every data operation is a GET, and x402 retries with the same payment identifier return the stored response (15). An SLA is named only for Enterprise under a written agreement and as 'partially available' on Business, with no published terms or figure, and the terms of use promise no uptime. Financial-datasets took 10 for SLAs listed on a self-serve plan, so this is half (5 of 10). No beta or preview label on the REST API, the MCP server or the x402 gateway (10). 20+5+15+15+5+10 = 70.
- Twelve Data (83): Read with the hosted lines. A public status page at twelvedata.isitup.cloud lists Price API, Fundamentals API, WebSocket and Website with uptime figures (20). Its history shows two incidents in the 90 days to 3 November 2026, 20 minutes of unavailability across the three APIs on 1 September and 16 minutes on the WebSocket on 14 October, minor only (20). Limits are published with numbers, credits a minute by plan from 8 to 10,946 and 800 a day on Basic (15). The docs document a 429 on the limit and the usage endpoint, with no Retry-After or backoff guidance; reads only (8 of 15). The terms sell a 99.9 per cent SLA with service credits, and the Enterprise plan carries 99.99 per cent (10). The REST API and MCP server are generally available (10). 20 + 20 + 15 + 8 + 10 + 10 = 83.

### Schema & documentation: TickerLayer +5

- TickerLayer (88): OpenAPI 3.1 at tickerlayer.com/openapi.json (TickerLayer Market Data API 1.0.0, about 386,000 characters), read in its first 100,000 and last 96,000 characters, with summaries, descriptions, tags and examples on the operations read and shared 400, 401, 403, 404, 429 and 503 responses. The WebSocket is described in prose only and the hosted MCP tool schemas weren't read (23 of 25). llms.txt, llms-full.txt and a Markdown twin of every docs page (10). Operation descriptions state purpose and plan gating, and the vendor's skill says which MCP tool to use for each question and when not to, such as `get_quote` not being the tool for a price. Financial-datasets took 17 (17 of 20). Enums on `interval`, `multiplier`, `timespan` and `sort`, `format: date` on dates, bounded `limit`, required path parameters, as for massive (13 of 15). Examples on most parameters and responses, one Error schema with ten fields and documented codes, but the codes appear only as example values with no enum or table (13 of 15). A dated changelog of the last 50 changes, 8 September to 6 November 2026, but no version in the REST paths ('no /v1/') and the spec at 1.0.0. Above twelve-data's 10 for monthly updates and below massive's 15 for versioned paths (12 of 15). 23+10+17+13+13+12 = 88.
- Twelve Data (83): A public OpenAPI 3.1 document covers 187 operations, every one with a description and 200, 400, 401, 403, 404, 414, 429 and 500 responses, and the MCP tools in the source carry typed inputs and annotations (25). llms.txt on the site and in the docs link Markdown pages per section, pricing.md and auth.md (10). Descriptions state purpose, plan requirement and credit cost, with little on when not to use an endpoint (16 of 20). Required parameters are marked and the Markdown lists interval, adjust and type values, but none of the 3,091 parameters in the spec declares an enum (9 of 15). Examples with a demo key on every endpoint and an error table with codes and meanings (13 of 15). No version in the path, a spec at version 0.0.1, and monthly dated product updates on the news page rather than an API changelog (10 of 15). 25 + 10 + 16 + 9 + 13 + 10 = 83.

### Agent ergonomics: Twelve Data +5

- TickerLayer (79): Read on the REST API, with the MCP server where a line covers it. Responses are sized by `limit` (bars up to 5,000, catalogue up to 1,000), `sort`, date ranges and batch calls for futures quotes and market status, with no field selection. The MCP server has 12 tools, 11 shown to the model. Massive and financial-datasets took 15 (15 of 25). `limit`, `offset` and `next_offset`, cursors on fundamentals and economic events, `total_count` on bars, `search` on symbols and `updated_since` on signals (18 of 20). Errors carry `statusCode`, `message`, a code, `retryAfterMs`, `resetsAt`, `limitRps`, `plansUrl` and the missing `product` or `market`, and the skill gives an action per status. Above financial-datasets' 16 (17 of 20). Every data call is a GET, and x402 settles only after a valid response with payment identifiers bound to the request, but no readOnlyHint or other annotation was found for the MCP tools. Financial-datasets took 14 without annotations (15 of 20). Data tools need only `asset_class` and `symbol`, with defaults for limit and sort, and official clients exist for JavaScript or TypeScript and Python, both at 0.1.0 from 20 October 2026. Stocks need the `COUNTRY:TICKER` form (14 of 15). 15+18+17+15+14 = 79.
- Twelve Data (84): The REST API is the surface graded. `outputsize` 1 to 5,000 with a default of 30, `format=CSV`, `dp`, date ranges and batch requests size responses, and the MCP server lists 27 tools (20 of 25). Date ranges, `outputsize` and exchange, country and type filters, with no cursor pagination (15 of 20). Error codes with meanings an agent can branch on, 403 for plan limits and 429 for credits (16 of 20). Every operation is a read, and the MCP source marks tools readOnlyHint (18 of 20). Few required parameters, a demo key, and official SDKs in Python, Node.js, Go, Java and R (15). 20 + 15 + 16 + 18 + 15 = 84.

### Security & auth: Twelve Data +5

- TickerLayer (49): A plain account key with no scopes, shown once and replaced by regenerating it in the dashboard (20). The OpenAPI file defines an `apiKey` query parameter as a 'compatibility fallback', and the WebSocket takes the key only in its URL, so 10 off. The MCP server adds OAuth 2.1 with PKCE S256, dynamic registration, refresh tokens, a revocation endpoint and one scope, `market.read`. Twelve-data took 18 on the same pattern, one less here because the WebSocket has no header option (17 of 30). Every operation reads data, and the OAuth scope is read-only, as for twelve-data and financial-datasets (15 of 20). Responses are prices, bars, symbols, calendars and yields. There is no news feed, and SignalPoint signals are structured fields, so no untrusted text reaches the agent (10 of 15). Rate-limit headers on every response, quota 429s that state the limit and when it renews, and a dashboard list of WebSocket connections with source IP, key and how each ended (24 October 2026). No per-call REST log for the key holder was found, though the privacy policy says request logs are kept (7 of 15). security.txt answered a client error, and no disclosure policy, bug bounty, SOC 2 or ISO 27001 was found (0 of 20). 17+15+10+7+0 = 49.
- Twelve Data (54): The REST key is a plain per-account key with no scopes, accepted as a header or as `?apikey=` (20 less 10 for the query string). The hosted MCP server refuses keys and uses OAuth 2.1 with PKCE, a resource indicator, refresh tokens, revocation and one scope, which lifts the credential model for that surface (18 of 30). Every operation is a read (15 of 20). Company news is third-party text and no guidance was found (5 of 15). An `/api_usage` endpoint and dashboard usage give the key holder a view of consumption, not a per-call log (6 of 15). A trust centre on SafeBase lists SOC 2, GDPR and CCPA and ten policies; no security.txt, disclosure process or bug bounty was found (10 of 20). 18 + 15 + 5 + 6 + 10 = 54.

## Score by category

| Category | Weight | TickerLayer | Twelve Data | Edge |
| --- | --- | --- | --- | --- |
| Reliability | 16% (20 this run) | 70 | 83 | Twelve Data +13 |
| Performance | 10%, pending | pending | pending | not scored in this run |
| Schema & documentation | 13% (16.2 this run) | 88 | 83 | TickerLayer +5 |
| Agent ergonomics | 13% (16.2 this run) | 79 | 84 | Twelve Data +5 |
| Security & auth | 14% (17.5 this run) | 49 | 54 | Twelve Data +5 |
| Payments & pricing | 10% (12.5 this run) | 92 | 30 | TickerLayer +62 |
| Task success | 10%, pending | pending | pending | not scored in this run |
| Maintenance & community | 7% (8.8 this run) | 79 | 82 | Twelve Data +3 |
| Transparency & trust | 7% (8.8 this run) | 38 | 67 | Twelve Data +29 |
| Negative events | ≤15 | 0 | 0 | |
| **Total** | | **71.5 · BB** | **70 · BB** | |

## Facts side by side

| Fact | TickerLayer | Twelve Data |
| --- | --- | --- |
| Kind | HTTP API | HTTP API |
| Vendor | TickerLayer | Twelve Data Pte. Ltd. |
| Hosted endpoint | `https://mcp.tickerlayer.com/mcp` | `https://api.twelvedata.com` |
| Transports | HTTP, Streamable HTTP, websocket | HTTP, Streamable HTTP, stdio, websocket |
| Auth | OAuth or key | OAuth or key |
| Pricing | Freemium | Freemium |
| x402 | yes, from $0.01/call | no |
| Licence | Proprietary hosted service under the TickerLayer terms of use, user agreement and market data disclaimer (all effective 3 November 2026), which name no legal entity or governing law. Free and Individual plans are for internal use, Business adds use inside the customer's own product, and redistribution needs a written Enterprise agreement. The agent plugin (github.com/tickerlayer/agent-plugin) and the npm client are MIT | none |
| Tools exposed | 12 | 27 |
| Read-only variant documented | no | yes |
| llms.txt | yes | yes |
| MCP registry | `com.tickerlayer/market-data` | not listed |
| Last release | 2026-11-06 | 2026-10-12 |
| Terms last updated | not read yet | 2026-01-01 |
| Privacy policy last updated | not read yet | 2026-09-22 |
| Customer content may train models | not read yet | not found in the text |
| Terms restrict automated access | not read yet | not found in the text |
| Terms restrict benchmarking | not read yet | yes |
| Terms or service can change without notice | not read yet | yes |
| Arbitration or class-action waiver | not read yet | yes |
| Popularity | none | 791 stars |

## Verdicts

**TickerLayer.** An agent can read quotes, bars and market hours across eight asset classes through a documented REST API, 12 MCP tools or 41 x402 resources with no account, and 429s carry Retry-After. The data is derived from unnamed non-exchange sources, no operator is named, and the status history couldn't be read.

**Twelve Data.** A public OpenAPI 3.1 document with error responses on all 187 operations, Markdown docs and pricing for agents, a status page with two short incidents in 90 days, and an MCP server behind OAuth 2.1. The REST key still travels in the query string as a documented option, no enums are declared, and free and individual plans forbid company use.

## Before you call either

### TickerLayer

1. Write stocks as `COUNTRY:TICKER`, such as `US:KO`, and always pass `asset_class` to the data tools.
2. If a 429 carries `REST_QUOTA_EXCEEDED`, stop and tell the user. Waiting doesn't reset the monthly quota.
3. Present prices as indicative TickerLayer values, never as official exchange prices.
4. Call `get_market_status` before you report a quiet symbol as missing data.
5. Send the key in the `x-api-key` header, never as the `apiKey` query parameter.

### Twelve Data

1. Send the key as `Authorization: apikey <key>`, not in the URL; the hosted MCP server takes OAuth only, so never paste a key into a connector's key field
2. Set `outputsize` (1 to 5,000, default 30) and `format=CSV` on time_series to keep responses small, and read `status` in the JSON body since errors come with HTTP codes and a `message`
3. Count credits, not calls; most endpoints cost one credit per symbol and the Basic plan allows 8 a minute and 800 a day, with 429 when exceeded
4. A 403 means the key's plan lacks the endpoint or symbol, not a bad key; check pricing.md before escalating
5. Use trial symbols from twelvedata.com/exchanges to test premium data on the free plan

## Questions

### Which is better for AI agents, TickerLayer or Twelve Data?

TickerLayer scores 71.5 (BB) on agent readiness against Twelve Data's 70 (BB), and leads in 2 of 7 scored categories. Twelve Data leads on reliability, agent ergonomics, security & auth and transparency & trust.

### Do TickerLayer and Twelve Data need an API key?

Both take an API key or an OAuth sign-in. An agent can also pay TickerLayer per call over x402, with no account.

### Can an agent call TickerLayer and Twelve Data without installing anything?

Yes. TickerLayer has a hosted endpoint at https://mcp.tickerlayer.com/mcp and Twelve Data at https://api.twelvedata.com.


## For agents

- This comparison as JSON: https://www.anchorterminal.com/compare/tickerlayer-vs-twelve-data.json, and with the fewest tokens: https://www.anchorterminal.com/compare/tickerlayer-vs-twelve-data.min.md
- Over MCP at https://www.anchorterminal.com/mcp (no key): `compare_tools {"a": "tickerlayer", "b": "twelve-data"}`. From a terminal: `anchor compare tickerlayer twelve-data`
- Each listing in full: https://www.anchorterminal.com/api/v1/tools/tickerlayer.json and https://www.anchorterminal.com/api/v1/tools/twelve-data.json

## Other comparisons with TickerLayer or Twelve Data

- [Alpha Vantage vs TickerLayer](https://www.anchorterminal.com/compare/alpha-vantage-vs-tickerlayer.md)
- [Alpha Vantage vs Twelve Data](https://www.anchorterminal.com/compare/alpha-vantage-vs-twelve-data.md)
- [Benzinga vs TickerLayer](https://www.anchorterminal.com/compare/benzinga-vs-tickerlayer.md)
- [Databento vs TickerLayer](https://www.anchorterminal.com/compare/databento-vs-tickerlayer.md)
- [Databento vs Twelve Data](https://www.anchorterminal.com/compare/databento-vs-twelve-data.md)
- [Finnhub vs TickerLayer](https://www.anchorterminal.com/compare/finnhub-vs-tickerlayer.md)
- [Finnhub vs Twelve Data](https://www.anchorterminal.com/compare/finnhub-vs-twelve-data.md)
- [Intrinio vs TickerLayer](https://www.anchorterminal.com/compare/intrinio-vs-tickerlayer.md)
- [Intrinio vs Twelve Data](https://www.anchorterminal.com/compare/intrinio-vs-twelve-data.md)
- [Massive (formerly Polygon.io) vs TickerLayer](https://www.anchorterminal.com/compare/massive-vs-tickerlayer.md)
- [Massive (formerly Polygon.io) vs Twelve Data](https://www.anchorterminal.com/compare/massive-vs-twelve-data.md)
- [TickerLayer vs Tiingo](https://www.anchorterminal.com/compare/tickerlayer-vs-tiingo.md)
- [Tiingo vs Twelve Data](https://www.anchorterminal.com/compare/tiingo-vs-twelve-data.md)
- [Eulerpool Financial Data API vs TickerLayer](https://www.anchorterminal.com/compare/eulerpool-vs-tickerlayer.md)
- [Eulerpool Financial Data API vs Twelve Data](https://www.anchorterminal.com/compare/eulerpool-vs-twelve-data.md)
- [Financial Datasets vs TickerLayer](https://www.anchorterminal.com/compare/financial-datasets-vs-tickerlayer.md)
- [Financial Datasets vs Twelve Data](https://www.anchorterminal.com/compare/financial-datasets-vs-twelve-data.md)
- [Financial Modeling Prep vs TickerLayer](https://www.anchorterminal.com/compare/financial-modeling-prep-vs-tickerlayer.md)
- [Financial Modeling Prep vs Twelve Data](https://www.anchorterminal.com/compare/financial-modeling-prep-vs-twelve-data.md)
- [EODHD vs TickerLayer](https://www.anchorterminal.com/compare/eodhd-vs-tickerlayer.md)
- [EODHD vs Twelve Data](https://www.anchorterminal.com/compare/eodhd-vs-twelve-data.md)
- [Benzinga vs Twelve Data](https://www.anchorterminal.com/compare/benzinga-vs-twelve-data.md)

---

Query this catalogue directly over MCP: https://www.anchorterminal.com/mcp (Streamable HTTP, no key). How: https://www.anchorterminal.com/agents/#mcp