Docs›API Reference

API endpoints

This is the main API reference. It explains which route to use, which key to send, and where control stays with the user.

How to read these docs: start with the option that fits how you want to work. Use Lightning for server-side trading, Local Build if you want to sign with your own local wallet, Agent Wallet to set limits for an AI agent, and Data Stream for public live data.
POST /api/v1/wallet/generate
      POST /api/v1/verify
      GET  /api/v1/agent-wallet/capabilities
      POST /api/v1/agent-wallet/generate
      GET  /api/v1/agent-wallet/profile
      GET  /api/v1/agent-wallet/balances
      GET  /api/v1/agent-wallet/stats
      GET  /api/v1/agent-wallet/history
      POST /api/v1/agent-wallet/settings
      GET  /api/v1/transfer/capabilities
      POST /api/v1/transfer/execute
      GET  /api/v1/swap/capabilities
      POST /api/v1/swap/execute
      GET  /api/v1/lightning/capabilities
      POST /api/v1/lightning/trade
      GET  /api/v1/local/capabilities
      GET  /api/v1/token-builder/capabilities
      POST /api/v1/token-builder/create
      POST /api/v1/token-builder/claim-cashback
      POST /api/v1/dev/analytics/trades
      POST /api/v1/local/trade
      GET  /data-stream
      GET  /api/v1/token-info/:mint
      GET  /api/v1/health
      GET  /api/v1/tx/:signature/status

Slippage: accepted range is 1..99.

