# Aptos Mainnet Transactions Scraper (`acquistion-automation/aptos-mainnet-transactions-scraper`) Actor

Scrapes Aptos mainnet transactions from any ledger version. Returns each transaction as a flat row with hash, sender, payload, gas used, and timestamp. No API key or node required.

- **URL**: https://apify.com/acquistion-automation/aptos-mainnet-transactions-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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 Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## ⛓ Aptos Mainnet Transactions Scraper

> **Export Aptos mainnet transactions as flat rows.** Each row carries the ledger version, transaction hash, sender address, sequence number, gas used, success flag, VM status and on-chain timestamp. No API key, no node to run, no registration.

The Aptos ledger is public, but reading it means talking to a full node REST endpoint, paging by ledger version and flattening a nested JSON response before anything is usable in a spreadsheet. This Actor does that walk for you. Give it a starting ledger version, or none at all to begin at the latest block, and it writes one row per transaction into a dataset you can export.

| Who uses it | What they use the ledger for |
|---|---|
| 💼 Buyers of crypto-native businesses | Checking that a seller's claimed on-chain volume matches the ledger's own record |
| 🔍 Diligence analysts | Pulling the transaction history of a treasury or operating wallet into a spreadsheet |
| 📊 Quantitative and market researchers | Building a transaction-level dataset for gas, throughput and failure-rate analysis |
| 🛠 Product and protocol teams | Monitoring senders and contract activity without standing up an indexer |

### 📋 What it does

> 💡 **Why it matters:** when the asset you are buying is on-chain, the chain is the source of truth. One run turns a range of ledger versions into rows you can filter, sort and hand to a lender.

- 🔢 **Reads by ledger version.** Set `startVersion` to pick up from a known point, or leave it empty and the Actor starts at the latest block.
- 🧾 **One row per transaction**, with the same fields every run, so several runs append into one clean dataset.
- 🆔 **The identifiers you need for follow-up.** Full transaction hash and sender address, both in the form any Aptos explorer accepts.
- ⛽ **Execution detail.** Gas used, the success flag and the VM status string, so failed transactions are visible rather than silently dropped.
- 🕒 **On-chain timestamp** as the ledger records it, plus the time the row was collected.
- 💾 **Exports to CSV, Excel, JSON or XML**, from the run page or the API.

### 📊 Output

Every transaction is one flat row. Numeric ledger values arrive as strings, which is how the chain publishes them and what keeps large integers from losing precision in a spreadsheet.

| Field | Type | Description |
|---|---|---|
| 🔢 `version` | string | Ledger version of the transaction, the chain's sequential position |
| 🔗 `hash` | string | Transaction hash, `0x` prefixed |
| 👤 `sender` | string | Sending account address, `0x` prefixed |
| 🔁 `sequence_number` | string | Sender's sequence number for this transaction |
| ⛽ `gas_used` | string | Gas units consumed |
| ✅ `success` | boolean | `true` if the transaction executed, `false` if it failed |
| 📄 `vm_status` | string | Virtual machine result, for example `Executed successfully` |
| 🕐 `timestamp` | string | On-chain timestamp in microseconds since the Unix epoch |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |

#### Example rows

```json
{
  "version": "7206045167",
  "hash": "0x36340a90f9c84a3833dde9815a888402e1be9de584777943acd370647c454c6d",
  "sender": "0xbf40935e0e6f0515cddf3e884ea7ebf1488f1292e0313f080c88102d8e0564f4",
  "sequence_number": "18446744073709551615",
  "gas_used": "1203",
  "success": true,
  "vm_status": "Executed successfully",
  "timestamp": "1789402875663638",
  "scrapedAt": "2026-09-14T16:21:15.868Z",
  "error": null
}
```

```json
{
  "version": "7206045168",
  "hash": "0x200b88e99a4a82f2d6d13ca4eeeb47cabbacacb2ac09092681661d55dd4d2847",
  "sender": "0xd503b95164384a5ebbccbb5c4bdc8b4a5893d9651e9953abda8e1c22fcc1181d",
  "sequence_number": "0",
  "gas_used": "353",
  "success": true,
  "vm_status": "Executed successfully",
  "timestamp": "1789402875663638",
  "scrapedAt": "2026-09-14T16:21:15.955Z",
  "error": null
}
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **No node, no indexer** | Reading Aptos directly means running or renting infrastructure. Here you set an input and press start. |
| **No API key** | Nothing to register for, nothing to rotate, no rate-limit negotiation. |
| **The same 10 fields every run** | Append a month of pulls into one dataset without cleaning columns. |
| **Failures are kept** | A reverted transaction still produces a row, with `success` false and the VM status attached. |
| **You pay per row** | No subscription. A run that returns nothing costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Leave `startVersion` empty to begin at the latest block, or paste a ledger version to start there.
4. Set `maxItems` to cap the run.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run, starting at the latest block:

```json
{
  "maxItems": 10
}
```

A larger pull from a known ledger version:

```json
{
  "startVersion": "7206045167",
  "maxItems": 5000
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `startVersion` | No | Ledger version to start from. Leave empty for the latest block |
| `maxItems` | No | Maximum transactions to collect in a run. Free plan is capped at 10, paid plans up to 1,000,000 |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per transaction row | $0.0085 | $0.00817 | $0.00783 | $0.0075 | $0.0075 | $0.0075 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $0.85 |
| 1,000 | $8.50 |
| 10,000 | $85.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🤖 Use with an AI agent

Give an agent live access to the Aptos ledger over the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/aptos-mainnet-transactions-scraper"
```

Then ask it in plain language to pull a range of transactions and read the result back.

### ❓ Frequently asked questions

**Does a row include the transaction payload, events or state changes?**
No. Each row carries the 10 fields listed above: version, hash, sender, sequence number, gas used, success, VM status, timestamp, and the two collection fields. Payload arguments, emitted events and write sets are not returned.

**Which chain does it read?**
Aptos mainnet only. Testnet and devnet are not covered.

**What is `timestamp` measured in?**
Microseconds since the Unix epoch, which is how the Aptos ledger publishes it. Divide by 1,000,000 for seconds before converting to a date.

**Why is `sequence_number` sometimes a very large number?**
System transactions, such as block metadata, carry the maximum unsigned 64-bit value, `18446744073709551615`, instead of a real sender sequence. User transactions count up from zero.

**Do I need a proxy or a node endpoint?**
No. Requests and retries are handled inside the Actor and included in the price.

**What can I export?**
CSV, Excel, JSON and XML from the run page, or JSON straight from the API.

### 🔗 More from Acquisition Automation Co.

- [BitMart Markets Scraper](https://apify.com/acquistion-automation/bitmart-markets-scraper)
- [SAM.gov Contract Opportunities Scraper](https://apify.com/acquistion-automation/sam-gov-contracts-scraper)
- [IRS Exempt Organizations Scraper](https://apify.com/acquistion-automation/irs-eo-master-file-scraper)
- [USCG PSIX Vessel Registry Scraper](https://apify.com/acquistion-automation/uscg-psix-vessel-incidents-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by Aptos Labs or the Aptos Foundation. It collects only publicly available on-chain data. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

## `startVersion` (type: `string`):

Optional ledger version to start from. Leave empty for the latest block.

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

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

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/aptos-mainnet-transactions-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/aptos-mainnet-transactions-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 '{
  "maxItems": 10
}' |
apify call acquistion-automation/aptos-mainnet-transactions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/aptos-mainnet-transactions-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/MSJa7wZuZx22Kak0V/builds/WBFElelVgYFHgBEGr/openapi.json