# Pump.fun Tweet Vision: Coins Announced by Their Own X Account (`winterlock/pump-fun-ca-post-feed`) Actor

Live feed of new pump.fun coins whose own linked X (Twitter) account posts the contract address. Each launch's linked X account is watched for 3 minutes; the moment it posts the CA, the coin is delivered with market cap, trades, followers and the tweet. Unfiltered.

- **URL**: https://apify.com/winterlock/pump-fun-ca-post-feed.md
- **Developed by:** [Alex Burton](https://apify.com/winterlock) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16.67 / 1,000 standard minutes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 CA Post Feed: Coins Announced by Their Own X Account

A live feed of brand-new pump.fun coins that are announced by their own X (Twitter) account. When a coin is launched with an X account linked in its metadata, that account is watched; if it posts the coin's contract address (CA) within three minutes of launch, the coin lands in your feed seconds later. It comes with its market cap and trading so far, the X account's followers and age, and the tweet itself.

Coins without a linked X account, and coins whose account never posts the CA, are never sent. Every coin that does get posted is sent, unfiltered, so you can apply your own rules.

Signals land in the run's dataset and, if you want, go straight to **Telegram**, **Discord** or **your own webhook**.

### How it works

1. Every pump.fun launch is picked up from Solana the moment it happens.
2. The coin's metadata is read for a linked X account.
3. That account is watched for three minutes, with X checked every 2.5 seconds.
4. If the account posts the coin's full contract address, the coin becomes a **signal**. A tweet that only mentions the name or ticker doesn't count.

There is no filter. You get every coin whose X account posts its address, and each row has the numbers you need to apply your own rules: market cap, trades and volume, the X account's followers, post count and age, the tweet's engagement, and how many coins the creator wallet has launched.

`detectionLagMs` on every row shows how long after the tweet the coin was detected.

### Pricing

| Feed | Price | Speed |
|---|---|---|
| **Free trial** | Free: one 30-minute run per Apify account | Standard delivery |
| **Standard** | **$1 per hour**, billed per started minute ($0.01667) | Standard delivery |
| **Fast** | **$3 per hour**, billed per started minute ($0.05) | Fastest delivery: each coin reaches you the moment it's detected, ahead of Standard |

- You pay for time, not for signals, and platform usage is included. A quiet hour costs the same as a busy one.
- Abort a run whenever you like. You only pay for the minutes that started.
- To cap spending, set **Stop after (minutes)** or your **maximum cost per run**. For example, a $2 cap on Standard runs for two hours and then stops on its own.
- Standard and Fast need a paid Apify plan. Free accounts can use the trial.

### How to use it

1. Pick a **Feed**. Start with the free trial to see a real half hour of signals.
2. Optionally set **Stop after (minutes)**, which is 60 by default.
3. Optionally add a Telegram bot, a Discord webhook or your own webhook URL.
4. Click **Start**. The run streams until it stops, and the dataset fills as signals arrive.

#### Example input: Fast feed for two hours, to Telegram

```json
{
  "tier": "fast",
  "maxMinutes": 120,
  "telegramBotToken": "123456789:AA...",
  "telegramChatId": "-1001234567890"
}
```

#### Setting up Telegram

1. Message **@BotFather** on Telegram, send `/newbot` and copy the token it gives you.
2. Add the bot to your group or channel. In a channel, make it an admin so it can post.
3. Put the chat ID in **Telegram chat ID**: a number such as `-1001234567890`, or `@yourchannel` for a public channel.

Alerts use the same layout in Telegram and Discord:

```
Pump Intelligence $PI  https://pump.fun/coin/7xHQxzPe3vDBDHwqCtPMhH1w8FyVF8PViZsiejpkpump
MCAP: 86.55 SOL
P: -25.29 · Max: 138.68 SOL (+52.13) · Min: 75.99 SOL (-10.56)
Twitter: https://x.com/davdevsx/status/2113269500317467031 (2639 followers, 2950 tweets)
Post stats: hidden views, 0 likes, 0 retweets
Twitter registered at: 2024-11-14 11:30:37 (1y)
Tweet posted after: 35s (took 6344ms)
Tokens: 1
```

### Output

One row per signal. This example is shortened:

```json
{
  "type": "signal",
  "name": "Pump Intelligence",
  "symbol": "PI",
  "mint": "7xHQxzPe3vDBDHwqCtPMhH1w8FyVF8PViZsiejpkpump",
  "pumpUrl": "https://pump.fun/coin/7xHQxzPe3vDBDHwqCtPMhH1w8FyVF8PViZsiejpkpump",
  "marketCapSol": 86.55,
  "launchMarketCapSol": 111.84,
  "maxMarketCapSol": 138.68,
  "minMarketCapSol": 75.99,
  "trades": 524,
  "volumeSol": 299.88,
  "xHandle": "davdevsx",
  "xProfileUrl": "https://x.com/davdevsx",
  "followers": 2639,
  "tweetCount": 2950,
  "accountCreatedAt": "2024-11-14T11:30:37Z",
  "accountAgeDays": 707.11,
  "tweetUrl": "https://x.com/davdevsx/status/2113269675044069562",
  "tweetViews": null,
  "tweetLikes": 0,
  "tweetRetweets": 0,
  "tweetPostedAfterLaunchS": 34.73,
  "detectionLagMs": 6344,
  "creator": "9BjcGY9ZfMvS13ozDRMwCaR2toE71hiLBXXvqBcGmeiU",
  "creatorLaunches": 1,
  "launchedAt": "2026-10-22T14:02:00Z",
  "detectedAt": "2026-10-22T14:02:41Z",
  "deliveredAt": "2026-10-22T14:02:41Z",
  "tier": "fast"
}
```

| Field | Meaning |
|---|---|
| `marketCapSol`, `launchMarketCapSol`, `maxMarketCapSol`, `minMarketCapSol` | Market cap in SOL when detected, at launch, and the high and low since launch |
| `trades`, `volumeSol` | Trades and SOL volume since launch |
| `followers`, `tweetCount`, `accountAgeDays` | The X account's size, how much it posts, and its age when the coin launched |
| `tweetViews`, `tweetLikes`, `tweetRetweets` | Engagement on the tweet. `tweetViews` is `null` when X hides the count |
| `tweetPostedAfterLaunchS` | Seconds between the launch and the tweet |
| `detectionLagMs` | Milliseconds between the tweet and its detection |
| `creatorLaunches` | How many coins this creator wallet has launched |
| `detectedAt`, `deliveredAt` | When the coin was detected and when it was delivered to you |

A summary of each run, covering minutes run, minutes charged and not charged, signals delivered and why the run stopped, is saved in the run's key-value store as `SUMMARY`.

### Use it from code

To start a Fast feed for two hours with every signal POSTed to your server, use the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/winterlock~pump-fun-ca-post-feed/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tier": "fast", "maxMinutes": 120, "webhookUrl": "https://your-server.example/pump-signal"}'
```

Your webhook gets each signal row as a JSON body, the same as the dataset rows above. To end the feed early, abort the run with `POST /v2/actor-runs/{runId}/abort`.

### Good to know

- **Each run is one live session.** Signals usually start within seconds; if nobody has used the feed for a while, it takes up to a minute to warm up. Your clock and billing start once the feed is live. To run around the clock, schedule a new run every few hours, or set a long timeout and use **Stop after (minutes)**.
- **Signals detected before a run stops are still delivered,** including any still on their way to you.
- **Outages aren't billed.** A minute that starts while the feed is paused (say, while it reconnects to Solana) is free, and a run stops on its own if the feed is down for 10 minutes. The run summary shows `minutesCharged` and `minutesNotCharged`.
- **The run timeout also ends a run.** If you leave Stop after empty, check the timeout under Run options.
- **Most coins never become signals.** A coin needs a linked X account that posts its contract address within three minutes. How many signals you get depends on how busy pump.fun is.
- **This is market data, not trading advice.** Most pump.fun coins lose most of their value.

### FAQ

**Does the feed filter coins?**
No. Every coin whose linked X account posts its contract address is delivered. Filtering is up to you: apply your own rules to the dataset fields, or in the code behind your webhook.

**What's the difference between Standard and Fast?**
Both feeds see the same coins. Fast is the quickest way to get them: each coin reaches you the moment it's detected, ahead of Standard. Standard suits research and watching what the feed finds; choose Fast if you act on signals.

**Can I run two feeds at once?**
Yes. Each run is a separate session, billed separately.

**Can I use the trial again?**
The trial is one 30-minute run per Apify account. After that, Standard costs $1 an hour.

**Does it buy or sell anything?**
No. It only reads public data from Solana and X, and it never touches a wallet.

# Actor input Schema

## `tier` (type: `string`):

Free trial: one 30-minute run per Apify account, standard delivery. Standard: $1 per hour, standard delivery. Fast: $3 per hour, fastest delivery: each coin reaches you the moment it's detected, ahead of Standard. Paid feeds are billed per started minute and need a paid Apify plan.

## `maxMinutes` (type: `integer`):

The run stops after this many minutes. Leave empty to keep it running until you abort it, your maximum cost per run is reached, or the run timeout ends it. The free trial always stops at 30 minutes.

## `telegramBotToken` (type: `string`):

Optional. Send every signal to Telegram: create a bot with @BotFather, add it to your chat or channel, and paste its token here.

## `telegramChatId` (type: `string`):

The chat, group or channel the bot posts to, e.g. 123456789 or -1001234567890 (a channel's @username also works).

## `discordWebhookUrl` (type: `string`):

Optional. Channel settings > Integrations > Webhooks > New webhook > Copy webhook URL.

## `webhookUrl` (type: `string`):

Optional. Every signal row is POSTed here as JSON the moment it is delivered.

## Actor input object example

```json
{
  "tier": "trial",
  "maxMinutes": 60
}
```

# Actor output Schema

## `signals` (type: `string`):

No description

## `summary` (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 = {
    "tier": "trial",
    "maxMinutes": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("winterlock/pump-fun-ca-post-feed").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 = {
    "tier": "trial",
    "maxMinutes": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("winterlock/pump-fun-ca-post-feed").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 '{
  "tier": "trial",
  "maxMinutes": 60
}' |
apify call winterlock/pump-fun-ca-post-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,winterlock/pump-fun-ca-post-feed"
        }
    }
}
```

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/DpFfXIOLhueCft3gS/builds/zdUJ4waqvJliJJBjL/openapi.json