Prototype · Preview: every server in the official registry, synced every 30 minutes. Reviews and accounts come in a later step.
PopNx MCPMCP servers for people who use AI · explained in plain words

Highwire

by HigherMaestroversion 0.11.0i★ –iComputer or cloud
Registry namefun.highwire/highwire

Install

Overview

Description from the maker (original English)

Trade, launch and research higher.fun coins on Solana, from any AI agent. Unsigned or policy-signed.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

  • Connection: Computer or cloud
  • Transport: stdio, Streamable HTTP
  • Category: Crypto & blockchain
  • You need to fill in: SOLANA_RPC_URL

Install

Pick the AI app you use, then copy the settings.

Before you install

  • Basic checks: 3 of 3 passed
  • Runs on the maker’s server: what you ask it goes through their server.
  • Can do 26 things (tools) list_coins, search_coins, get_coin, get_coin_trades …
  • You fill in yourself: HIGHWIRE_CLUSTER, SOLANA_RPC_URL, HIGHWIRE_KEYPAIR_PATH

Values marked secret are keys to your account. Never share them or paste them into a chat.

You need

  • Runs in the cloudNothing to install; it connects over the internet
  • npmNode.js installed (for the npx command)

Which app do you use?

Pick your app above. We remember it, so next time the button says “Install in …”.

Works in Claude on the web, desktop and mobile:

  1. Open Settings → Connectors
  2. Press Add custom connector
  3. Paste the address below and press Add
  4. If it asks you to sign in, sign in with the maker
SettingsConnectors1+ Add2https://…3
https://highwire.fun/mcp

Or run it on your computer

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "highwire": {
      "command": "npx",
      "args": [
        "-y",
        "highwire-mcp"
      ],
      "env": {
        "HIGHWIRE_CLUSTER": "your-value",
        "SOLANA_RPC_URL": "your-value",
        "HIGHWIRE_KEYPAIR_PATH": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add --transport http highwire https://highwire.fun/mcp

Or run it on your computer

claude mcp add highwire --env HIGHWIRE_CLUSTER=your-value --env SOLANA_RPC_URL=your-value --env HIGHWIRE_KEYPAIR_PATH=your-value -- npx -y highwire-mcp

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "highwire": {
      "url": "https://highwire.fun/mcp"
    }
  }
}

Or run it on your computer

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "highwire": {
      "command": "npx",
      "args": [
        "-y",
        "highwire-mcp"
      ],
      "env": {
        "HIGHWIRE_CLUSTER": "your-value",
        "SOLANA_RPC_URL": "your-value",
        "HIGHWIRE_KEYPAIR_PATH": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "highwire": {
      "type": "http",
      "url": "https://highwire.fun/mcp"
    }
  }
}

