# Pump.fun New Token Transactions Monitor (`muhammetakkurtt/pump-fun-new-token-transactions-monitor`) Actor

Real-time monitoring tool for tracking new token creations and their subsequent transactions on Pump.fun Solana platform. Captures token launches, tracks buy/sell operations, and records market data including price, volume, and reserves. Ideal for traders and analysts seeking instant market insights

- **URL**: https://apify.com/muhammetakkurtt/pump-fun-new-token-transactions-monitor.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** Developer tools, Other, Automation
- **Stats:** 72 total users, 2 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 token / trade records

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

![Pump.fun New Token Transactions Monitor - Real-time Solana Meme Token Tracking Tool](https://github.com/user-attachments/assets/a4b3567b-1ac8-4e46-88ca-a0185c6b37b4)

## Pump.fun New Token Transactions Monitor

An Apify actor that records newly created meme tokens and their buy/sell transactions on the Solana blockchain at [Pump.fun](https://pump.fun). Track market movements instantly!

### Overview

This tool monitors [Pump.fun](https://pump.fun) in real-time. It captures every new token the moment it is created and then streams the buy/sell transactions for those tokens as they happen. It is ideal for traders, analysts, and developers who want to catch launches and follow the flow of trades right after a token goes live.

### Key Features

- **New Token Detection**: Catches tokens seconds after they are created
- **Real-Time Transaction Streaming**: Buy/sell trades for each new token as they happen
- **Rich Data Collection**:
  - Trade details (buy/sell, token/SOL/USD amounts, price in SOL and USD)
  - Token information (name, symbol, mint address)
  - Market data (market cap, reserves, bonding curve status)
  - Trader and pool addresses
- **Customizable Settings**:
  - Flexible monitoring duration
  - Transaction limit per token
- **Single, Structured Output**: Every record is written to the run's default dataset

### Usage

1. Run the actor in the Apify console
2. Provide the following input parameters:
   - **monitoringDuration**: Monitoring duration in minutes (`0` = unlimited)
   - **tradeLimit**: Number of transactions to capture for each token (`0` = only new tokens, no transactions)

#### Example Input

```json
{
  "monitoringDuration": 3,
  "tradeLimit": 100
}
```

### Output

All records are saved to the run's **default Apify dataset**. Each record has a `type` field so you can tell the two record kinds apart:

- `type: "new_token"` — a newly created token
- `type: "trade"` — a buy/sell transaction on a monitored token

#### New Token record (`type: "new_token"`)

- `timestamp`: Detection time (UTC)
- `token_details`:
  - `signature`: Token creation transaction signature
  - `mint`: Token mint address
  - `traderPublicKey`: Creator address
  - `txType`: Transaction type (`"create"`)
  - `initialBuy`: Initial buy amount
  - `solAmount`: SOL amount
  - `bondingCurveKey`: Bonding curve address
  - `vTokensInBondingCurve`: Token reserve
  - `vSolInBondingCurve`: SOL reserve
  - `marketCapSol`: Market value (SOL)
  - `name`: Token name
  - `symbol`: Token symbol
  - `uri`: Token metadata URI

#### Trade record (`type: "trade"`)

- `timestamp`: Transaction time (UTC)
- `signature`: Transaction signature
- `mint_address`: Token mint address
- `token_name`: Token name
- `token_symbol`: Token symbol
- `trader_public_key`: Trader address
- `is_buy`: `true` for a buy, `false` for a sell
- `tx_type`: `"buy"` or `"sell"`
- `token_amount`: Token amount traded
- `sol_amount`: SOL amount
- `usd_amount`: USD amount
- `price_sol`: Token price in SOL
- `price_usd`: Token price in USD
- `market_cap_usd`: Market value (USD)
- `pool_address`: Pool address
- `is_bonding_curve`: Whether the trade happened on the bonding curve
- `virtual_sol_reserves`: Virtual SOL reserves
- `virtual_token_reserves`: Virtual token reserves
- `program`: Trading program

### Transaction Monitoring Control

Control how many transactions to capture per token with `tradeLimit`:

- **tradeLimit = 0**: Only capture new token creations, without any buy/sell transactions
- **tradeLimit > 0**: Capture the specified number of transactions for each token, then automatically stop following that token

This lets you cap the amount of data collected and focus on what matters most.

### Example Output

#### New Token record

```json
{
  "type": "new_token",
  "timestamp": "2026-02-08 19:49:34 UTC",
  "token_details": {
    "signature": "4b3gUjdvYpfieUUBxbcSASymXowffnLojNibronxeyDt4fNL8WMsbUzVtMmhWR94bzwXofmMJW2x2b97jK1voEvr",
    "mint": "DHSsYznX4KebawyyEP4aCNnjaq3bBaaDTzzXHhzCpump",
    "traderPublicKey": "8BvKowtWUhNoEyMbihtk1tzwCnhEfrFqxeKg5D5bCxGV",
    "txType": "create",
    "initialBuy": 27870129.870129,
    "solAmount": 0.8,
    "bondingCurveKey": "8xcQQFha9yUCHKzPs2EiQGVKPNaQei6MeHuqMnzpYFaN",
    "vTokensInBondingCurve": 1045129870.129871,
    "vSolInBondingCurve": 30.8,
    "marketCapSol": 29.470021745883763,
    "name": "Smol Monk",
    "symbol": "MONK",
    "uri": "https://ipfs.io/ipfs/QmZvdN3GAmkL4B87mbURff65EMUsUn8hG768SLH8PbFBta"
  }
}
```

#### Trade record

```json
{
  "type": "trade",
  "timestamp": "2026-02-08T19:49:36Z",
  "signature": "4FNxjxs8ZT8jAW39oeRKbekkLyrHD736Mm1XAfpPRSfikTiBre2E1hmKmo8guKdRsFyxTLSDTmM18TNjcUC4ToUP",
  "mint_address": "DHSsYznX4KebawyyEP4aCNnjaq3bBaaDTzzXHhzCpump",
  "token_name": "Smol Monk",
  "token_symbol": "MONK",
  "trader_public_key": "8h8C783QE93nY5TDBqMtu1ysGgynzPEjraRV1avav78V",
  "is_buy": true,
  "tx_type": "buy",
  "token_amount": 357666.583211,
  "sol_amount": 0.01054405,
  "usd_amount": 2.15,
  "price_sol": 2.87e-08,
  "price_usd": 3.19e-06,
  "market_cap_usd": 6021.44,
  "pool_address": "8xcQQFha9yUCHKzPs2EiQGVKPNaQei6MeHuqMnzpYFaN",
  "is_bonding_curve": true,
  "virtual_sol_reserves": 30.81,
  "virtual_token_reserves": 1044772203.54666,
  "program": "pump"
}
```

The actual output is a list of such objects for all tokens and trades captured during the run.

### Notes

- If `monitoringDuration` is set to `0`, monitoring runs indefinitely.
- If `tradeLimit` is set to `0`, only new token creations are captured, without any transactions.

### 🔗 Related Actors

#### [Pump.fun Token Scraper & Monitor](https://apify.com/muhammetakkurtt/pump-fun-token-scraper-monitor)

A powerful Apify actor that monitors and analyzes Solana (SOL) tokens on the Pump.fun platform in real-time. Track market capitalization, new token listings, trading volume, and King of the Hill tokens with comprehensive monitoring features. Don't miss opportunities in the Solana ecosystem!

[🔍 Click for Detailed Information and Usage Guide](https://apify.com/muhammetakkurtt/pump-fun-token-scraper-monitor)

#### [Pump.fun Real-Time Trade Monitor](https://apify.com/muhammetakkurtt/pump-fun-trade-monitor)

An advanced Apify actor that monitors and records real-time trade transactions of Solana (SOL) tokens on the Pump.fun platform. Track buy/sell transactions, trade volumes, and market movements instantly!

# Actor input Schema

## `monitoringDuration` (type: `integer`):

How long to monitor (in minutes, 0 = unlimited)

## `tradeLimit` (type: `integer`):

Number of transactions to monitor for each token (0 = no transaction monitoring, only new tokens)

## Actor input object example

```json
{
  "monitoringDuration": 1,
  "tradeLimit": 50
}
```

# Actor output Schema

## `records` (type: `string`):

New token records with their launch details, and trade records with side, SOL and USD amounts, price, market cap, trader wallet and transaction signature.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammetakkurtt/pump-fun-new-token-transactions-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/pump-fun-new-token-transactions-monitor").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 '{}' |
apify call muhammetakkurtt/pump-fun-new-token-transactions-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/pump-fun-new-token-transactions-monitor"
        }
    }
}
```

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/Sb6Zwdn1q0qpVNhps/builds/8joUrim3fpe85AwtV/openapi.json