Binance Scraper

Binance's REST API needs a key for most endpoints and blocks requests from several countries outright. This Actor reads the public ticker for any spot pair and returns one structured record: last price, best bid and ask, 24h high, low, volume and change. Turn on funding and it adds the perpetual futures funding rate and mark price for the same pair.

What it does

• Returns one record per requested pair, in order. A pair Binance does not list comes back with status: "failed" and a reason, so a batch never fails silently.
• Keeps both names: requested is what you asked for (BTC/USDT) and symbol is Binance's own (BTCUSDT), so you can join back to your watchlist.
• Adds the perpetual funding rate and mark price when Include funding is on, which is how you see whether the market is paying longs or shorts.
• Routes through Germany because Binance refuses US datacenter addresses. The egress the source needs is handled for you and there is nothing to configure.
• Stamps every record with validFrom, Binance's own exchange time for that tick, so you always know how stale a price is.
• Needs no API key and no signed request. Nothing to register, nothing to rotate.

Use cases

You need to	How this Actor does it
Price a portfolio every minute	Pass every pair you hold and schedule the run
Watch the spread on a pair	Subtract bid from ask on each run and alert on a widening book
Compare venues for the same pair	Run this next to the Bybit, OKX, Kraken or Coinbase Actor and diff value at validFrom
See who is paying to hold a position	Turn on funding and read fundingRate against markPrice
Feed a trading agent	Call the Actor over MCP and let the model ask for the pair it needs
Build your own candles	Schedule the run and let the dataset accumulate one row per pair per run

Quick start

1. Click Try for free.
2. Add your pairs, one per line, as BASE/QUOTE: BTC/USDT, ETH/USDT, SOL/USDT. Binance quotes most pairs in USDT rather than USD.
3. Turn on Include funding if you also want the perpetual funding rate and mark price.
4. Click Start. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

Input

Field	Type	Default	What it controls
pairs	array	BTC/USDT, ETH/USDT	Trading pairs to read, written BASE/QUOTE. Slashes are optional and case does not matter.
includeFunding	boolean	false	Adds fundingRate and markPrice from the perpetual futures market
maxItems	integer	0	Caps how many pairs are read. 0 reads them all

{
    "pairs": [
        "BTC/USDT",
        "ETH/USDT",
        "SOL/USDT"
    ],
    "includeFunding": true,
    "maxItems": 0
}

Output

One dataset item per pair. Funding fields appear only when Include funding is on and Binance lists a perpetual contract for that pair.

Field group	Fields
Identity	status, requested, symbol, currency, url
Price	value, bid, ask
24 hour window	high24h, low24h, baseVolume24h
Timing	validFrom, scrapedAt
Perpetual futures	fundingRate, markPrice, nextFundingTime

{
    "status": "ok",
    "requested": "BTC/USDT",
    "symbol": "BTCUSDT",
    "currency": "USDT",
    "value": 104238.61,
    "bid": 104238.6,
    "ask": 104238.61,
    "high24h": 106540.0,
    "low24h": 103112.45,
    "baseVolume24h": 18422.31,
    "fundingRate": 0.0001,
    "markPrice": 104240.12,
    "validFrom": "2026-09-04T20:00:01.000Z"
}

Integrations

Run it over the API and get the rows back in one call:

curl -X POST "https://api.apify.com/v2/acts/publicmoney~binance-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pairs": ["BTC/USDT", "ETH/USDT", "SOL/USDT"], "includeFunding": true, "maxItems": 0}'

From Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/binance-scraper").call(run_input={"pairs": ["BTC/USDT", "ETH/USDT", "SOL/USDT"], "includeFunding": true, "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["symbol"], item["value"], item["validFrom"])

Give an AI agent the Actor over MCP:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/binance-scraper"
        }
    }
}

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

Cost

Pay per event, so you pay for records rather than compute time.

Event	Free tier	Top volume tier
Record with data	$0.002	$0.0007
Actor start	$0.00005 per GB	Same

A record that returned no data is published as a failure row and is never charged. Six volume tiers apply, so the per-record price falls with monthly volume.

Troubleshooting

Issue	Solution
Every pair returns failed	Binance is refusing the egress this Actor uses. It is not settable from the input, so open an issue on the Issues tab and we will move it.
One pair returns failed, the rest are fine	That pair is not listed on this exchange, or the quote asset is wrong. Check it on the exchange first.
A pair works but funding fields are missing	Binance lists no perpetual contract for it. Spot-only pairs carry no funding rate.
symbol does not match what I sent	By design. requested is your input and symbol is Binance's own form, so BTC/USDT becomes BTCUSDT.
value looks behind another exchange	Read validFrom. It is the exchange's own timestamp for that tick, so two venues legitimately differ. Prices are spot, not aggregated.

FAQ

Does the Binance API need an API key?

For most endpoints yes, and several need a signed HMAC request on top. The public ticker does not, which is what this Actor reads, so there is nothing to register and nothing to rotate.

Why does Binance block my requests?

Binance restricts access from a number of countries, including the US, and returns an error rather than data. This Actor routes through Germany for that reason, and the egress is not exposed in the input, so there is nothing you can misconfigure.

Is this the real-time Binance price?

It is the last trade Binance published at validFrom, read live on each run. It is not a stream, so for tick-by-tick data use a websocket. For a price every minute or every hour, schedule the Actor.

Does it return Binance candles or historical prices?

No. Each record is the current ticker. To build a series, schedule the Actor and let the dataset accumulate one row per pair per run, each stamped with validFrom.

What is the funding rate for?

On perpetual futures it is the periodic payment between longs and shorts that keeps the contract near spot. A positive rate means longs pay shorts. nextFundingTime says when the next payment lands.

Do I need a Binance API key?

No. You need an Apify token to call the Actor over the API. No Binance credential is involved anywhere.

Can I get this data in Python?

Yes, with the apify-client package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

Is it legal to scrape Binance?

This Actor reads public Binance data that needs no login and collects no personal data. Scraping public data is generally lawful, and how you store, redistribute or act on market data is governed by your own agreements and local rules. Take your own legal advice for your use case.

Changelog

• 0.0.2 Added the perpetual funding rate, mark price and next funding time.
• 0.0.1 First release. Spot ticker for any listed pair.

Feedback

Found a field Binance publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.