Or run it on your computer

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "highwire": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "highwire-mcp"
      ],
      "env": {
        "HIGHWIRE_CLUSTER": "your-value",
        "SOLANA_RPC_URL": "your-value",
        "HIGHWIRE_KEYPAIR_PATH": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

ChatGPT connects only to servers on the internet:

  1. Open ChatGPT on the web → Settings → Connectors (Apps)
  2. Press Create or Add (some plans need Developer mode under Advanced first)
  3. Paste the address below, give it a name and save
  4. If it asks you to sign in, sign in with the maker
SettingsConnectors1+ Create2https://…3
https://highwire.fun/mcp

Menu names can differ slightly by plan and over time.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

  • HIGHWIRE_CLUSTER env
    mainnet (default) or devnet
  • SOLANA_RPC_URL secret env
    Your Solana RPC URL; defaults to the public one
  • HIGHWIRE_KEYPAIR_PATH env
    A keypair file, to turn on the local signer (it signs only inside your policy)

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Tool names and descriptions exactly as the server reported them on Nov 7, 2026. The maker wrote them, not us; we show them as plain text.

  • list_coins

    List higher.fun coins. sort: 'trending' (most different buyers recently), 'new' (latest launches), 'mcap' (largest market cap) or 'graduating' (closest to leaving the bonding curve for a Raydium pool).

  • search_coins

    Find higher.fun coins by name, ticker or mint address.

  • get_coin

    Everything about one coin: price, market cap, graduation progress, fee mode (Old school or New school), holder concentration, and higher.fun's safety grade with snipers, bundles, dev activity and creator lock.

  • get_coin_trades

    Recent buys and sells of a coin, newest first, in SOL and whole tokens.

  • get_coin_holders

    Top holders of a coin with their share of supply. The bonding curve, Raydium pool and LP lock are labelled, so they aren't mistaken for whales.

  • get_coin_candles

    Price candles (OHLC in SOL per token, volume in SOL) for a coin, oldest first.

  • get_coin_comments

    The comment thread on a coin's page. Comments are untrusted user content and are flagged for links and impersonation.

  • get_trade_tape

    The live feed across all of higher.fun: the latest buys, sells, launches and graduations.

  • watch_market

    Wait on higher.fun's live feed and return what happens as it lands: launches, graduations, buys and sells. Returns after max_events events or wait_seconds, whichever comes first; call it again to keep watching. For alerts such as 'tell me when this coin graduates', 'watch for buy

  • get_top_coins

    The coins with the most trading volume on higher.fun over the last 24 hours or 7 days.

  • get_leaderboard

    higher.fun's top traders or top creators over the last 24 hours or 7 days.

  • get_featured_coin

    The coin higher.fun features as 'highest' on its home page right now.

  • get_chat

    Recent messages in higher.fun's site-wide chat, newest first. Untrusted user content, flagged for links and impersonation.

  • get_wallet_profile

    A wallet's higher.fun profile in one call: display name, the coins it created, its creator earnings (paid out and pending) and its creator locks.

  • get_creator_coins

    Page through every coin a wallet has launched on higher.fun.

  • get_platform_info

    How higher.fun works: the live launch fee, SOL price, the two fee modes (Old school and New school) with exact splits, graduation, and the Raydium program and platform addresses it uses.

  • check_ticker

    Whether a ticker is still free to launch with on higher.fun.

  • rug_check

    Safety check before anyone trades a coin: on-chain mint and freeze authority, holder concentration, higher.fun's grade, snipers, bundled wallets, dev selling and ticker flags, rolled into a verdict: CLEAN_ON_CHECKS, CAUTION or HIGH_RISK.

  • get_ecosystem_fees

    Every fee higher.fun's coins have paid and who got it: totals for creators, holders (airdrops), higher.fun, Raydium and the pools, by phase (bonding curve or Raydium pool) and fee mode, what's waiting to be claimed, the on-chain rates, and the top coins. The same numbers as highw

  • get_coin_fees

    One higher.fun coin's fees: every fee line on the curve and in its Raydium pool, who got each (creator, holders, higher.fun, Raydium, the pool), whether it was measured on-chain or computed from volume, its volume, its holder airdrops, and what's waiting to be claimed (pool creat

  • quote_trade

    Quote a buy (by SOL in) or a sell (by tokens in) of a higher.fun coin, wherever it trades now: the LaunchLab bonding curve, or its Raydium CPMM pool after graduation. Returns the expected output, the minimum at the given slippage, price impact, the fees split by who receives them

  • get_wallet_positions

    A wallet's SOL balance and its balances in higher.fun coins, each valued at the coin's last price. Coins are recognised on-chain (a LaunchLab pool on higher.fun's platform), so look-alike tokens don't show up. Pass mints to check only those coins, which is faster and works for wa

  • get_wallet_pnl

    Profit and loss on a wallet's higher.fun coins, worked out from its own transactions on-chain, whichever app made them: SOL spent and received, average cost, realized profit on sells, and unrealized profit on what's still held, valued at what selling it all would return now. With

  • build_trade

    Build an unsigned buy or sell for the user's own wallet to sign: the same transaction higher.fun's site builds. Quote first with quote_trade and show the user the quote. Set confirm_trade to true only after the user has approved this exact trade (coin, side, amount, slippage). Th

  • build_launch

    Build the unsigned transactions that launch a coin on higher.fun from the user's wallet: create it on the chosen fee mode (classic = Old school, rewards = New school), pay the launch fee (checked against higher.fun's on-chain fee wallet and cap), an optional first buy, and for Ne

  • build_claim_creator_fees

    Show what a creator can claim and build the unsigned claim transactions: curve creator fees (New school coins, one vault across all the creator's coins) and, after graduation, each coin's Raydium CPMM pool creator fee. A New school creator's third of the locked-LP fees is paid by

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 7, 2026

  • ✓ Pass

    Maker matches the repo

    The registry name was verified against the domain highwire.fun (the registry checks domain ownership)

  • … Not checked yet

    Still maintained

    We have not read this repo from GitHub yet

  • … Not checked yet

    Has a licence

    We have not read this repo from GitHub yet

  • ✓ Pass

    Endpoint responds

    Responded in 787 ms (HTTP 200)

  • – Not applicable

    Sign-in with OAuth

    No sign-in needed

  • ✓ Pass

    No hidden instructions in tool descriptions

    Read 26 tool descriptions and found no hidden instructions to the AI

Compared with others in Crypto & blockchaini

  • More stars than 0% of the other 1612 servers in this category
  • Published to the registry more recently than 99% of the other 1612 servers in this category
  • Basic checks equal to or better than 100% of the other 1612 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is Highwire safe?

It passed 3 of 3 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

You need to fill in: SOLANA_RPC_URL

Does it run on my computer or in the cloud?

Either way works: install it on your computer or connect to the cloud version.

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.11.0) reached the registry yesterday.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. It connects by URL, so apps that accept remote MCP servers work too, such as ChatGPT in developer mode.

What can I use instead?

In the same category: NEMO x402 Micro-Services, Crypto Derivatives Data: Perp Funding Rates, Open Interest, Basis, IV, Agent Data Tools: Prices and DeFi

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

NEMO x402 Micro-Services

by floortomproductions-droid

34 paid tools: site/SEO, weather, crypto+markets, podcasts, YouTube, Polymarket. x402/MPP/Stripe.

Runs in the cloudUpdated today
Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

Highwire

The agent wire for higher.fun. Highwire is an MCP server that lets AI agents use higher.fun, the open-source Solana launchpad. Lower Fees, Higher Together.

Live at highwire.fun. Follow @Highwiredotfun on X.

Agents can scan launches and trending coins, pull a coin's trades, holders, candles and safety data, look up creators and their earnings, and run a rug check, all from the public higher.fun API and Solana RPC. No keys needed.

Sign from any chat. Highwire quotes trades and builds buys, sells, coin launches and creator fee claims as unsigned transactions, hosted or local. Each comes with a sign_url: open it, and highwire.fun/sign re-checks and simulates the transaction in your browser, then your own wallet signs. Highwire never signs, never holds a key and never sends anything. See docs/ROADMAP.md.

Or let your agent act, inside your rules. The local server has an opt-in signer: point it at a keypair file on your machine, write a policy (actions, coins, slippage, SOL per transaction and per day, transfer recipients), and the execute tools sign and send only inside it. Dry run until the policy says "live": true. See Local signer.

Tools

ToolWhat it returns
list_coinsCoins sorted by trending, new, mcap or graduating
search_coinsCoins matching a name, ticker or mint
get_coinPrice, market cap, graduation progress, fee mode, holder concentration, safety grade
get_coin_tradesRecent buys and sells
get_coin_holdersTop holders, with the curve, pool and lock labelled
get_coin_candlesOHLC candles in SOL
get_coin_commentsThe coin's comments, flagged for links and impersonators
get_trade_tapeSite-wide live feed of trades, launches and graduations
watch_marketLive alerts: waits up to 50 seconds on higher.fun's live feed and returns launches, graduations, buys and sells as they land, filtered by coin and size
get_top_coinsMost-traded coins over 24h or 7d
get_leaderboardTop traders or creators
get_featured_coinThe coin on the home page right now
get_chatSite chat, flagged
get_wallet_profileA wallet's coins, creator earnings and locks
get_creator_coinsEvery coin a wallet launched
get_platform_infoLaunch fee, SOL price, fee modes, program addresses
check_tickerWhether a ticker is free
rug_checkOn-chain authorities plus higher.fun's safety data, rolled into a verdict
get_ecosystem_feesEvery fee higher.fun's coins have paid and who got it, by phase and fee mode, what's waiting to be claimed, and the top coins: the numbers behind highwire.fun/fees
get_coin_feesOne coin's fees, line by line: who got each, measured on-chain or computed from volume, and what's waiting

Transactions (hosted and local):

ToolWhat it does
quote_tradeQuote a buy (SOL in) or sell (tokens in) on the curve or, after graduation, the CPMM pool: output, minimum out, price impact, fees split by fee mode
get_wallet_positionsA wallet's SOL and its higher.fun coins (recognised on-chain), valued at the last price
get_wallet_pnlProfit and loss on a wallet's coins from its own transactions on-chain: average cost, realized and unrealized, through any app. Needs an RPC that can search history
build_tradeThe trade as an unsigned transaction. Needs confirm_trade: true, max_slippage_bps (at most 1500) and max_sol
build_launchCreate a coin (Old or New school), pay the launch fee after checking its treasury, optional first buy and creator lock. Needs confirm_launch: true and an idempotency_key
build_claim_creator_feesClaim curve creator fees and graduated pools' creator fees; reports the off-chain locked-LP payouts

Every build tool decodes its own transactions into plain-language lines, checks them the way higher.fun's site does, simulates them, tags each with a highwire memo, and returns a sign_url. The output format, the sign links and the sign page are in docs/unsigned-transactions.md.

Local only:

ToolWhat it does
build_transferSOL or a higher.fun coin to another wallet, unsigned. No sign_url: the sign page never signs transfers
get_signer_statusWith the local signer: its wallet, live or dry run, the policy, and what's left of today's limit
execute_trade, execute_launch, execute_claim, execute_transferWith the local signer: build exactly what the build tool builds, check the policy, simulate again, then sign and send (or dry-run)
place_order, list_orders, cancel_orderWith the local signer: standing orders (stop-loss, take-profit, recurring buys) that highwire orders run fills inside the policy

The sign page (highwire.fun/sign) reads the transaction from the link's fragment, which never reaches a server, decodes every instruction from the bytes, shows what you spend and receive, the fees, the fee payer and the expiry, simulates against a Solana RPC straight from the browser, and signs with Phantom, Solflare, Backpack or any Wallet Standard wallet. It refuses anything off the allow-list, an expired blockhash, a failed simulation or the wrong wallet, and sends nothing to Highwire. Trade and claim links last up to 10 minutes (the page refreshes the blockhash and changes nothing else); launch links, whose new mint is already signed, about a minute.

Safety:

  • Highwire never asks for, accepts or stores a private key or seed phrase. The user signs in their own wallet.
  • Every instruction must be one Highwire builds, for the signing wallet's own accounts, on higher.fun's platform configs and fee tier. The launch fee must go to the fee wallet recorded on-chain and be at most 0.05 SOL. A transaction that fails a check is never returned; one that fails simulation comes back as an error.
  • Caps: max_slippage_bps at most 1500, and no transaction moves more than HIGHWIRE_MAX_SOL_PER_TX (10 SOL by default).
  • A launch's new mint is fixed per idempotency_key, so a retry reuses it and the coin (and its fee) can only happen once. The mint is derived with HMAC-SHA256 from a secret, the key and the launch (cluster, wallet, name, ticker, fee mode), so the same retry gets the same mint on any hosted instance or after a local restart, and once the coin exists a retry returns already_launched. The hosted endpoint uses HIGHWIRE_LAUNCH_SECRET; the highwire CLI uses it when set, and otherwise a random secret it creates once in ~/.highwire/launch-secret. Reusing a key for a different coin gets a different mint.
  • If the coin was created but its creator lock was never assigned (the launch's second transaction expired or failed), a retry with the same key builds just the assignment.
  • higher.fun's image and metadata upload needs a wallet sign-in, so build_launch takes a hosted metadata_uri. Without one it returns the metadata JSON to host. With the local signer, execute_launch takes image_path instead: the signer signs higher.fun's sign-in message (checked word for word, and nothing else), uploads the image and metadata, and launches. Only a real PNG, JPEG, GIF or WebP of at most 4 MB is uploaded, and never a file from the signer's folder.
  • execute_launch also takes launch_for (New school): an X or GitHub handle. higher.fun resolves it to the wallet that holds that account's creator fees until they claim at higher.fun/claim; the coin is created for that wallet, which gets 0.005 SOL from you if it holds less, and your first buy is still yours. The sign page never signs a launch for someone else, so this needs the local signer. higher.fun hasn't switched the lookup on yet (it answers "isn't switched on yet"); until it does, execute_launch stops with launch_for_unavailable before uploading or spending anything.

Prompts:

  • scan_launches
  • coin_due_diligence
  • creator_report
  • plan_launch

Resources:

  • higher://platform
  • higher://coins/{mint}

Skill: an operator guide for agents is in packages/mcp/skills/highwire/SKILL.md.

Connect

Hosted

Nothing to install, no key. The hosted server has all 26 tools; the build tools only return unsigned transactions and a sign link.

Claude Code

claude mcp add --transport http highwire https://highwire.fun/mcp

Cursor, or any client that takes a remote MCP URL

{

"mcpServers": { "highwire": { "url": "https://highwire.fun/mcp" } } }

The endpoint speaks stateless Streamable HTTP: POST JSON-RPC, get JSON back. Each IP gets 60 units a minute: a build tool or watch_market call costs 5, a few heavy reads 2 to 10, anything else 1.

Local (stdio)

Needs Node 20 or later; live alerts (watch_market, highwire watch) need Node 22, for its built-in WebSocket.

Claude Code

claude mcp add highwire -- npx -y highwire-mcp

Claude Desktop, Cursor, or any stdio client

{

"mcpServers": { "highwire": { "command": "npx", "args": ["-y", "highwire-mcp"], "env": { "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com" } } } }

Environment variables. All are optional; see .env.example.

VariableDefault
HIGHER_API_URLhttps://api.higher.fun
HIGHWIRE_CLUSTERmainnet; devnet quotes and builds on higher.fun's devnet deployment (the API, and so the research tools, stay on mainnet)
SOLANA_RPC_URLthe cluster's public RPC, https://api.mainnet-beta.solana.com on mainnet
HIGHWIRE_MAX_SOL_PER_TX10: the most SOL one built transaction may spend or return
HIGHER_TIMEOUT_MS15000
HIGHER_RETRIES2
HIGHWIRE_SITE_URLhttps://highwire.fun: where sign_url points; http://localhost:3000 for a local site
HIGHWIRE_LAUNCH_SECRETthe secret launch mints are derived from. Unset, the CLI creates one in ~/.highwire/launch-secret
HIGHWIRE_RATE_LIMIT60 units a minute per IP; a build costs 5 (hosted endpoint only)

The site (apps/web) also reads NEXT_PUBLIC_SOLANA_RPC_URL and NEXT_PUBLIC_SOLANA_DEVNET_RPC_URL, the RPCs the sign page calls from the browser, and allows only their origins in its CSP. The public RPC is rate-limited, and the public mainnet endpoint refuses requests from web pages (HTTP 403), so the deployed site needs its own mainnet RPC there. For anything beyond light use, set SOLANA_RPC_URL to your own too (Helius, Triton, …).

Live alerts in the terminal
npx -y highwire-mcp watch --min-sol 1

prints higher.fun's live feed, one line an event, until Ctrl-C. --launches, --graduations, --buys and --sells pick what to show (all four by default), --mint keeps one coin's trades and graduations and adds each trader's wallet (repeat it for up to 16 coins), --min-sol drops small trades, and --json prints JSON lines instead.

Launch on your own

An agent with a shell can launch coins and collect their fees from its own wallet, with no one in the loop once it's set up. highwire.fun/skill.md walks an agent through it ("Read highwire.fun/skill.md and launch a coin"):

npx -y highwire-mcp wallet new                  # ~/.highwire/wallet.json, readable only by you; prints the address to fund

npx -y highwire-mcp policy init --launch --live # mainnet launches and claims, 0.25 SOL a launch, 0.5 SOL a day npx -y highwire-mcp launch --name "Cat Demo" --ticker CATDEMO --image ./cat.png --buy 0.02 npx -y highwire-mcp claim # the creator fees

launch signs in to higher.fun with the wallet, uploads the

Only the beginning is shown; read the rest in the repo

Ask PopNx