# Bitcoin Address Ticker Scraper (`zerobreak/bitcoin-address-ticker-scraper-202610120341`) Actor

Bitcoin Address Ticker Scraper is a Python tool designed to extract real-time wallet balances, total sent and received amounts, transaction counts, and unconfirmed activity for specific Bitcoin addresses. It exports structured on-chain blockchain datasets into clean CSV or JSON format.

- **URL**: https://apify.com/zerobreak/bitcoin-address-ticker-scraper-202610120341.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 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

### Bitcoin Address/Ticker Scraper — BTC Prices, Address Balances, and Latest Block

### Overview

Bitcoin Address/Ticker Scraper collects publicly available Bitcoin market quotes, address activity statistics, and the latest block information.

Configure the currencies and Bitcoin addresses you want to examine, then review the structured results in an Apify dataset. Export the collected data as JSON, CSV, or Excel for analysis and reporting.

By default, the actor collects USD and EUR ticker quotes along with the latest block information.

### Features

- **Bitcoin ticker quotes:** Collect the latest available BTC prices for selected currencies.
- **Address balance summaries:** Retrieve confirmed and unconfirmed activity statistics for specified Bitcoin addresses.
- **Latest block information:** Collect the latest block hash, height, timestamp, and transaction-index count.
- **Configurable collection:** Select currencies, provide addresses, and choose whether to include the latest block.
- **Structured output:** Store useful market, address, and block fields in a tabular format.
- **Duplicate reduction:** Avoid saving duplicate records during a run.
- **Dataset exports:** Export results to JSON, CSV, or Excel for further analysis.

### Use Cases

- **Price monitoring:** Collect BTC quotes in selected currencies and compare snapshots over time.
- **Address analysis:** Review reported balances, total received, total sent, and transaction counts.
- **Blockchain monitoring:** Track the latest block height and hash alongside market quotes.
- **Research and reporting:** Build structured datasets containing public Bitcoin information.
- **Balance comparisons:** Revisit selected addresses in subsequent runs and compare their reported balances.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `currencies` | Array | `["USD", "EUR"]` | Currency codes to collect from the ticker. An empty array skips ticker collection. |
| `addresses` | Array | `[]` | Bitcoin addresses to summarize. |
| `maxTxPerAddress` | Integer | `50` | Maximum number of transactions requested per address, from 1 to 100. |
| `includeLatestBlock` | Boolean | `true` | Whether to collect the latest block information. |
| `maxItems` | Integer | `100` | Maximum number of dataset rows to collect. Maximum: `1000`. |

### Example Input

```json
{
  "currencies": ["USD", "EUR"],
  "addresses": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
  ],
  "maxTxPerAddress": 1,
  "includeLatestBlock": true,
  "maxItems": 100
}
```

To collect only ticker quotes, provide the desired currencies and set `addresses` to an empty array.

To collect address summaries, add the required Bitcoin addresses to `addresses`. Set `includeLatestBlock` to `false` if you do not need the latest block record.

### What Data Does This Actor Extract?

The actor creates structured records for three data categories: ticker quotes, Bitcoin address summaries, and the latest block.

#### Extracted Data Fields

| Field | Type | Description |
|---|---|---|
| `mode` | String | Record category: `ticker`, `address`, or `latest_block`. |
| `record_id` | String | Record identifier used to distinguish collected entries. |
| `scraped_at` | String | Timestamp when the record was created, in UTC. |
| `currency` | String | Currency code associated with a ticker quote. |
| `symbol` | String | Currency symbol or identifier returned for the quote. |
| `price_15m` | Number | Price from the ticker's `15m` field. |
| `last` | Number | Latest reported price for the currency. |
| `buy` | Number | Reported buy price. |
| `sell` | Number | Reported sell price. |
| `address` | String | Bitcoin address being examined. |
| `hash160` | String | Address-associated hash value, when available. |
| `n_tx` | Integer | Reported transaction count for the address. |
| `n_unredeemed` | Integer | Reported count of unredeemed outputs associated with the address. |
| `total_received` | Integer | Total value received, in satoshis. |
| `total_sent` | Integer | Total value sent, in satoshis. |
| `final_balance` | Integer | Reported address balance, in satoshis. |
| `latest_tx_hash` | String | Hash of the newest transaction included in the returned transaction data, when available. |
| `tx_returned` | Integer | Number of transactions returned for the address. |
| `block_hash` | String | Hash identifying the latest block. |
| `block_time` | Integer | Reported block timestamp. |
| `block_index` | Integer | Block index returned by the source. |
| `block_height` | Integer | Height of the latest block. |
| `tx_index_count` | Integer | Number of transaction-index entries reported for the block. |

Fields may be absent when the selected record type does not use them or the corresponding information is unavailable.

### Example Output

#### Ticker record

```json
{
  "mode": "ticker",
  "record_id": "ticker:EUR",
  "currency": "EUR",
  "symbol": "EUR",
  "price_15m": 74465.97,
  "last": 74465.97,
  "buy": 74465.97,
  "sell": 74465.97,
  "scraped_at": "2026-10-12T00:00:00+00:00"
}
```

The values are illustrative and do not represent live market prices.

#### Address record

