Femtos

Stop your plan from renewing: it runs to its period end (no refund), then the key is back on pay as you go. subscribe_plan before then resumes it. Free.

Create an outgoing webhook: we POST the events of its subscriptions to your HTTPS URL (port 443 or 8443, public address), signed (Standard Webhooks: webhook-id, webhook-timestamp, webhook-signature = v1,<base64 HMAC-SHA256 of "id.timestamp.body" with the secret>). Channels (WebSocket vocabulary): bridge.transfers and elysium.bridge (matched bridge legs), wallet (filter.address: up to 100 addresses, filter.channel: event kinds), hc.liquidations and hc.positions (filter.min_notional; positions >= 10000), elysium.launches, hyperevm.launches. Your URL first gets a webhook.verification POST: answer {"challenge": "<data.challenge>"} within 10 s, nothing else is sent before. The answer carries the secret once. Free tier: 2 webhooks, 5 subscriptions, 10k deliveries a day.

Delete your account: the key stops working for good. Refused while a plan runs or overage is due; a positive balance is lost only with forfeit_balance=true. Needs management_secret (agents); an account with an email gets a confirmation link. Cannot be undone.

Delete one of your webhooks and its pending deliveries. Cannot be undone.

One read-only JSON-RPC call on our Elysium mainnet (chain 99901) node, free: eth_chainId, eth_blockNumber, net_version, net_listening, web3_clientVersion, eth_syncing, eth_getBlockByNumber, eth_getBlockByHash, eth_getBlockTransactionCountByNumber, eth_getBlockTransactionCountByHash, eth_getTransactionByHash, eth_getTransactionByBlockNumberAndIndex, eth_getTransactionByBlockHashAndIndex, eth_getTransactionReceipt, eth_getBlockReceipts, eth_getBalance, eth_getCode, eth_getStorageAt, eth_getTransactionCount, eth_call, eth_estimateGas, eth_gasPrice, eth_maxPriorityFeePerGas, eth_feeHistory, eth_getLogs, eth_getProof. The answer is the node's {jsonrpc, id, result} or {error}. eth_getLogs over at most 1000 blocks; state (eth_call, eth_getBalance…) of the last 128 blocks only. No transaction sending. Limited per IP (5/s, 60/min): use the indexed tools for history.

Turn a disabled webhook (410 Gone, or failing for 24 h) on again: your URL gets a new webhook.verification challenge, deliveries resume once it is answered; pending ones are kept 7 days.

Emergency stop for a leaked key: it is refused everywhere at once, this MCP connection included. Unfreeze or rotate it after with your management secret (POST /v1/account/unfreeze, /v1/account/rotate). Free.

Your Femtos account: name, tier and limits in force, balance and debt (USD), credits used this month and free credits left, monthly cap, plan and renewal, how to pay (USDC deposit address, card, x402), how rotate/delete are confirmed (manageWith). Start here to manage the account. Free.

What an address holds, one flat list: HyperCore spot tokens (live), HyperEVM and Elysium ERC-20s and native HYPE (indexed head), each with raw units, amount, USD price and value, largest first; spam tokens left out; HyperCore perp accounts (account value, withdrawable) apart in `perp`; totals per layer and overall, each layer with its source, height and asOf. Past balances: block or at (Unix ms) on one layer (EVM: needs tokens, read on our archive node; HyperCore: the holder snapshot at or before it, 7 days kept). verify: EVM rows read again on the node at the same block (indexer drift shows as onchain.match false).

One HyperEVM or Elysium block (a number, or latest): hash, time, small or big block (HyperEVM), gas, base fee, tips, HYPE burnt and fees, and every transaction in order with sender, recipient (named wallets tagged), HYPE sent, function called, status, gas, tip, fee and its decoded swaps, transfers and liquidity changes.

Live L2 order book of one HyperCore market from our own node: bids and asks best first as [px, sz, n] (price, size, order count), and the block it was read at. coin: perp name (BTC), spot @index (@107) or HIP-3 dex:COIN.

Bridge movements, newest first, with 24 h stats. route core_evm: HyperCore <> HyperEVM transfers, both legs matched (status, latency, how they were paired); route evm_elysium: HyperEVM <> Elysium (Orbit) deposits and withdrawals. Filter by account to follow one wallet across layers. Medium call.