Versioning: the current stable API is /api/v1/*. Legacy compatibility is still available via /api/*.

Execution keys and auth

Why the keys are split: one key should not do everything. The regular API key is for normal trading. The agent execution key is for agent trades and transfers. The settings key is only for viewing and changing agent wallet settings.

ModeHeaderUseIdempotency
Ordinary wallet executionX-API-KeyRegular server-side execution for lightning, token-builder, analytics, and the dedicated swap route.Not required by the API.
Agent wallet executionX-Agent-Execution-KeyAgent routes that can move funds, with limits, permissions, and replay protection.Required on every request that can move funds.
Agent wallet settingsX-Settings-KeyProfile, balances, stats, history, and policy updates only. Do not give this key to an AI agent. It must not be used on transfer, swap, lightning, or any spend route.Not used.

Execution routes: POST /api/v1/transfer/execute is agent-wallet only and requires transfer to be enabled in policy. POST /api/v1/swap/execute accepts both the ordinary wallet API key and the agent execution key. POST /api/v1/lightning/trade also accepts the agent execution key when lightning is enabled in policy. POST /api/v1/token-builder/create and POST /api/v1/token-builder/claim-cashback also accept either X-API-Key or X-Agent-Execution-Key. If you use X-Agent-Execution-Key on token-builder routes, also send X-Idempotency-Key. Send exactly one auth header.

Agent Wallet settings

GET/POST /api/v1/agent-wallet/*

Purpose: these routes let you create an agent wallet, check its state, and change its limits. They are separate from spend routes, so you can give someone a settings key without also giving them spending access. Do not hand this key to the AI agent itself.

RouteHeaderPurpose
POST /api/v1/agent-wallet/generatenoneGenerate the one-time bundle with private key, execution key, and settings key.
GET /api/v1/agent-wallet/profileX-Settings-KeyRead public key, capabilities, limits, and current policy state.
GET /api/v1/agent-wallet/balancesX-Settings-KeyRead current SOL and token balances.
GET /api/v1/agent-wallet/statsX-Settings-KeyRead aggregate success/failure counters and rolling policy state.
GET /api/v1/agent-wallet/historyX-Settings-KeyRead recent execution history with idempotency records and result summaries.
POST /api/v1/agent-wallet/settingsX-Settings-KeyUpdate capabilities, per-tx limits, rolling windows, memo requirement, and transfer allowlist.

Default transfer stance: newly generated agent wallets start with transfer=false. Enable transfer explicitly in settings before using the dedicated transfer route.

UI page: use the AI Agents Wallet page for generate, inspect, balances, live state, and policy editing. Use the Operations Builder page only for transfers and swaps.

Token Builder Capabilities

GET /api/v1/token-builder/capabilities

Purpose: returns the current rules used by the builder and integrations before they send create or claim requests.

Response: supported platforms, platform labels, claim type, metadata notes, upload size limit, allowed image types, and the expected create and claim fields.

Why it exists: the web builder and example clients can boot from one source of truth instead of hardcoding pump vs letsbonk differences in multiple places.

Token Builder Capabilities / JavaScript
const response = await fetch('https://corto.fun/api/v1/token-builder/capabilities', {
  method: 'GET'
});

const data = await response.json();
console.log(data.platforms); // pump.fun and letsbonk.fun metadata.
console.log(data.limits); // Upload limits and supported image types.
console.log(data.createContract); // Expected fields for create.
console.log(data.claimContract); // Expected fields for claim.

Token Builder Create

POST /api/v1/token-builder/create

Auth: send exactly one execution header: X-API-Key or X-Agent-Execution-Key.

Agent mode: if you use X-Agent-Execution-Key, also send X-Idempotency-Key. Ordinary X-API-Key mode does not use idempotency.

Content-Type: multipart/form-data.

Security: image stays in memory only, max size is 2 MB by default, and only png/jpeg/webp are accepted.

FieldTypeRequiredDescription
platform"pump" | "letsbonk"yesWhich launch platform to use.
namestringyesToken name, up to 32 chars.
symbolstringyesToken symbol, up to 10 chars.
descriptionstringyesMetadata description.
websitestringnoOptional http/https URL.
twitterstringnoOptional http/https URL.
telegramstringnoOptional http/https URL.
devBuyEnabledbooleannoEnables initial dev wallet buy in the same create flow.
devBuySolnumbernoSOL amount for the optional dev buy. Builder presets include 0.01, 0.05, 0.1, 1, 3, 5, and 10, but the server still enforces the current maximum.
migrateType"amm" | "cpmm"noletsbonk-only LaunchLab migration mode. Defaults to amm.
cashbackEnabledbooleannopump-only cashback accounting flag. Defaults to true in the builder.
imagefileyesSingle image file in field image.

pump metadata flow: the same multipart request uploads image + metadata to pump.fun IPFS, then Corto submits create_v2 on-chain.

letsbonk metadata flow: the same multipart request uploads image + metadata to the Raydium launch-mint host, then Corto submits LaunchLab create with letsbonk platformId.

Token Builder Create / JavaScript
const form = new FormData();
form.append('platform', 'pump');
form.append('name', 'Corto Nova');
form.append('symbol', 'NOVA');
form.append('description', 'Example launch from Corto token builder');
form.append('website', 'https://example.com');
form.append('devBuyEnabled', 'true');
form.append('devBuySol', '0.001');
form.append('image', fileInput.files[0]);

const response = await fetch('https://corto.fun/api/v1/token-builder/create', {
  method: 'POST',
  headers: {
    'X-API-Key': 'YOUR_API_KEY' // Ordinary wallet example. X-Agent-Execution-Key also works.
  },
  body: form
});

const data = await response.json();
console.log(data);

Token Builder Claim

POST /api/v1/token-builder/claim-cashback

Auth: send exactly one execution header: X-API-Key or X-Agent-Execution-Key. The JSON body does not include apiKey.

Agent mode: if you use X-Agent-Execution-Key, also send X-Idempotency-Key. Ordinary X-API-Key mode does not use idempotency.

FieldTypeRequiredDescription
platform"pump" | "letsbonk"yesSelects which reward contour to claim.

pump: claims pump cashback for the wallet restored from the execution header you sent.

letsbonk: claims LaunchLab creator fee for the wallet restored from the execution header you sent. The public endpoint name stays shared, but the response exposes claimKind=creator_fee.

Token Builder Claim / JavaScript
const response = await fetch('https://corto.fun/api/v1/token-builder/claim-cashback', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'YOUR_API_KEY' // Ordinary wallet example. X-Agent-Execution-Key also works.
  },
  body: JSON.stringify({
    platform: 'letsbonk'
  })
});

const data = await response.json();
console.log(data);

Data Stream

WS /data-stream

Access: Data Stream is free. One IP can keep one active connection open at a time.

Purpose: read public live JSON events in real time. You do not need polling, and you do not need to reconnect every time you change the filter.

Control messages: subscribe, unsubscribe, and current_state.

How filtering works: send a new control message when you want to change pools or event types. Normal filter changes do not require reconnecting. For create subscriptions, you can also set create.detail to min, mid, or full.

Client messageBodyResult
subscribe{"type":"subscribe","events":[...],"pools":[...],"create":{"detail":"mid"}}Starts or replaces the current subscription and sets the create message detail level.
unsubscribe{"type":"unsubscribe","events":[...],"pools":[...]}Removes part of the current filter without closing the socket.
current_state{"type":"current_state"}Returns the current filter, including the active createDetail value.

Common responses: handshake, subscription_ack, current_state, error, plus event messages such as create, buy, sell, and migration when the current filter matches.

Start here: use the Data Stream Builder to watch live messages, then open the linked schema pages if you need the exact JSON format.

Local Capabilities

GET /api/v1/local/capabilities

Purpose: shows the current rules for Local Build before you send POST /api/v1/local/trade.

Response: supported pools, required vs optional fields, numeric limits, default pool and route budget, and explicit mode differences such as publicKey required and no percent amounts.

Memo policy: local capabilities also expose memo rules. User memo has priority, and the branded suffix is appended only when the combined UTF-8 text still fits the service limit.

Why it exists: Local Build works differently from Lightning, so your client can read the rules first instead of learning them from validation errors.

Local Capabilities / JavaScript
const response = await fetch('https://corto.fun/api/v1/local/capabilities', {
  method: 'GET'
});

const data = await response.json();
console.log(data.supportedPools);
console.log(data.features.requiresPublicKey); // true
console.log(data.features.supportsPercentAmount); // false
console.log(data.fieldRules.amount);

Local Trade

POST /api/v1/local/trade

Before sending the request: call GET /api/v1/local/capabilities if your client wants to read the current rules before building the request body.

Memo behavior: your memo is the main one. The service adds the branding suffix only if the combined UTF-8 text still fits the memo limit. If the transaction gets too large, the branding suffix is removed first and your memo stays.

FieldTypeRequiredDescription
publicKeystringyesWallet public key used as fee payer.
action"buy" | "sell"yesTrade direction.
mintstringyesSPL token mint address.
amountnumberyesTrade size, must be > 0.
denominatedInSolbooleanyestrue = amount in SOL, false = in tokens.
slippagenumberyesAllowed slippage, 1..99.
pool"auto" | "pump" | "pump-amm" | "raydium-launchlab" | "raydium" | "raydium-cpmm" | "meteora-amm" | "meteora-dlmm" | "meteora" | "jupiter"noRouting source (default auto). Use raydium-launchlab for the Raydium LaunchLab contour; branded origin is returned separately as launchpadBrand in responses.
priorityFeeSolnumbernoPriority fee in SOL (0.0000001..0.01).
memostringnoOptional user memo up to 120 UTF-8 bytes. If branding memo is enabled and the combined text still fits, the service appends via corto.fun. Otherwise your memo stays unchanged.
partnerAddressstringnoPartner address for additional transfer in the same transaction.
partnerFeeRationumbernoShare of order size (0..1). Example: 0.005 = 0.5%.
partnerFeeFixednumbernoFixed partner payout in SOL (0..1).
maxRouteMsnumbernoRouting time budget in milliseconds.
Local / Python
import requests

payload = {
    "publicKey": "YOUR_PUBLIC_KEY",
    "action": "buy",
    "mint": "TOKEN_MINT",
    "amount": 0.01,
    "denominatedInSol": True,
    "slippage": 5,
  "pool": "auto",
  "memo": "local buy note"
}

res = requests.post(
    "https://corto.fun/api/v1/local/trade",
    json=payload,
    timeout=20
)
print(res.json())
Local / JavaScript
const payload = {
  publicKey: 'YOUR_PUBLIC_KEY',
  action: 'buy',
  mint: 'TOKEN_MINT',
  amount: 0.01,
  denominatedInSol: true,
  slippage: 5,
  pool: 'auto',
  memo: 'local buy note',
  partnerAddress: 'PARTNER_SOLANA_ADDRESS',
  partnerFeeRatio: 0.005
};

const response = await fetch('https://corto.fun/api/v1/local/trade', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload)
});

const data = await response.json();
console.log(data);
Local / Rust (reqwest)
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() {
    let client = Client::new();
    let payload = json!({
        "publicKey": "YOUR_PUBLIC_KEY",
        "action": "buy",
        "mint": "TOKEN_MINT",
        "amount": 0.01,
        "denominatedInSol": true,
        "slippage": 5,
        "pool": "auto",
        "memo": "local buy note"
    });

    let res = client
        .post("https://corto.fun/api/v1/local/trade")
        .json(&payload)
        .send()
        .await
        .unwrap();

    println!("{}", res.text().await.unwrap());
}
Local / Go
package main

import (
  "bytes"
  "net/http"
)

func main() {
  body := []byte(`{"publicKey":"YOUR_PUBLIC_KEY","action":"buy","mint":"TOKEN_MINT","amount":0.01,"denominatedInSol":true,"slippage":5,"pool":"auto","memo":"local buy note"}`)
  req, _ := http.NewRequest("POST", "https://corto.fun/api/v1/local/trade", bytes.NewBuffer(body))
  req.Header.Set("Content-Type", "application/json")
  client := &http.Client{}
  client.Do(req)
}

Lightning Capabilities

GET /api/v1/lightning/capabilities

Purpose: shows the current rules for the server-signed Lightning flow before you send POST /api/v1/lightning/trade.

Response: supported pools, required vs optional fields, numeric limits, default ack mode, Jito policy hints, and feature flags such as supports percent amount and supports projectId.

Memo policy: lightning capabilities also expose memo rules. User memo has priority, and the branded suffix is appended only when the combined UTF-8 text still fits the service limit.

Why it exists: Lightning has extra rules beyond the basic field list, especially for ack mode, percent sells, and fees.

Lightning Capabilities / JavaScript
const response = await fetch('https://corto.fun/api/v1/lightning/capabilities', {
  method: 'GET'
});

const data = await response.json();
console.log(data.defaults.ackMode);
console.log(data.features.supportsPercentAmount); // true
console.log(data.jitoPolicy);
console.log(data.fieldRules.projectId);

Lightning Trade

POST /api/v1/lightning/trade

Before sending the request: call GET /api/v1/lightning/capabilities if your client wants to read the current Lightning rules first.

Memo behavior: your memo is the main one. The branding suffix is added only if the combined UTF-8 text still fits the memo limit. In Lightning, an optional auto-Jito tip may also be removed first if the transaction gets too large.

FieldTypeRequiredDescription
action"buy" | "sell"yesTrade direction.
mintstringyesSPL token mint address.
amountnumberyesTrade size, must be > 0.
denominatedInSolbooleanyestrue = amount in SOL, false = in tokens.
slippagenumberyesAllowed slippage, 1..99.
pool"auto" | "pump" | "pump-amm" | "raydium-launchlab" | "raydium" | "raydium-cpmm" | "meteora-amm" | "meteora-dlmm" | "meteora" | "jupiter"noRouting source (default auto). Use raydium-launchlab for the Raydium LaunchLab contour; branded origin is returned separately as launchpadBrand in responses.
priorityFeeSolnumbernoPriority fee in SOL (0.0000001..0.01).
jitoTipnumbernoExplicit Jito tip in SOL. Minimum to join Jito auction is 0.0002 SOL; lower values are ignored.
memostringnoOptional user memo up to 120 UTF-8 bytes. If branding memo is enabled and the combined text still fits, the service appends via corto.fun. Otherwise your memo stays unchanged.
partnerAddressstringnoPartner address that receives partner fee via separate transfer in the same transaction.
partnerFeeRationumbernoShare of order size (0..1). Example: 0.005 = 0.5%.
partnerFeeFixednumbernoFixed partner payout in SOL (0..1).
projectIdstringnoOptional project attribution key used by developer analytics.
ackMode"sent" | "confirmed"noResponse mode: fast-ack after send or wait for confirmation.
maxRouteMsnumbernoRouting time budget in milliseconds.

Auth: send the API key only in the X-API-Key header. The JSON body does not include apiKey.

Jito policy: if only priorityFeeSol is provided and it is ≥ 0.00023 SOL, service auto-splits it 90/10: 90% to Jito tip and 10% to priority fee. If lower than 0.00023 SOL, no split is applied and full value remains priority fee.

Tx size behavior: if a request still overflows after memo/Jito fallback handling, TX_SIZE_EXCEEDED returns safe diagnostic details including the selected memo variant and whether the branded suffix or auto-Jito tip had already been dropped.

Developer analytics: only successful lightning trades are tracked. Local unsigned transactions are never included.

projectId: optional attribution key for segmenting one partner wallet into multiple projects inside developer analytics.

Lightning / Python
import requests

api_key = "YOUR_API_KEY"
payload = {
    "action": "buy",
    "mint": "TOKEN_MINT",
    "amount": 0.01,
    "denominatedInSol": True,
    "slippage": 5,
    "pool": "auto",
    "memo": "alpha entry",
    "priorityFeeSol": 0.00023,
    "projectId": "alpha-campaign",
    "partnerAddress": "PARTNER_SOLANA_ADDRESS",
    "partnerFeeRatio": 0.005,
    "partnerFeeFixed": 0.0001
}

res = requests.post(
    "https://corto.fun/api/v1/lightning/trade",
    headers={"X-API-Key": api_key, "Content-Type": "application/json"},
    json=payload,
    timeout=25
)
print(res.json())
Lightning / JavaScript
const apiKey = 'YOUR_API_KEY';

const payload = {
  action: 'buy',
  mint: 'TOKEN_MINT',
  amount: 0.01,
  denominatedInSol: true,
  slippage: 5,
  pool: 'auto',
  memo: 'alpha entry',
  priorityFeeSol: 0.00023,
  projectId: 'alpha-campaign',
  partnerAddress: 'PARTNER_SOLANA_ADDRESS',
  partnerFeeRatio: 0.005,
  partnerFeeFixed: 0.0001
};

const response = await fetch('https://corto.fun/api/v1/lightning/trade', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-API-Key': apiKey },
  body: JSON.stringify(payload)
});

const data = await response.json();
console.log(data);
Lightning / Rust (reqwest)
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() {
    let api_key = "YOUR_API_KEY";
    let payload = json!({
        "action": "buy",
        "mint": "TOKEN_MINT",
        "amount": 0.01,
        "denominatedInSol": true,
        "slippage": 5,
        "pool": "auto",
        "memo": "alpha entry",
        "priorityFeeSol": 0.00023,
        "projectId": "alpha-campaign",
        "partnerAddress": "PARTNER_SOLANA_ADDRESS",
        "partnerFeeRatio": 0.005,
        "partnerFeeFixed": 0.0001
    });

    let res = Client::new()
        .post("https://corto.fun/api/v1/lightning/trade")
        .header("X-API-Key", api_key)
        .json(&payload)
        .send()
        .await
        .unwrap();

    println!("{}", res.text().await.unwrap());
}
Lightning / Go
package main

import (
  "bytes"
  "net/http"
)

func main() {
  body := []byte(`{"action":"buy","mint":"TOKEN_MINT","amount":0.01,"denominatedInSol":true,"slippage":5,"pool":"auto","memo":"alpha entry","priorityFeeSol":0.00023,"projectId":"alpha-campaign","partnerAddress":"PARTNER_SOLANA_ADDRESS","partnerFeeRatio":0.005,"partnerFeeFixed":0.0001}`)
  req, _ := http.NewRequest("POST", "https://corto.fun/api/v1/lightning/trade", bytes.NewBuffer(body))
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("X-API-Key", "YOUR_API_KEY")
  client := &http.Client{}
  client.Do(req)
}

Swap Capabilities

GET /api/v1/swap/capabilities

Purpose: returns the live contract for the dedicated real swap route before you submit POST /api/v1/swap/execute.

Response: required vs optional fields, exact-in semantics, default ack mode, dedicated swap timeout, auth rules, and whether token-to-token execution is supported.

Important: this route is not the Lightning buy/sell contract. Dedicated swap uses inputMint and outputMint directly.

Swap Capabilities / JavaScript
const response = await fetch('https://corto.fun/api/v1/swap/capabilities', {
  method: 'GET'
});

const data = await response.json();
console.log(data.defaults.maxRouteMs);
console.log(data.features.supportsTokenToToken); // true
console.log(data.fieldRules.inputMint);
console.log(data.fieldRules.outputMint);

Dedicated Swap

POST /api/v1/swap/execute

Before sending the request: call GET /api/v1/swap/capabilities if your client wants to read the live swap rules first.

Contract: dedicated swap is exact-in. amount is always interpreted in units of inputMint.

Coverage: the route supports SOL -> token, token -> SOL, and token -> token. Use the canonical WSOL mint for SOL legs.

FieldTypeRequiredDescription
inputMintstringyesMint of the asset you are spending.
outputMintstringyesMint of the asset you want to receive.
amountnumberyesExact-in amount expressed in input asset units.
slippagenumberyesAllowed slippage, 1..99.
pool"auto" | "jupiter"noDedicated swap engine selection. Default is jupiter.
priorityFeeSolnumbernoPriority fee in SOL (0.0000001..0.01).
jitoTipnumbernoExplicit Jito tip in SOL. Lower values can be ignored if they do not reach the auction floor.
projectIdstringnoOptional project attribution key.
ackMode"sent" | "confirmed"noResponse mode: fast ack after send or wait for confirmation.
maxRouteMsnumbernoDedicated swap routing budget in milliseconds. If omitted, the route uses the swap-specific ENV default.
memostringnoOptional user memo up to 120 UTF-8 bytes.

Auth: send exactly one execution header: X-API-Key for an ordinary wallet or X-Agent-Execution-Key for an agent wallet. Agent execution also requires X-Idempotency-Key.

Route timeout: dedicated swap uses its own runtime default from SWAP_MAX_ROUTE_MS, separate from the generic routing budget used by Lightning and Local Build.

Fees: partner fee fields from Lightning are not part of the dedicated swap contract.

Dedicated Swap / JavaScript
const apiKey = 'YOUR_API_KEY';

const payload = {
  inputMint: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
  outputMint: 'JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN',
  amount: 1,
  slippage: 5,
  pool: 'jupiter',
  ackMode: 'confirmed',
  maxRouteMs: 8000,
  priorityFeeSol: 0.00023,
  memo: 'rebalance leg'
};

const response = await fetch('https://corto.fun/api/v1/swap/execute', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'X-API-Key': apiKey },
  body: JSON.stringify(payload)
});

const data = await response.json();
console.log(data.swap);
console.log(data.routePlan);

Developer Analytics

POST /api/v1/dev/analytics/trades
FieldTypeRequiredDescription
framestringyesRolling window in 1..24h or 1..30d format, for example 7h or 12d.
partnerAddressstringyesMust be the same public key that is restored from the API key used in the X-API-Key header.
projectIdstringnoOptional project-level filter inside the verified partner scope.
userWalletstringnoOptional wallet filter when you want a single trader row.

Auth: send the same X-API-Key header used for lightning trading. The server decodes that API key, restores the wallet, and compares the restored public key against partnerAddress.

Access model: generate the wallet on Wallet Tools, use that public key as partnerAddress in lightning trades, and query analytics with the paired API key. If the derived public key and partnerAddress differ, the endpoint returns 403. Rate limit is 1 request per 10 seconds per API key.

Response shape: the endpoint returns summary and rows. Summary includes currentTimestampMs, fromTimestampMs, frame, total volume, total API fee, total partner fee, buy count, and sell count. Rows are aggregated per user wallet.

Developer Analytics / JavaScript
const apiKey = 'YOUR_API_KEY';
const partnerAddress = 'PUBLIC_KEY_FROM_THE_SAME_GENERATED_WALLET';

const response = await fetch('https://corto.fun/api/v1/dev/analytics/trades', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': apiKey
  },
  body: JSON.stringify({
    frame: '7h',
    partnerAddress,
    projectId: 'alpha-campaign'
  })
});

const data = await response.json();
console.log(data.summary);
console.table(data.rows);

Token Info (free public probe)

GET /api/v1/token-info/:mint?pool=auto

Rate limit: 1 request per 5 seconds per source.

Response fieldTypeDescription
tradablebooleanWhether route exists on public Jupiter quote.
token.decimalsnumber|nullToken decimals from public Solana RPC.
market.buyProbeobjectEstimated buy output for 0.001 SOL probe.
market.sellProbeobject|nullEstimated sell output for 1 token probe.

Tx Status

GET /api/v1/tx/:signature/status

Rate limit: 60 requests per minute per source.

Use this endpoint to check the latest known confirmation state for a Solana transaction signature when you need an API response instead of opening Solscan.

Memo readback: if the transaction contained a memo instruction, this endpoint returns the final on-chain memo text, not just the raw memo field from the request.

Response fieldTypeDescription
statusstringCurrent state: not_found, processed, confirmed, finalized, or unknown.
confirmedbooleantrue when status is confirmed or finalized.
finalizedbooleantrue only when finalized.
slotnumber|nullObserved slot from RPC response.
errorobject|nullRaw Solana transaction error object if present.
memoobject|nullDecoded memo data found in the on-chain transaction, including the final text if a memo instruction exists.

Live endpoint tests

{}
{}
{}

Pricing and fees

ItemValueComment
Platform API feeAccording to active commercial planCheck operator quote and billing agreement.
Priority feeUser-definedSent to Solana network validators.
Jito tipUser-defined or auto-split policyMinimum auction tip is 0.0002 SOL.
Partner payoutUser-definedService does not cap partner commission size and is not liable for it.

For legal boundaries, open Terms of Service and Legal Notices.

For implementation walkthroughs, open Detailed Examples.

Current Page Docs
Next Page Examples →