Enhanced Stream
The PumpFun API for real-time Solana token launches, trades, and graduations
Pump.fun is the busiest memecoin pipe on Solana. Millions of trades a day across thousands of bonding curves, with graduations migrating tokens into PumpSwap and Raydium CPMM. The way most third-party APIs handle this is REST plus polling, which is slow enough that by the time you see a new token, the price has 4x'd. We push every Pump.fun event to your app the moment it lands: token creations, buys, sells, graduations, and the MEV-relevant transaction metadata (compute budget, priority fee, Jito tip). One gRPC connection. Sub-50ms p99. JSON or Protobuf, your choice.
Sub-50ms latencyToken creations + tradesGraduations & migrationsMEV transaction metadataJSON or ProtobufNo rate limits
On-chain programs
- Pump.fun bonding curve6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P, The launchpad program emitting create / buy / sell / migrate instructions
- PumpSwap AMM (graduation target)pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA, Where graduated bonding curves settle as AMM pools
Try it live: PumpFun streams
decoded solana events over grpc · click Run to see live data
4 streamslive
PumpFun Trades
1grpcurl -H "x-api-key: YOUR_API_KEY" \
2 -d '{"topic":"prod.rpc.solana.pumpfun.trade","format":"JSON"}' \
3 stream-1.nln.clr3.org:443 nln.stream.v1.StreamService/SubscribeLive Output
See real data
Click Run to stream 5 live PumpFun Trades messages
Pro: 2 streams $49/mo · Ultra: 20 streams $199/mo · pre-parsed, zero infra
PumpFun streaming performance
last reviewed 2026-04-28
End-to-end latency
<50ms
p50 from on-chain transaction to your callback
Verified 2026-04-28
Daily Pump.fun events
2M+
Across creations, trades, and graduations on busy days
Stream uptime SLO
99.99%
Pro and Ultra plans, monthly rolling
Time to first event
5 min
Signup → API key → live stream
Token creations
CreateEntrytopic = prod.rpc.solana.pumpfun.create
Fires every time a new token is launched on Pump.fun. Includes the mint, the bonding curve, the creator wallet, the initial reserves, and the metadata URI, everything a sniper needs to size and submit a buy in the next slot.
| Field | Type | Description |
|---|---|---|
| signature | string | Transaction signature |
| tx_index | uint64 | Transaction index in the block |
| bonding_curve | string | Bonding curve account address |
| creator | string | Wallet that created the token |
| is_mayhem_mode | bool? | Whether token was created in mayhem mode |
| mint | string | Token mint address |
| name | string | Token display name |
| symbol | string | Token ticker symbol |
| uri | string | Metadata JSON URI |
| token_program | string? | SPL Token or Token-2022 program |
| token_total_supply | string | Total supply (raw units) |
| real_token_reserves | string | Real token reserves in bonding curve |
| virtual_sol_reserves | string | Virtual SOL reserves (lamports) |
| virtual_token_reserves | string | Virtual token reserves (raw) |
| user | string | Wallet that signed the transaction |
| timestamp | string | Unix timestamp |
| slot | uint64 | Solana slot number |
| block_time | string | Block timestamp |
Sample payload
{
"signature": "3Kf63DJexeo99sgZXnk52cKvnRojNFHv...",
"tx_index": "724",
"bonding_curve": "2z9Jxwzv7W7w7dczbViNKgLM7QHCJzhA3MeMjwRFYkN1",
"creator": "FjXrmGSiAhYw17fiCboZaTQMCQ8RtLte7XymZPhkGGwb",
"is_mayhem_mode": false,
"mint": "HakYYnqeNDt8xweEfznycLxvxLmXUagYXcc4bP7aVwah",
"name": "Mega Viral",
"symbol": "Kyupiin",
"uri": "https://mwgy.us/m/xOdV.json",
"token_program": "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb",
"token_total_supply": "1000000000000000",
"real_token_reserves": "793100000000000",
"virtual_sol_reserves": "30000000000",
"virtual_token_reserves": "1073000000000000",
"user": "FjXrmGSiAhYw17fiCboZaTQMCQ8RtLte7XymZPhkGGwb",
"timestamp": "1775629975",
"slot": "411796395",
"block_time": "1775629975"
}Subscribe to token creations
topic: prod.rpc.solana.pumpfun.create
import Client from "@grpc/grpc-js";
import { StreamServiceClient } from "./gen/stream_service_grpc_pb";
import { SubscribeRequest } from "./gen/stream_service_pb";
const client = new StreamServiceClient(
"stream-1.nln.clr3.org:443",
Client.credentials.createSsl()
);
const metadata = new Client.Metadata();
metadata.set("x-api-key", "YOUR_API_KEY");
const req = new SubscribeRequest();
req.setTopic("prod.rpc.solana.pumpfun.create");
req.setFormat(1); // JSON
const stream = client.subscribe(req, metadata);
stream.on("data", (msg) => {
const data = JSON.parse(Buffer.from(msg.getPayload()).toString());
console.log(data);
});
stream.on("error", (err) => console.error("Stream error:", err));import grpc, json
from stream_service_pb2 import SubscribeRequest
from stream_service_pb2_grpc import StreamServiceStub
channel = grpc.secure_channel("stream-1.nln.clr3.org:443",
grpc.ssl_channel_credentials())
stub = StreamServiceStub(channel)
metadata = [("x-api-key", "YOUR_API_KEY")]
request = SubscribeRequest(topic="prod.rpc.solana.pumpfun.create", format=1)
for msg in stub.Subscribe(request, metadata=metadata):
print(json.loads(msg.payload))use tonic::transport::{Channel, ClientTlsConfig};
use tonic::metadata::MetadataValue;
mod proto { tonic::include_proto!("nln.stream.v1"); }
use proto::stream_service_client::StreamServiceClient;
use proto::{OutputFormat, SubscribeRequest};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let tls = ClientTlsConfig::new().with_native_roots();
let channel = Channel::from_static("https://stream-1.nln.clr3.org:443")
.tls_config(tls)?.connect().await?;
let api_key: MetadataValue<_> = "YOUR_API_KEY".parse()?;
let mut client = StreamServiceClient::with_interceptor(channel,
move |mut req: tonic::Request<()>| {
req.metadata_mut().insert("x-api-key", api_key.clone());
Ok(req)
});
let req = SubscribeRequest {
topic: "prod.rpc.solana.pumpfun.create".into(),
format: OutputFormat::Json.into(),
};
let mut stream = client.subscribe(req).await?.into_inner();
while let Some(msg) = stream.message().await? {
let v: serde_json::Value = serde_json::from_slice(&msg.payload)?;
println!("{}", v);
}
Ok(())
}package main
import (
"context"
"encoding/json"
"fmt"
"log"
pb "your_module/gen/nln/stream/v1"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
func main() {
conn, _ := grpc.Dial("stream-1.nln.clr3.org:443",
grpc.WithTransportCredentials(credentials.NewTLS(nil)))
defer conn.Close()
client := pb.NewStreamServiceClient(conn)
ctx := metadata.AppendToOutgoingContext(context.Background(),
"x-api-key", "YOUR_API_KEY")
stream, _ := client.Subscribe(ctx, &pb.SubscribeRequest{
Topic: "prod.rpc.solana.pumpfun.create", Format: pb.OutputFormat_JSON,
})
for {
msg, err := stream.Recv()
if err != nil { log.Fatal(err) }
var v map[string]interface{}
json.Unmarshal(msg.Payload, &v)
fmt.Println(v)
}
}# Subscribe to prod.rpc.solana.pumpfun.create via grpcurl
grpcurl \
-H "x-api-key: YOUR_API_KEY" \
-d '{"topic":"prod.rpc.solana.pumpfun.create","format":"JSON"}' \
stream-1.nln.clr3.org:443 \
nln.stream.v1.StreamService/SubscribeTrades
TradeEntrytopic = prod.rpc.solana.pumpfun.trade
Every buy and sell on the Pump.fun bonding curve. Includes SOL/token amounts, the post-trade reserves state, fees, creator fees, and the instruction name (buy or sell).
| Field | Type | Description |
|---|---|---|
| signature | string | Transaction signature |
| tx_index | uint64 | Transaction index in the block |
| mint | string | Token mint address |
| sol_amount | string | SOL amount (lamports) |
| token_amount | string | Token amount (raw units) |
| is_buy | bool | True if buy, false if sell |
| user | string | Trader wallet address |
| timestamp | string | Unix timestamp |
| virtual_sol_reserves | string | Virtual SOL reserves after trade |
| virtual_token_reserves | string | Virtual token reserves after trade |
| real_sol_reserves | string | Real SOL reserves after trade |
| real_token_reserves | string | Real token reserves after trade |
| fee_recipient | string | Fee recipient address |
| fee_basis_points | string | Fee in basis points |
| fee | string | Fee amount (lamports) |
| creator | string | Token creator wallet |
| creator_fee_basis_points | string | Creator fee basis points |
| creator_fee | string | Creator fee amount |
| ix_name | string? | Instruction name ("buy" or "sell") |
| slot | uint64 | Solana slot number |
| block_time | string | Block timestamp |
Sample payload
{
"signature": "2FhofrT4F6vY88bkSsrfYkqzsuYoM6oz...",
"tx_index": "1068",
"mint": "6DLtSmrUzpoijBnF6SYgErWkeXPw2xCff3VMNxkYpump",
"sol_amount": "13636072",
"token_amount": "488316041498",
"is_buy": false,
"user": "BwWK17cbHxwWBKZkUYvzxLcNQ1YVyaFezduWbtm2de6s",
"timestamp": "1775630038",
"virtual_sol_reserves": "21741714044",
"virtual_token_reserves": "1071646576884438",
"real_sol_reserves": "36166972",
"real_token_reserves": "791746576884438",
"fee": "0",
"creator": "8Kx61ptBPNLiG6SvDBA1XAwpzLhsw88Z9cSS1iQNDY3x",
"creator_fee": "0",
"ix_name": "sell",
"slot": "411796554"
}Subscribe to trades
topic: prod.rpc.solana.pumpfun.trade
import Client from "@grpc/grpc-js";
import { StreamServiceClient } from "./gen/stream_service_grpc_pb";
import { SubscribeRequest } from "./gen/stream_service_pb";
const client = new StreamServiceClient(
"stream-1.nln.clr3.org:443",
Client.credentials.createSsl()
);
const metadata = new Client.Metadata();
metadata.set("x-api-key", "YOUR_API_KEY");
const req = new SubscribeRequest();
req.setTopic("prod.rpc.solana.pumpfun.trade");
req.setFormat(1); // JSON
const stream = client.subscribe(req, metadata);
stream.on("data", (msg) => {
const data = JSON.parse(Buffer.from(msg.getPayload()).toString());
console.log(data);
});
stream.on("error", (err) => console.error("Stream error:", err));import grpc, json
from stream_service_pb2 import SubscribeRequest
from stream_service_pb2_grpc import StreamServiceStub
channel = grpc.secure_channel("stream-1.nln.clr3.org:443",
grpc.ssl_channel_credentials())
stub = StreamServiceStub(channel)
metadata = [("x-api-key", "YOUR_API_KEY")]
request = SubscribeRequest(topic="prod.rpc.solana.pumpfun.trade", format=1)
for msg in stub.Subscribe(request, metadata=metadata):
print(json.loads(msg.payload))use tonic::transport::{Channel, ClientTlsConfig};
use tonic::metadata::MetadataValue;
mod proto { tonic::include_proto!("nln.stream.v1"); }
use proto::stream_service_client::StreamServiceClient;
use proto::{OutputFormat, SubscribeRequest};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let tls = ClientTlsConfig::new().with_native_roots();
let channel = Channel::from_static("https://stream-1.nln.clr3.org:443")
.tls_config(tls)?.connect().await?;
let api_key: MetadataValue<_> = "YOUR_API_KEY".parse()?;
let mut client = StreamServiceClient::with_interceptor(channel,
move |mut req: tonic::Request<()>| {
req.metadata_mut().insert("x-api-key", api_key.clone());
Ok(req)
});
let req = SubscribeRequest {
topic: "prod.rpc.solana.pumpfun.trade".into(),
format: OutputFormat::Json.into(),
};
let mut stream = client.subscribe(req).await?.into_inner();
while let Some(msg) = stream.message().await? {
let v: serde_json::Value = serde_json::from_slice(&msg.payload)?;
println!("{}", v);
}
Ok(())
}package main
import (
"context"
"encoding/json"
"fmt"
"log"
pb "your_module/gen/nln/stream/v1"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
func main() {
conn, _ := grpc.Dial("stream-1.nln.clr3.org:443",
grpc.WithTransportCredentials(credentials.NewTLS(nil)))
defer conn.Close()
client := pb.NewStreamServiceClient(conn)
ctx := metadata.AppendToOutgoingContext(context.Background(),
"x-api-key", "YOUR_API_KEY")
stream, _ := client.Subscribe(ctx, &pb.SubscribeRequest{
Topic: "prod.rpc.solana.pumpfun.trade", Format: pb.OutputFormat_JSON,
})
for {
msg, err := stream.Recv()
if err != nil { log.Fatal(err) }
var v map[string]interface{}
json.Unmarshal(msg.Payload, &v)
fmt.Println(v)
}
}# Subscribe to prod.rpc.solana.pumpfun.trade via grpcurl
grpcurl \
-H "x-api-key: YOUR_API_KEY" \
-d '{"topic":"prod.rpc.solana.pumpfun.trade","format":"JSON"}' \
stream-1.nln.clr3.org:443 \
nln.stream.v1.StreamService/SubscribeGraduations
GraduateEventtopic = prod.rpc.solana.pumpfun.graduate
Fires when a token completes its bonding curve and migrates to a DEX (PumpSwap or Raydium CPMM). Includes the new pool address, the migrated SOL and token amounts, and the migration fee.
| Field | Type | Description |
|---|---|---|
| signature | string | Transaction signature |
| slot | uint64 | Solana slot number |
| tx_index | uint32 | Transaction index in the block |
| user | string | Wallet that triggered graduation |
| mint | string | Graduated token mint address |
| mint_amount | uint64 | Token amount moved to pool |
| sol_amount | uint64 | SOL amount moved to pool (lamports) |
| pool_migration_fee | uint64 | Migration fee (lamports) |
| bonding_curve | string | Bonding curve account address |
| timestamp | int64 | Unix timestamp |
| pool | string | New PumpSwap/Raydium pool address |
Sample payload
{
"signature": "5YmGe3F9kxQ8v7B2pWzN...",
"slot": "411800123",
"tx_index": 42,
"user": "D9hiiHLWMdyZgDCnDm5goGcrvLzXVa3QmLQpaGvkWoXi",
"mint": "AXWt2Ay6RuMqxD8FKMzs83ARzQPKSj6HtHE1k2Vxpump",
"mint_amount": 206900000000000,
"sol_amount": 78500000000,
"pool_migration_fee": 1500000000,
"bonding_curve": "ByYaWkuWFWEFsjPbWYTbF7GVDMc9MkhUVkucjawpvh4T",
"timestamp": 1775630100,
"pool": "8kJfq3Dm1Jv4e9WkBpTz6nEQ7PzGbiCfShNqR2Vxpump"
}Subscribe to graduations
topic: prod.rpc.solana.pumpfun.graduate
import Client from "@grpc/grpc-js";
import { StreamServiceClient } from "./gen/stream_service_grpc_pb";
import { SubscribeRequest } from "./gen/stream_service_pb";
const client = new StreamServiceClient(
"stream-1.nln.clr3.org:443",
Client.credentials.createSsl()
);
const metadata = new Client.Metadata();
metadata.set("x-api-key", "YOUR_API_KEY");
const req = new SubscribeRequest();
req.setTopic("prod.rpc.solana.pumpfun.graduate");
req.setFormat(1); // JSON
const stream = client.subscribe(req, metadata);
stream.on("data", (msg) => {
const data = JSON.parse(Buffer.from(msg.getPayload()).toString());
console.log(data);
});
stream.on("error", (err) => console.error("Stream error:", err));import grpc, json
from stream_service_pb2 import SubscribeRequest
from stream_service_pb2_grpc import StreamServiceStub
channel = grpc.secure_channel("stream-1.nln.clr3.org:443",
grpc.ssl_channel_credentials())
stub = StreamServiceStub(channel)
metadata = [("x-api-key", "YOUR_API_KEY")]
request = SubscribeRequest(topic="prod.rpc.solana.pumpfun.graduate", format=1)
for msg in stub.Subscribe(request, metadata=metadata):
print(json.loads(msg.payload))use tonic::transport::{Channel, ClientTlsConfig};
use tonic::metadata::MetadataValue;
mod proto { tonic::include_proto!("nln.stream.v1"); }
use proto::stream_service_client::StreamServiceClient;
use proto::{OutputFormat, SubscribeRequest};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let tls = ClientTlsConfig::new().with_native_roots();
let channel = Channel::from_static("https://stream-1.nln.clr3.org:443")
.tls_config(tls)?.connect().await?;
let api_key: MetadataValue<_> = "YOUR_API_KEY".parse()?;
let mut client = StreamServiceClient::with_interceptor(channel,
move |mut req: tonic::Request<()>| {
req.metadata_mut().insert("x-api-key", api_key.clone());
Ok(req)
});
let req = SubscribeRequest {
topic: "prod.rpc.solana.pumpfun.graduate".into(),
format: OutputFormat::Json.into(),
};
let mut stream = client.subscribe(req).await?.into_inner();
while let Some(msg) = stream.message().await? {
let v: serde_json::Value = serde_json::from_slice(&msg.payload)?;
println!("{}", v);
}
Ok(())
}package main
import (
"context"
"encoding/json"
"fmt"
"log"
pb "your_module/gen/nln/stream/v1"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
func main() {
conn, _ := grpc.Dial("stream-1.nln.clr3.org:443",
grpc.WithTransportCredentials(credentials.NewTLS(nil)))
defer conn.Close()
client := pb.NewStreamServiceClient(conn)
ctx := metadata.AppendToOutgoingContext(context.Background(),
"x-api-key", "YOUR_API_KEY")
stream, _ := client.Subscribe(ctx, &pb.SubscribeRequest{
Topic: "prod.rpc.solana.pumpfun.graduate", Format: pb.OutputFormat_JSON,
})
for {
msg, err := stream.Recv()
if err != nil { log.Fatal(err) }
var v map[string]interface{}
json.Unmarshal(msg.Payload, &v)
fmt.Println(v)
}
}# Subscribe to prod.rpc.solana.pumpfun.graduate via grpcurl
grpcurl \
-H "x-api-key: YOUR_API_KEY" \
-d '{"topic":"prod.rpc.solana.pumpfun.graduate","format":"JSON"}' \
stream-1.nln.clr3.org:443 \
nln.stream.v1.StreamService/SubscribeTransaction metadata (MEV)
PumpfunTransactiontopic = prod.rpc.solana.pumpfun.transaction
MEV-focused transaction metadata: compute budget, priority fee, Jito tip, instruction count, and unique program IDs touched. The signal layer for MEV searchers and gas-optimization research.
| Field | Type | Description |
|---|---|---|
| signature | string? | Transaction signature |
| slot | uint64? | Solana slot number |
| tx_index | uint32? | Transaction index in the block |
| first_signer | string? | First signer (fee payer) wallet |
| num_signers | uint32? | Number of signers |
| signers_hashed | string? | MD5 hash of all signers |
| compute_unit_limit | uint64? | Compute unit limit requested |
| compute_unit_price | uint64? | Compute unit price (micro-lamports) |
| priority_fee | uint64? | Priority fee (lamports) |
| tip_provider | uint32? | Tip provider ID (e.g., Jito) |
| tip_wallet | string? | Tip recipient wallet |
| tip_amount | uint64? | Tip amount (lamports) |
| is_inner_instruction | bool? | Whether PumpFun ix is a CPI |
| ix_count | uint32? | Total instruction count |
| iix_count | uint32? | Inner instruction count |
| unique_programs | string? | Comma-separated unique program IDs |
Sample payload
{
"signature": "UpzhqxTT4djEbPeNoejjxczGfX3afrfX...",
"slot": "411796627",
"tx_index": 41,
"first_signer": "DMw5597ixEk71fkdgcgZjCTaVXmtCKiA74gKDNDjpct2",
"compute_unit_limit": "400000",
"compute_unit_price": "25000",
"priority_fee": "10000",
"tip_provider": 1,
"tip_amount": "1000000",
"ix_count": 6,
"iix_count": 10
}Subscribe to transaction metadata (mev)
topic: prod.rpc.solana.pumpfun.transaction
import Client from "@grpc/grpc-js";
import { StreamServiceClient } from "./gen/stream_service_grpc_pb";
import { SubscribeRequest } from "./gen/stream_service_pb";
const client = new StreamServiceClient(
"stream-1.nln.clr3.org:443",
Client.credentials.createSsl()
);
const metadata = new Client.Metadata();
metadata.set("x-api-key", "YOUR_API_KEY");
const req = new SubscribeRequest();
req.setTopic("prod.rpc.solana.pumpfun.transaction");
req.setFormat(1); // JSON
const stream = client.subscribe(req, metadata);
stream.on("data", (msg) => {
const data = JSON.parse(Buffer.from(msg.getPayload()).toString());
console.log(data);
});
stream.on("error", (err) => console.error("Stream error:", err));import grpc, json
from stream_service_pb2 import SubscribeRequest
from stream_service_pb2_grpc import StreamServiceStub
channel = grpc.secure_channel("stream-1.nln.clr3.org:443",
grpc.ssl_channel_credentials())
stub = StreamServiceStub(channel)
metadata = [("x-api-key", "YOUR_API_KEY")]
request = SubscribeRequest(topic="prod.rpc.solana.pumpfun.transaction", format=1)
for msg in stub.Subscribe(request, metadata=metadata):
print(json.loads(msg.payload))use tonic::transport::{Channel, ClientTlsConfig};
use tonic::metadata::MetadataValue;
mod proto { tonic::include_proto!("nln.stream.v1"); }
use proto::stream_service_client::StreamServiceClient;
use proto::{OutputFormat, SubscribeRequest};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let tls = ClientTlsConfig::new().with_native_roots();
let channel = Channel::from_static("https://stream-1.nln.clr3.org:443")
.tls_config(tls)?.connect().await?;
let api_key: MetadataValue<_> = "YOUR_API_KEY".parse()?;
let mut client = StreamServiceClient::with_interceptor(channel,
move |mut req: tonic::Request<()>| {
req.metadata_mut().insert("x-api-key", api_key.clone());
Ok(req)
});
let req = SubscribeRequest {
topic: "prod.rpc.solana.pumpfun.transaction".into(),
format: OutputFormat::Json.into(),
};
let mut stream = client.subscribe(req).await?.into_inner();
while let Some(msg) = stream.message().await? {
let v: serde_json::Value = serde_json::from_slice(&msg.payload)?;
println!("{}", v);
}
Ok(())
}package main
import (
"context"
"encoding/json"
"fmt"
"log"
pb "your_module/gen/nln/stream/v1"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
func main() {
conn, _ := grpc.Dial("stream-1.nln.clr3.org:443",
grpc.WithTransportCredentials(credentials.NewTLS(nil)))
defer conn.Close()
client := pb.NewStreamServiceClient(conn)
ctx := metadata.AppendToOutgoingContext(context.Background(),
"x-api-key", "YOUR_API_KEY")
stream, _ := client.Subscribe(ctx, &pb.SubscribeRequest{
Topic: "prod.rpc.solana.pumpfun.transaction", Format: pb.OutputFormat_JSON,
})
for {
msg, err := stream.Recv()
if err != nil { log.Fatal(err) }
var v map[string]interface{}
json.Unmarshal(msg.Payload, &v)
fmt.Println(v)
}
}# Subscribe to prod.rpc.solana.pumpfun.transaction via grpcurl
grpcurl \
-H "x-api-key: YOUR_API_KEY" \
-d '{"topic":"prod.rpc.solana.pumpfun.transaction","format":"JSON"}' \
stream-1.nln.clr3.org:443 \
nln.stream.v1.StreamService/SubscribeWhat teams build on this stream
Sniper bots
Subscribe to the create topic and act on new mints in the next slot. The decoded payload includes the bonding curve, initial reserves, and the creator wallet, which is enough to size and submit a Jito-bundled buy without a separate getMint round-trip. The latency budget is mostly your code.
Copy trading
Filter the trade topic by leader-trader wallet and replicate sized buys and sells in the next slot. Sub-50ms parsing keeps most of the alpha intact even on volatile memecoin pairs.
MEV & priority-fee analytics
The transaction topic surfaces compute-unit price, priority fee, and Jito tip on every Pump.fun transaction. Drives block-builder pricing, anti-frontrun logic, and the gas-burn dashboards your CFO actually wants.
Graduation alerts
Subscribe to the graduate topic and pair with the PumpSwap stream to capture both legs of a migration in the same transaction. The most-watched signal in memecoin trading.
Pricing, and where we sit vs the rest
The Pump.fun data market splits three ways. PumpPortal sells per-message WebSocket. Cheap on a quiet day, expensive on a memecoin Tuesday. Bitquery sells GraphQL with deep historical queries. Best for analytics and post-hoc work; weaker for sub-second decisioning. Shyft ships parsed gRPC streams that overlap with our coverage. We charge flat, $49/month for two streams and $199/month for twenty, with no per-event surcharge and explicit MEV-transaction coverage that the others don't have.
Pro covers most production sniper and copy-trading workloads. Ultra adds 30 hours per month of custom Geyser-plugin development time, useful for teams that want a custom decoder fused with the existing parsed streams. Full breakdown is on the pricing page.
Frequently asked questions
Every Pump.fun event on Solana, pushed to your app the moment it lands on chain. Token creations, trades, bonding-curve graduations, and MEV-relevant transaction metadata. One gRPC connection. Decoded structures, not raw logs. Under 50ms from the on-chain transaction to your callback.
Under 50ms from the on-chain transaction. You get the token mint, name, symbol, creator wallet, and bonding-curve reserves the instant the create instruction lands. Fast enough to size and submit a buy in the next slot, which is what every serious sniper bot needs.
Yes, and it's one of the most common things people build with us. The create topic surfaces the mint, bonding curve, and initial reserves before any aggregator catches up. Several production bot operators run on us for the latency, the flat-rate pricing, and the fact that there's no per-event meter that goes ugly when memecoin Tuesday hits.
Four topics cover the full lifecycle: prod.rpc.solana.pumpfun.create (new token launches with metadata), .trade (every buy and sell on the bonding curve), .graduate (when a token completes its curve and migrates to PumpSwap or Raydium), and .transaction (compute budget, priority fee, Jito tip, and the MEV-relevant transaction metadata). Subscribe to any combination.
Both. format=1 returns JSON, format=2 returns Protobuf. Same stream, same fields, your call. JSON for debugging and scripting; Protobuf when you're optimizing throughput in production.
PumpPortal: per-message WebSocket. Easy to start, costs spike during memecoin peaks. Bitquery: GraphQL with deep historical queries. Excellent for analytics, less suited to sub-second decisioning. Shyft: gRPC streams that overlap with our coverage. We charge flat ($49/month for 2, $199/month for 20), no per-event meter, plus explicit MEV-transaction coverage that the others don't have.
JavaScript, Python, Rust, Go, anything with gRPC support. Code samples for each are above. Most developers are streaming live Pump.fun data inside five minutes of getting their API key.
Subscribe to prod.rpc.solana.pumpfun.graduate. Each event has the token mint, the new pool address (PumpSwap or Raydium CPMM), the migrated SOL and token amounts, and the migration fee. Use it to trigger alerts, provide post-graduation liquidity, or hedge. The companion PumpSwap stream catches the create_pool instruction that fires in the same transaction.
Pro ($49/month, 2 concurrent streams) and Ultra ($199/month, 20 concurrent streams). The free tier includes RPC, WebSocket, and gRPC node access but no parsed streams. Sign up free to validate the connection, upgrade when you're ready to stream.
Related products
PumpSwap real-time stream
Catch Pump.fun → PumpSwap migrations and post-graduation trades in the same gRPC feed.
Historical Pump.fun data
Backfill every token, every trade, every graduation since the program launched.
Raydium AMM v4 + CLMM + CPMM
Some Pump.fun-style tokens migrate via Raydium Launchpad, companion stream.
Pump.fun program explorer
Browse every decoded instruction and event the bonding-curve program emits.
Yellowstone gRPC nodes
The transport layer behind every NoLimitNodes Pump.fun subscription.
All Enhanced Streams
18 curated topics across DEXes, lifecycle, and system events. The catalog hub.
Start streaming PumpFun in under 5 minutes
Pro plan from $49/mo includes 2 parsed streams. Pick any two of create, trade, graduate, transaction. Or combine with PumpSwap, Raydium, Orca, Meteora.