One HyperCore builder code over a window (24h to all since 2025-07-19): fees (USD stablecoins at par, exact per token), volume, fills, users, rank; one row per day; its markets; its orders from 2026-10-13 15:50 UTC by status (fills, cancels, each rejection reason) and the fee rates they charged.

Fills of one HyperCore builder code, newest first, with the builder fee of each, account, market, price, size, direction, PnL, oid, tid and hash. From 2025-07-19; window from / to, default the last 24 h, at most 24 h per call. Next page: pass `next_cursor` as cursor.

Order statuses of one HyperCore builder code, newest first: open, filled, canceled, triggered and every rejection reason, with market, side, type, prices, sizes, account and the fee rate charged. From 2026-10-13 15:50 UTC; window from / to, default 24 h, at most 7 days per call. Next page: pass `next_cursor` as cursor.

HyperCore builder codes ranked over a window (24h, 7d, 30d, 90d, all since 2025-07-19): builder fees earned (USD stablecoins at par, exact per token), volume, fills, distinct users, share of all builder fees, and order outcomes (distinct orders, filled, canceled, rejected; from 2026-10-13 15:50 UTC), and the app behind each code (Phantom, MetaMask…) when known. Sort by fees, volume, fills, users or orders.

OHLCV candles of one market, ascending, UTC-aligned. hypercore: market = coin (BTC, HYPE, @107 spot, xyz:TSLA), down to 1 s. hyperevm / elysium: market = pool key from list_markets; prices in quote plus `usd` and `mcap` OHLC (USD price and market cap). Or token instead of market: a token's candles in USD through its reference pool (most liquid; the answer names it), HyperCore: its USDC market. Without from: the `limit` candles ending now. Windows over 30 days are billed as heavy calls.

One token: its links across layers, the markets it trades on (most traded first) and its 5 largest holders. hypercore: id = token name (HYPE), index or token id; hyperevm / elysium: id = 0x address. Price, FDV, liquidity and 5m–24h windows over all its pools: get_token_overview.

Your USDC deposit address (created on the first call, then the same): send USDC on HyperCore (usdSend), HyperEVM, Base or Arbitrum One (ERC-20 transfer) and it is credited 1:1 to your balance. Answers how to pay on each chain. Free.

Your USDC deposit address on each chain (HyperCore, HyperEVM, Base, Arbitrum One), amounts waiting to reach the minimum, and its latest deposits: amount, tx, pending / credited / ignored with the reason. Free.

How each wallet of a named entity was attributed: the links (bridges, HyperCore sub-accounts, sends both ways, Farcaster self-declarations) back to the public source, with their proofs (source, time, USD value, chains), and the HyperCore metrics of smart-money wallets. Use it to judge an attribution before relying on it.

The HyperCore PnL curve of a named entity (id from search_entities): per hour or day, realized PnL, fees, funding, net and cumulative net, over 7d, 30d, 90d or all history. Realized only: open positions' unrealized PnL is in get_entity's answer.

ERC-20 Transfer events, newest first (from, to, amount, block, tx). address: the transfers sent / received by a wallet (direction in, out or any), optionally of one token, in a window (from / to, Unix ms) or above minUsd (amount × current token price); each row with token, symbol, direction and USD value. Without address: the transfers of one token. Filtered pages may hold fewer rows than limit: keep paging with `next_cursor` (null = no more).

