Everything about NearPad, in one place.

Overview

NearPad is a launch and trading interface for user-created tokens on NEAR Protocol. Launches on nearpadfamily.near create a NEP‑141 token and a Rhea DCL market in one wallet transaction, then place the DCL position in an operator-controlled locker account.

NearPad is non-custodial: the connected wallet authorizes launch and trade transactions. Token names, symbols, and images are not unique, so always verify the full token account ID.

Launch mechanism

New launches use a fixed one-billion-token supply with 18 decimals. One wallet-approved call to nearpadfamily.near creates the token, opens its Rhea DCL pool against the selected pair asset (NEAR, USDC, or USDT), deposits the full supply into a one-sided position, and assigns that position to lock.nearpadfamily.near. NEAR pairs use wrap.near onchain. The selected pair, 0–9% custom tax, and developer or holder destination are fixed at launch. The custom tax is collected on swaps submitted through NearPad; direct Rhea swaps bypass the NearPad router and do not collect it.

Launch costs

Trading and pricing

New NearPad tokens trade through the factory's routed swap into their Rhea DCL pool. The interface wraps NEAR as needed and uses ft_transfer_call to submit the input asset; executable quotes come from DCL's quote method. A first trade may require separate token storage registration.

Displayed values are estimates. The pool can move between quote and execution, and wallet/storage costs are separate from token output.

Graduation

NearPad displays virtual bonding-curve progress against a $9,000 market-cap marker. Once the $9,000 threshold is verified, graduation is permanent even if the market cap later falls below it.

Graduation does not migrate the token or create a second market. Trading continues in the same Rhea pool before and after the marker. It is a progress indicator, not a quality, safety, or liquidity guarantee.

Fees and rewards

Select NEAR (wNEAR onchain), USDC, or USDT at launch. Each NearPad routed buy charges 1% platform fee plus the immutable 0–9% custom rate from the pair input before the DCL trade; a routed sell deducts the fees from the pair output. The 1% platform amount is split 70% to the developer and 30% to the protocol. The full custom amount goes to the chosen developer balance or holder vault, in the selected pair asset. DCL pool fees, wallet gas, and token storage are separate. Swaps made directly on DCL bypass NearPad's routed fee collection.

Developer fees accrue per launch and can be claimed with claim_developer(token_id). In holder mode, the custom fee accumulates in the selected pair asset. Rewards become claimable after a balance snapshot and funded distribution are published. Eligible holders then see a claim button on the coin page. A 0% custom tax has no holder rewards. Review the claim amount and wallet transaction before signing.

Liquidity locks

The factory deposits the full token supply into a Rhea DCL position owned by lock.nearpadfamily.near. Registration verifies that the DCL position exists and the locker reports it locked.

The opening position contains the full fixed token supply and initially no reserve of its selected pair asset. Buys add that asset to the market; the displayed token price changes with DCL trading. For NEAR pairs, the USD value also follows NEAR/USD.

Risk disclosures

NearPad tokens are user-created and experimental. Review the token account, creator, pool ID, holder concentration, liquidity, and wallet transaction preview before signing.

• Prices can move quickly; small pools can have high price impact.
• Names, tickers, artwork, and social links can be copied.
• NEAR RPCs, Rhea, wallets, indexers, and third-party pricing feeds can be delayed or unavailable.
• USD prices, market caps, charts, holder lists, and transaction labels are display estimates.
• A locker-held position does not guarantee token value, trading demand, or that liquidity cannot be withdrawn.

NearPad provides software and data interfaces, not investment advice, custody, or a representation of token quality.

Network

Contracts and accounts

These mainnet accounts form the current NearPad integration surface. Treat all identifiers as case-sensitive strings and verify them onchain.

Reviewed token deployment

NearPad verifies the deployed code hash and confirms the token account has zero access keys before accepting it into the launch registry.

Reading token state

Every launch uses standard NEP‑141 view methods. Metadata and balances can be read directly from any NEAR RPC without relying on NearPad's database.

When you upload PNG, JPEG, GIF, or WebP artwork, NearPad saves the original file on its server and serves that file on the launch and coin pages. GIF animation and the uploaded resolution are preserved. Pinata stores the separate onchain image and metadata JSON (description, website, and social links); ft_metadata exposes their Pinata URLs and the JSON SHA-256 hash. A Pinata key with pinFileToIPFS permission is required to launch. The metadata service status reports whether a key is installed; an upload also requires that permission.

