CoinPaprika Scraper: Up to 1,000 Free Results a Month (2026)

Extracting coin records containing up to 41 fields such as currentPrice, circulatingSupply, and priceChangePercentage24h requires no developer API keys or registration. By querying CoinPaprika directly, this tool bypasses per-minute rate limits to deliver live price moves, exchange volume data, and token metadata on demand. Standard queries run on standard infrastructure, while 17 input controls allow you to filter results down to targeted coin lists. This scraper is built for developers creating automated trading algorithms, tracking applications, or financial dashboards, but it is not suitable for those who require deep historical candlestick series or direct community governance metrics.

Try it: open CoinPaprika Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try CoinPaprika Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of CoinPaprika Scraper a month, before run-start charges and platform usage.

CoinPaprika Scraper was last updated on 2026-05-08. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 680,173 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run CoinPaprika Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The mode and includeDetails parameters have the largest influence on your budget. Running in markets mode fetches thousands of tickers in a single underlying API request, whereas running in coins mode with includeDetails enabled triggers additional queries for every single coin ID in your list, multiplying your data usage. To find out if this scraper works for your integration before spending, run it with maxItems set to a low value like 5 in markets mode.

How do you run CoinPaprika Scraper from the API?

The schema marks 1 of its 17 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for CoinPaprika Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~coinpaprika-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"markets"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "markets"
}

run = client.actor("crawlerbros~coinpaprika-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "markets"
}