```json
{
  "mode": "address",
  "record_id": "address:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
  "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
  "hash160": "62e907b15cbf27d5425399ebf6f0fb50ebb88f18",
  "n_tx": 66920,
  "n_unredeemed": 80385,
  "total_received": 10759488974,
  "total_sent": 0,
  "final_balance": 10759488974,
  "latest_tx_hash": "f751c3e3d1e369306704aa90c101eff11deb41a4c132ce36eeac88c2d367f058",
  "tx_returned": 1,
  "scraped_at": "2026-10-12T00:00:00+00:00"
}
```

The address figures above illustrate the output structure and are not guaranteed to reflect current blockchain data.

#### Latest block record

```json
{
  "mode": "latest_block",
  "record_id": "block:000000000000000000007e610e49cf1087a77eeece833ee16c7f68a90f5cc009",
  "block_hash": "000000000000000000007e610e49cf1087a77eeece833ee16c7f68a90f5cc009",
  "block_time": 1791753450,
  "block_index": 970984,
  "block_height": 970984,
  "tx_index_count": 6722,
  "scraped_at": "2026-10-12T00:00:00+00:00"
}
```

The block values are illustrative examples rather than a live snapshot.

### Working with Your Dataset

1. Run the actor with your preferred currencies and addresses.
2. Open the resulting dataset.
3. Review the ticker, address, and latest-block records.
4. Export the data as JSON, CSV, or Excel.
5. Compare snapshots from separate runs to analyze changes over time.

### Important Notes

- Ticker quotes represent a snapshot at collection time, not a historical price series.
- Address balances and transaction totals are expressed in satoshis.
- Address transaction history is limited by the configured `maxTxPerAddress` value.
- The actor does not retrieve an unlimited transaction history for each address.
- The latest-block record represents the latest block information available when the data is collected.
- The maximum dataset size is controlled by `maxItems`.

### FAQ

**Does the actor collect multiple currencies?**

Yes. Provide the currency codes you want in the `currencies` array.

**Can I collect address balances without ticker quotes?**

Yes. Set `currencies` to an empty array and provide the addresses you want to examine.

**Can I skip the latest block record?**

Yes. Set `includeLatestBlock` to `false`.

**Are address balances displayed in BTC?**

The address amount fields, including `total_received`, `total_sent`, and `final_balance`, are expressed in satoshis.

**Does the actor return every transaction associated with an address?**

No. The number of transactions requested per address is controlled by `maxTxPerAddress`, which accepts values from 1 to 100.

**Can I export the results to a spreadsheet?**

Yes. Export the Apify dataset as CSV or Excel, or download it as JSON.

### Disclaimer

This actor is an independent data collection tool and is not affiliated with or endorsed by Blockchain.com or Bitcoin. Market quotes and blockchain information may change, and data availability depends on the publicly accessible information at collection time. Verify important figures independently before making financial decisions.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects information from public pages. It does not log in and it does not bypass access controls.

For a longer explanation, see Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

## `currencies` (type: `array`):

ISO currency codes to keep from the public BTC ticker. One code per line, such as USD or EUR. Each match is saved as its own row. Leave the list empty to skip the ticker.

## `addresses` (type: `array`):

Bitcoin addresses to summarize. One address per line. Each recognized address becomes one balance and transaction-count row.

## `maxTxPerAddress` (type: `integer`):

How many recent transactions to request for each address via the verified limit parameter. The row stores the newest transaction hash and the count returned, not every input and output.

## `includeLatestBlock` (type: `boolean`):

When checked, the run also saves one row for the latest Bitcoin block from the public latest-block endpoint.

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

Maximum number of dataset rows to save in this run, including error rows. Free-plan cap is 1000.

## `requestDelaySecs` (type: `number`):

Seconds to wait between public API calls. Values below 1 are raised to 1 so the run stays sequential and polite.

## `timeoutSecs` (type: `integer`):

Overall time limit for the run. The actor stops scheduling new requests when this limit is reached.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout for each call to the public explorer API.

## `proxyConfiguration` (type: `object`):

Optional proxy for requests. The default is no proxy. Turn on Apify Proxy only if the public API starts refusing your IP.

## Actor input object example

```json
{
  "currencies": [
    "USD",
    "EUR"
  ],
  "addresses": [
    "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
  ],
  "maxTxPerAddress": 50,
  "includeLatestBlock": true,
  "maxItems": 100,
  "requestDelaySecs": 1,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with ticker quotes, address summaries, the latest block, and error rows.

## `items` (type: `string`):

Dataset items as JSON.

## `overview` (type: `string`):

Dataset items using the overview table.

# 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 = {
    "currencies": [
        "USD",
        "EUR"
    ],
    "addresses": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/bitcoin-address-ticker-scraper-202610120341").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 = {
    "currencies": [
        "USD",
        "EUR",
    ],
    "addresses": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/bitcoin-address-ticker-scraper-202610120341").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 '{
  "currencies": [
    "USD",
    "EUR"
  ],
  "addresses": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call zerobreak/bitcoin-address-ticker-scraper-202610120341 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zerobreak/bitcoin-address-ticker-scraper-202610120341"
        }
    }
}
```

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/cWHfkmL76miVEmYnT/builds/jF0oekwZLyMhGIFyo/openapi.json