curl https://rpc.mainnet.fastnear.com \
  -H "Content-Type: application/json" \
  --data '{
    "jsonrpc":"2.0",
    "id":"nearpad-docs",
    "method":"query",
    "params":{
      "request_type":"call_function",
      "finality":"final",
      "account_id":"TOKEN_ACCOUNT",
      "method_name":"ft_metadata",
      "args_base64":"e30="
    }
  }'

The RPC response returns method bytes as integer values. Convert them to UTF‑8 and parse the resulting JSON.

Reading Rhea pools

Launches store a DCL pool ID such as token.nearpadfamily.near|wrap.near|10000. Read the DCL point, executable quote, factory route, and locked position together.

const route = await view("nearpadfamily.near", "get_launch", {
  token_id: TOKEN_ACCOUNT
});
const pool = await view("dclv2.ref-labs.near", "get_pool", {
  pool_id: route.pool_id
});
const position = await view("lock.nearpadfamily.near", "get_position", {
  token_id: TOKEN_ACCOUNT
});
const quote = await view("dclv2.ref-labs.near", "quote", {
  pool_ids: [route.pool_id],
  input_token: "wrap.near",
  output_token: TOKEN_ACCOUNT,
  input_amount: "10000000000000000000000",
  tag: "near-pad-docs"
});

Pricing and market data

Use the DCL point price, token order, and each asset's decimals. Before the first buy, use the left boundary for a token on the X side or the right boundary for a token on the Y side. NearPad samples 5-minute, 1-hour, 6-hour, and 1-day candles. NEAR pools convert the current NEAR price with live NEAR/USD; stable pairs open around 1,000 times the NEAR/USD quote supplied at launch, rounded to a DCL tick. Existing stable pools follow their DCL trading price after launch.

tokenIsX = pool.token_x === TOKEN_ACCOUNT
effectivePoint = tokenIsX && pool.current_point < route.left_point
  ? route.left_point
  : !tokenIsX && pool.current_point > route.right_point
    ? route.right_point
    : pool.current_point
pairDecimals = route.pair_asset === "wrap.near" ? 24 : 6
pairPerToken = tokenIsX
  ? (1.0001 ** effectivePoint) * 10 ** (18 - pairDecimals)
  : 1 / ((1.0001 ** effectivePoint) * 10 ** (pairDecimals - 18))
priceUsd = pairPerToken * (route.pair_asset === "wrap.near" ? nearUsd : 1)
fdvUsd = priceUsd * 1_000_000_000

DexScreener and GeckoTerminal use refv2- followed by the DCL pool ID with vertical bars replaced by colons. Token order depends on the chosen pair. Tracker listings and updates depend on those external indexers.

Public read API

The application exposes JSON read endpoints under https://nearpad.family/launch-feed-v5/. They require no wallet connection. Use onchain contract calls when you need a trust-minimized source of truth.

fetch("https://nearpad.family/launch-feed-v5/launches?limit=24")
  .then((response) => response.json())
  .then(({ launches }) => {
    for (const token of launches) {
      console.log(token.contract_id, token.pool_id, token.status);
    }
  });

Responses use snake_case fields. A launch becomes fully tradable when status is pool_live and a DCL pool_id is present.

Indexing

A resilient indexer should combine registered launch data with direct NEAR and Rhea state.

1. Fetch launches and retain each token account, creator, block height, pool ID, and pair asset.
2. Verify NEP‑141 metadata and supply directly from the token account.
3. Read Rhea DCL get_pool for pool state and the locker get_position for the position status.
4. Index successful swaps involving the verified pool; derive direction from the input/output token.
5. Use token balance data for holders and normalize every quantity by its own decimals.

NearPad's trade feed synchronizes Rhea activity through NEAR transaction data with a minimum five-second sync window. Consumers should tolerate temporary RPC and indexer delays.

Support and terms

For integration help, launch recovery, or verified platform questions, contact the NearPad community through Telegram or X. Never share a private key or seed phrase; NearPad support will not ask for one.

Onchain data is public and may be read independently. NearPad is provided as is, without warranties. Integrators are responsible for validating account IDs, decimals, pool state, transaction outcomes, and any information shown to their users. Do not imply an official partnership or endorsement without written permission.