const run = await client.actor('crawlerbros~coinpaprika-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which CoinPaprika Scraper inputs matter, and which can you skip?

The mode parameter dictates the entire schema structure of your output and must be set first. For targeted scans, the coinIds array lets you pass specific strings, which prevents the scraper from running through the default market cap lists. On your initial runs, leave the proxy and rotation settings disabled, as CoinPaprika does not restrict standard datacenter IPs under normal usage patterns.

• mode (string): What to fetch. Default: "markets".
• quoteCurrency (string): Quote currency for prices/market cap. Supported: USD, BTC, ETH, EUR, GBP, JPY, PLN, KRW, CNY, INR. Default: "USD".
• coinIds (array): CoinPaprika coin IDs (e.g. ["btc-bitcoin", "eth-ethereum", "sol-solana"]). Use mode=search to discover IDs. Default: [].
• includeDetails (boolean): If true, fetches /coins/{id} per ID for description, tags, social links, team size. Doubles request count. Default: true.
• searchQuery (string): Query (matches coin name + symbol). E.g. bitcoin, eth, dogecoin. Default: "bitcoin".
• tagIds (array): Specific CoinPaprika tag IDs to fetch detail for (e.g. ["defi", "stablecoin", "dao"]). Leave empty in mode=tags to list ALL tags. Default: [].
• baseCurrencyId (string): CoinPaprika ID of the FROM currency (e.g. btc-bitcoin, usd-us-dollars).
• quoteCurrencyId (string): CoinPaprika ID of the TO currency (e.g. eth-ethereum, usd-us-dollars).
• amount (integer): Amount of the base currency to convert. Default 1. Default: 1.
• order (string): Client-side sort applied to the full ticker list before slicing. Default: "market_cap_desc".
• minMarketCap (integer): Drop coins with market cap below this. Applied client-side after fetch.
• min24hVolume (integer): Drop coins with 24h trading volume below this.

The other 5 controls, with their defaults, are listed in the input schema on CoinPaprika Scraper on Apify.

Fixed-choice controls: mode accepts 11 values (default markets), including markets (top coins by market cap (full ticker list)), coins (fetch specific coins by ID with rich detail), search (find coins by query), exchanges (top exchanges by trading volume); quoteCurrency accepts 10 values (default USD), including USD, BTC, ETH, EUR; order accepts market_cap_desc (Market cap (desc)), market_cap_asc (Market cap (asc)), volume_desc (24h volume (desc)), volume_asc (24h volume (asc)), price_desc (Price (desc)), price_asc (Price (asc)), change_24h_desc (24h change % (desc)), change_24h_asc (24h change % (asc)).

What does CoinPaprika Scraper return?

The returned records are excellent for real-time portfolio tracking, market dashboards, and monitoring short-term price movements across multiple timeframes. They do not contain historical candlestick series, detailed member profiles, or historical ICO data, which are absent from the public endpoints. If you need extensive historical trends, you must look to alternative aggregators.

Coin records (recordType=coin)

• id: CoinPaprika coin ID (btc-bitcoin, eth-ethereum, …)
• symbol: Ticker (btc)
• name: Display name
• marketCapRank: Rank by market cap
• currentPrice: Current price in quoteCurrency
• marketCap: Market cap in quoteCurrency
• totalVolume24h: 24h trading volume
• priceChangePercentage15m, priceChangePercentage30m, priceChangePercentage1h, priceChangePercentage6h, priceChangePercentage12h: Short-window price moves
• priceChangePercentage24h, priceChangePercentage7d, priceChangePercentage30d, priceChangePercentage1y: Long-window price moves
• marketCapChangePercentage24h, volumeChangePercentage24h: 24h aggregate moves
• circulatingSupply, totalSupply, maxSupply: Supply data
• allTimeHigh, allTimeHighDate, allTimeHighChangePercentage: ATH info
• betaValue: Beta vs BTC
• firstDataAt, lastUpdated: Timestamps
• quoteCurrency: Quote currency for prices (e.g. USD)
• url: Public CoinPaprika URL
• description: Coin description (HTML stripped)
• tags: Array of tag names
• type: coin / token
• openSource, developmentStatus, hardwareWallet: Booleans
• proofType, hashAlgorithm, orgStructure: Metadata
• startedAt: Genesis date
• teamSize: Number of team members
• social: {homepage, twitter, reddit, github, youtube, telegram}

Exchange records (recordType=exchange)

• id, name: Exchange metadata
• type: Array (e.g. ["cex", "spot"])
• active, websiteStatus: Booleans
• marketCapRank: Adjusted rank
• currenciesCount, marketsCount: Inventory
• reportedVolume24hUsd, adjustedVolume24hUsd: 24h volume in USD
• social: {website, twitter}
• description: Exchange description

Global record (recordType=global)

• totalMarketCapUsd, totalVolume24hUsd: Aggregate market cap + volume in USD
• bitcoinDominancePercentage: BTC dominance
• cryptocurrenciesNumber: Total tracked coins
• marketCapAthValue, marketCapAthDate: Market-cap ATH
• volume24hAthValue, volume24hAthDate: Volume ATH
• marketCapChangePercentage24h, volumeChangePercentage24h: 24h aggregate moves
• updatedAt: Unix timestamp

Example output

• recordType (e.g. coin)
• id (e.g. btc-bitcoin)
• symbol (e.g. btc)
• name (e.g. Bitcoin)
• url (e.g. https://coinpaprika.com/coin/btc-bitcoin/)
• quoteCurrency (e.g. USD)
• marketCapRank (e.g. 1)
• currentPrice (e.g. 82397.0894)
• marketCap (e.g. 1650043655158)
• totalVolume24h (e.g. 35994071984.028)
• priceChangePercentage1h (e.g. -0.13)
• priceChangePercentage24h (e.g. 1.12)
• priceChangePercentage7d (e.g. 7.29)
• circulatingSupply (e.g. 20025512)
• maxSupply (e.g. 21000000)
• allTimeHigh (e.g. 126173.1778)
• allTimeHighDate (e.g. 2025-10-06T19:00:40Z)
• allTimeHighChangePercentage (e.g. -34.72)
• betaValue (e.g. 0.9336)
• lastUpdated (e.g. 2026-05-06T12:35:16Z)
• scrapedAt (e.g. 2026-05-06T12:36:00Z)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open CoinPaprika Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run mode set to search with searchQuery configured for your target asset to discover the exact CoinPaprika ID required for detail lookups.
2. Inspect the resulting dataset to locate the id field such as btc-bitcoin or eth-ethereum before querying specific profiles.
3. Switch mode to coins and paste the discovered ID strings into the coinIds array to load direct asset records.
4. Check the includeDetails checkbox if you require team metadata, developer status, and social profiles in addition to price data.
5. Configure quoteCurrency to one of the ten supported fiat or crypto pairings, such as USD or BTC, to align all value fields to your base.
6. Add client-side filtering via minMarketCap or min24hVolume to drop low-liquidity assets before they are written to the dataset.
7. Set maxItems to a conservative threshold like 50 to test your integration structure before scaling up to larger arrays.

How do you apply it? Three worked playbooks

These are CoinPaprika Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Crypto trading bots

Outcome: Live price + multi-window % moves (15m to 1y).

Configure: mode="markets", quoteCurrency="USD", order="market_cap_desc", maxItems=100

Working method: Execute the scraper on a tight schedule to fetch the top 100 assets. Inspect the return payload for fast-moving metrics like priceChangePercentage15m and priceChangePercentage1h. Build logic that alerts when price changes cross your designated momentum boundaries.

Deliverable: A structured JSON dataset containing 100 coin records with 41 fields of price-change percentages spanning multiple time intervals.

Stop condition: The lastUpdated timestamp on returned assets halts updating, indicating an upstream pause in exchange feeds.

Use case 2: Portfolio trackers

Outcome: Snapshot pricing across hundreds of coins.

Configure: mode="coins", coinIds=["btc-bitcoin", "eth-ethereum", "sol-solana"], quoteCurrency="USD", includeDetails=true

Working method: Assemble a precise list of CoinPaprika asset IDs mapped to your tracker's holdings. Run the scraper with detailed fields enabled to acquire both latest pricing and project tags. Merge these metrics directly into your database schema using the unique coin ID as the primary key.

Deliverable: A collection of coin records containing currentPrice, circulatingSupply, and detailed social links for specific assets.

Stop condition: The scraper returns empty records or fails to locate details for valid ticker IDs in your input list.

Use case 3: Market dashboards

Outcome: Mode=global for daily summaries.

Configure: mode="global", quoteCurrency="USD"

Working method: Schedule a daily run to collect high-level network statistics. Capture total market capitalization, transaction volumes, and Bitcoin's dominance ratio. Push these macro values to your dashboard's historical timeline database for rendering trend lines.

Deliverable: A single global record featuring aggregate market metrics, market cap all-time highs, and 24-hour volume changes.

Stop condition: The returned record contains a totalMarketCapUsd value of zero or null, indicating database corruption upstream.

What breaks, and how do you design around it?

• Free tier has no documented per-minute cap, but burst limits exist; the actor backs off and retries on 429.
• Historical OHLCV (/coins/{id}/ohlcv/historical) requires a paid CoinPaprika plan and is therefore not exposed; only mode=ohlcv (latest day) is supported.
• Per-person profiles (/people/{id}) and ICO listings (/ico) endpoints have been removed from CoinPaprika's public API and are not exposed.
• Trending / categories endpoints aren't part of CoinPaprika's public API; use order=change_24h_desc on mode=markets for a "trending" proxy and mode=tags for category browsing.
• Some lightly traded coins may have stale lastUpdated timestamps.

Because historical OHLCV data is restricted by the platform, design your system to store daily snapshots locally if you need to build a historical chart. When you encounter rate limits on larger runs, enable useProxy to bypass blocks rather than manually partitioning your requests. For missing or stale coins, implement a fallback filter that discards any record with an outdated lastUpdated timestamp before it hits your production database.

When should you not use CoinPaprika Scraper?

Do not use this scraper if you need comprehensive historical price charts or long-term historical candlestick data, as CoinPaprika restricts historical OHLCV endpoints to their paid Pro API tiers. Instead, you should use the CryptoCompare Market Data Scraper which retrieves complete historical daily, hourly, and minute price sequences. If your application relies on comprehensive market coverage that includes deep order-book analytics or direct community audit scores, you are better served by the CoinGecko Scraper or the CoinMarketCap Crypto Scraper, which aggregate those specific external developer and community signals.

What should you check before trusting the output?

• Verify that the recordType matches coin, exchange, or global depending on your active mode parameter.
• Confirm that critical financial values like currentPrice and marketCap are non-null and correctly mapped to your chosen quoteCurrency.
• Check for stale or inactive assets by flagging records where the lastUpdated timestamp is older than your acceptable tracking window.
• Audit nested objects inside the social field to ensure links are complete strings rather than empty fields, which are dropped from the output.
• Monitor response structures for empty objects when querying obscure, lightly traded coins that might lack comprehensive metadata.

None of this proves a record is correct. It gives a scheduled CoinPaprika Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Is an API key needed to run this scraper?

No. The scraper is built entirely around CoinPaprika's public API endpoints. It successfully retrieves live tickers, coins, search details, exchange lists, and global market statistics without requiring you to purchase or register a personal developer key.

What are the pricing tiers for this Actor?

On Apify's free plan, results cost $5.00 per 1,000 results. If you upgrade to paid levels, the cost decreases, going down to $4.33 on the Bronze plan and $3.00 on the Gold plan for every 1,000 results written to your dataset. Keep in mind that platform compute usage and run-start fees are billed separately.

How do I avoid getting rate limited or blocked?

By default, the scraper auto-escalates to Apify proxies if it encounters HTTP 429 or 403 errors. For larger operations, you can set useProxy to true and configure rotateEveryNRequests to change IP addresses frequently, sharing the request volume across a broad pool.

Can I fetch historical charts with this Actor?

No. Historical OHLCV datasets are restricted behind CoinPaprika's paid developer tiers and are not exposed by this scraper. Only the latest daily open, high, low, close, and volume statistics are available through the ohlcv mode.

What is the difference between markets mode and coins mode?

Markets mode retrieves the broad ticker list in a single fast query, returning pricing and price-change percentages. Coins mode requires individual queries per coin ID but fetches rich metadata including project descriptions, social media links, and team sizes.

Where to go next

When you are ready to run it, open CoinPaprika Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• CryptoCompare Market Data Scraper: Scrape live and historical cryptocurrency market data from CryptoCompare - top coins by market cap/volume, historical OHLCV price series, exchange rankings, and coin metadata.
• CoinMarketCap Crypto Scraper: Scrape CoinMarketCap for cryptocurrency prices, market cap, supply, ATH/ATL, audits, and social links.
• CryptoBubbles Coin Performance Scraper: Scrape live cryptocurrency performance data from CryptoBubbles - top 1000 coins with price, market cap, volume, and multi-timeframe performance metrics (1m, 5m, 15m, 1h, 4h, 1d, 1w, 1mo, 3mo, 1y).
• CryptoSlate Crypto News & Data Scraper: Scrape CryptoSlate.com - latest crypto news articles, coin market data, article details, and news search.
• Investing.com Quotes Scraper: Scrape real-time quote data from Investing.com - stocks, indices, currency pairs, commodities, crypto, and ETFs.
• Adobe Exchange Scraper: Scrape Adobe Exchange marketplace - search extensions, plugins, and integrations for Creative Cloud (Photoshop, Illustrator, Premiere Pro, After Effects, etc.) and Adobe Commerce.
• CoinGecko Scraper: Scrape CoinGecko - the world's largest crypto data aggregator.
• Finviz Stock Screener Scraper: Scrape Finviz stock screener - filter stocks by exchange, sector, industry, market cap, P/E ratio, and 50+ other criteria.

Related guides:

• Applying StockTwits Scraper: 3 Proven Workflows and Setup Guides
• PubMed Search Scraper: 3 Practical Use Cases and Workflow Guide
• Vivian Health Jobs Scraper: Build 3 Robust Healthcare Data Playbooks
• Redbubble Scraper: 3 Practical Use Cases and Workflow Guide

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-05-08.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• CoinPaprika Scraper on Apify