Open stop-loss / take-profit orders and the liquidation prices of open positions of one HyperCore market on the same price buckets: per bucket the stops by kind and side (each at what it would execute: a reduce-only order at most what is left of its wallet's position, the rest under stops.unbacked), the liquidations by side, the cascade (what fires with the move: sell = sell stop-losses + long liquidations, buy = buy stop-losses + short liquidations) and forced = cascade + take-profits (which fire against the move: sell ones above the mark, buy ones below), each with its running total from the mark outward (cumCascadeSell / cumSell downward, cumCascadeBuy / cumBuy upward); summary = cascade selling under the mark and buying over it, take-profits on the far side, and the forced totals, inside the grid. Same grid parameters as get_stop_map.

HyperEVM or Elysium gas over 1h, 6h, 24h or 7d: each block's base fee, gas used and limit, transactions and priority fees (p50 / p90 tips), HyperEVM small and big blocks as two series (each has its own base fee). Stats per series (base fee min / median / p90 / p99 / max / mean, typical tips, utilization) and the latest block. Points are every block up to 25000 per series, else buckets with min / mean / max base fee; ask a coarse resolution (5m, 15m, 1h) for a short answer. Values in wei.

Largest holders of a token and its concentration (top-10 share…); system addresses (pools, bridges, launchpad, zero/dead) counted apart. hypercore: token = name (HYPE), kind = balances (spot) or positions (perp open interest of a coin); hyperevm / elysium: token = 0x address. Named wallets carry `entity`; EVM rows say what each address is (label, labelKind: pool, bridge, protocol, token, creator, multisig, contract, wallet; contract: has code).

How the number of holders of a HyperEVM or Elysium ERC-20 evolved: one point a UTC day (holders at the indexed head just after 00:00 UTC, system addresses such as pools, bridges and zero / dead left out, as get_holders totalHolders) and the count now. History from the layer's first snapshot (`since`) on, up to 365 days.

The story of one launched token: launch event, market cap, volume, holders, dev wallet and its funding, early buyers with flags, coordination signals, fees (exact from the launchpad ledger when indexed), lifecycle stage across layers and, for Ascend, progress toward the "Ascended" criteria. Elysium first, then HyperEVM LiquidLaunch.

Replayable life of a launch, oldest first: launch, swaps and transfers with the running holder count and market cap, graduation links (bridge to HyperEVM, HyperCore listing). Long histories are cut to fit (see `truncated`).

Your money movements, newest first: USDC deposits and x402 packs (with tx), card payments, credits by Femtos, plans paid from the balance, refunds; usage debits with usage=true. With the balance now. Next page: pass `next_cursor` as cursor. Free.

Liquidation prices of the open perp positions of one HyperCore market, bucketed by price around the mark: per bucket the longs (liquidated by a forced sell as price falls to them) and the shorts (forced buy), count, |size| and |size| × liquidation price. Real per-position prices: every account's positions a few seconds old (the node state rolled forward with every fill, funding payment, ledger update and accepted account action), each liquidation price from Hyperliquid's formula on the account state, not a leverage model; `coverage` gives the share of open interest that has one (portfolio-margin cross accounts have none). Same grid parameters as get_stop_map: the buckets line up.

HyperCore liquidations over a window (1h, 24h, 7d, 30d), every perp or one coin: totals (notional, count, accounts, long / short, market / backstop), per coin, per time bucket, the most liquidated accounts and the largest events.

HyperCore perp liquidations, newest first: one row per account, coin and block (side of the liquidated position, market or backstop, size, notional, average and mark price). Default window: the last 24 h; `from` older than 7 days (30 with a coin) is clamped, the answer's `from` says where it starts. Named wallets carry `entity`.

One NFT collection of an EVM layer: metadata, standards, token ids seen (counted up to 1,000), transfers / mints / burns over the 24 h before the indexed head.

Tokens of one collection by token id, ascending: current ERC-721 owner (null for ERC-1155), metadata URI, image URL. Next page: pass `next_cursor` as cursor.

Transfers (mints and burns included) of one collection or one of its tokens, newest first: from, to, token id, amount, block, tx. Next page: pass `next_cursor` as cursor.

NFTs an address holds on an EVM layer at the indexed head: ERC-721 tokens and ERC-1155 balances, counted per collection, the tokens listed up to limit.

Open interest of a HyperCore perp over time (bars of 1s to 1M since 2023-05-20, 1s and 15s since 2025-09-28): open / high / low / close of the open interest (size, Σ |position| of longs and shorts), its value at the last price, longs and shorts opened and closed in each bar, the part opened by aggressors, the size liquidated, accounts long and short, the hourly funding rate settled. Exact after every block since 2025-03-22 10:49 UTC, from every trade and Hyperliquid's own per-minute values (anchored on every hourly funding since 2025-09-28, where accounts start); before, Hyperliquid's per-minute values alone, moves and trades null. Hyperliquid's API serves only the current open interest.

Who holds a HyperCore perp's open interest, every hour since 2025-09-28: long and short size and accounts by position size tier (0 = no trade price known, 1 = under $10k, 2 = $10k–100k, 3 = $100k–1M, 4 = $1M–10M, 5 = $10M and more), and the share of the 10 largest longs and shorts. Read whale vs retail positioning over time.

Who opened positions on a HyperCore perp in a window of up to a day (since 2025-03-22 10:49 UTC): the orders that opened longs or shorts, largest value first, with the account and its named wallet, size and value opened, average price, taker or resting, position before and after; plus the window's longs / shorts opened in total and by aggressors. Use it to explain an open interest jump.

How to pay your account now: your USDC deposit address on each chain with exact instructions, x402 credit packs, a card checkout URL when cards are offered (give usd), and the credits an amount buys. Free.

The price list: credits per call class (and which calls are medium / heavy), pay-as-you-go bands, plans with their monthly and annual price and included credits, payment methods. Use it before subscribe_plan. Free.

One DEX pool of HyperEVM or Elysium: dex, factory, fee tier, hooks, tokens with USD prices, creation block / tx, price, liquidity with its USD value and how it is measured (pool balances for V2 / V3; virtual reserves of the in-range liquidity for V4 / Infinity pools: not TVL), depth to ±2 %, trades / buys / sells / USD volume / price change over 5m, 1h, 6h, 24h, for V2-style pools the largest LP holders, and how much of its liquidity is burned, locked (until when), free or in contracts.

Past HyperCore perp position changes of one coin over a notional (at least 10000), one row per account and block (opens, closes, increases, reductions, flips, with size, average price and whether a liquidation moved it): the history of the WS hc.positions channel, the rows behind get_position_flow's bars. Window: the last 24 h by default, at most 30 days, anywhere since 2025-05-25. sort=notional for the largest of the window. Named wallets carry `entity`.

Large HyperCore perp position moves and liquidations of one coin summed per bar of a unit (1m to 1d, 1w, 1M): buys, sells, longs liquidated, shorts liquidated, each with notional, count, volume-weighted price and the largest move (named wallet when known). The figures add up across units. Floors: minNotional for buys and sells, liqMinNotional for liquidations (at least 10000). History from 2025-05-25.

Open positions of one HyperCore perp, current to a few seconds (the node state rolled forward with every fill, funding payment, ledger update and accepted account action): account, size, side, entry price, notional, unrealized PnL at the mark, leverage, margin mode and liquidation price when known. Sort by notional (default), upnl or liqDistance (closest to liquidation first). Named wallets carry `entity`.

USD prices in the past. With at (Unix ms): the price of up to 100 tokens at that time (last observation at or before it). With from / to / interval: USD closes per unit (1m 5m 15m 1h 4h 1d) of up to 25 tokens, gap-filled. Same sources as get_prices. Windows over 30 days are billed as heavy calls.

The wallets behind one price band of a HyperCore market (a bucket of get_forced_flow / get_stop_map / get_liquidation_map: px_lo = its pxLo, px_hi = its pxHi): the open stop-loss / take-profit orders triggering in it, each with what it would execute (a reduce-only order at most what is left of its wallet's position; the rest as unbackedSz) and the wallet's position, and the open positions liquidated in it (size, entry, leverage, liquidation price). Largest first. Named wallets carry `entity`.

Current USD price of up to 100 tokens in one call, each with its source and provenance: hl_mid (HYPE / WHYPE: HyperCore spot mid; hl_oracle when no mid is recorded), hl_spot (HyperCore tokens and HyperEVM tokens linked to one: last trade of its USDC market), hl_perp, unit (USDC), pool (HyperEVM / Elysium: last swap of the token's reference pool, the most liquid one, with block / tx / logIndex). hypercore: tokens = names (HYPE, PURR) or perp coins (BTC).

No key needed. Lost the key of an account created by an x402 payment? Get the message its paying wallet must sign (personal_sign), then call recover_account. EOA wallets only.