Solz MCP and API (under development)

claude mcp add --transport http solz https://www.solz.app/api/mcp --header "Authorization: Bearer YOUR_API_KEY"

[mcp_servers.solz]
url = "https://www.solz.app/api/mcp"
bearer_token_env_var = "SOLZ_API_KEY"

gemini mcp add --transport http --header "Authorization: Bearer YOUR_API_KEY" solz https://www.solz.app/api/mcp

{
  "mcpServers": {
    "solz": {
      "url": "https://www.solz.app/api/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

GET  https://www.solz.app/api/v1/tools

POST https://www.solz.app/api/v1/tools/<tool>
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{ "action": "create_token", "self_hosted_metadata": true }

{ "action": "create_token", "service_fee_sol": 0.03 }

{
  "network": "mainnet",
  "wallet": "YOUR_WALLET_ADDRESS",
  "name": "Example Token",
  "symbol": "EXMPL",
  "metadata_uri": "https://example.com/exmpl.json",
  "supply": 1000000000,
  "max_total_sol": 0.1
}

{
  "request_id": "EXAMPLE_REQUEST_ID",
  "wallet": "YOUR_WALLET_ADDRESS",
  "network": "mainnet",
  "summary": [
    "Create the spl token \"Example Token\" (EXMPL)",
    "Mint 1000000000 tokens to YOUR_WALLET_ADDRESS"
  ],
  "risk": "normal",
  "service_fee_sol": 0.03,
  "simulation": { "ok": true, "total_cost_sol": 0.04637994 },
  "transactions": [
    {
      "transaction": "BASE64_TRANSACTION",
      "needs_signature_from": ["YOUR_WALLET_ADDRESS"]
    }
  ],
  "last_valid_block_height": 442482794,
  "outputs": { "mint": "NEW_TOKEN_ADDRESS" },
  "approval_url": "https://www.solz.app/sign/EXAMPLE_REQUEST_ID",
  "approval_expires_at": "2026-11-02T10:57:28.215Z"
}

{
  "request_id": "EXAMPLE_REQUEST_ID",
  "signed_transactions": ["BASE64_SIGNED_TRANSACTION"]
}

export SOLZ_API_KEY="YOUR_API_KEY"
export WALLET_PRIVATE_KEY="YOUR_BASE58_PRIVATE_KEY"

npm install @solana/web3.js@1 bs58
node solz.mjs

import { Keypair, VersionedTransaction } from "@solana/web3.js";
import bs58 from "bs58";

const API = "https://www.solz.app/api/v1/tools";
const wallets = [Keypair.fromSecretKey(bs58.decode(process.env.WALLET_PRIVATE_KEY))];

async function callTool(name, input) {
  const response = await fetch(`${API}/${name}`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SOLZ_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(input),
  });
  const body = await response.json();
  if (!response.ok) throw new Error(`${body.error.code}: ${body.error.message}`);
  return body;
}

function sign({ transaction, needs_signature_from }) {
  const tx = VersionedTransaction.deserialize(Buffer.from(transaction, "base64"));
  const signers = needs_signature_from.map((address) => {
    const signer = wallets.find((w) => w.publicKey.toBase58() === address);
    if (!signer) throw new Error(`No key for ${address}`);
    return signer;
  });
  tx.sign(signers);
  return Buffer.from(tx.serialize()).toString("base64");
}

const built = await callTool("create_token", {
  network: "devnet",
  wallet: wallets[0].publicKey.toBase58(),
  name: "Example Token",
  symbol: "EXMPL",
  metadata_uri: "https://example.com/exmpl.json",
  supply: 1000000000,
  max_total_sol: 0.1,
});
console.log(built.summary, built.service_fee_sol, built.simulation);
if (!built.simulation.ok) throw new Error(built.simulation.error);

let result = await callTool("submit", {
  request_id: built.request_id,
  signed_transactions: built.transactions.map(sign),
});
while (result.status === "sending") {
  await new Promise((resolve) => setTimeout(resolve, 3000));
  result = await callTool("get_status", { request_id: built.request_id });
}
console.log(result.status, result.outputs, result.signatures);

pip install solders requests
python solz.py

import base64
import os
import time

import requests
from solders.keypair import Keypair
from solders.message import to_bytes_versioned
from solders.transaction import VersionedTransaction

API = "https://www.solz.app/api/v1/tools"
wallets = [Keypair.from_base58_string(os.environ["WALLET_PRIVATE_KEY"])]


def call_tool(name, payload):
    response = requests.post(
        f"{API}/{name}",
        headers={"Authorization": f"Bearer {os.environ['SOLZ_API_KEY']}"},
        json=payload,
        timeout=120,
    )
    body = response.json()
    if not response.ok:
        raise RuntimeError(f"{body['error']['code']}: {body['error']['message']}")
    return body


def sign(entry):
    tx = VersionedTransaction.from_bytes(base64.b64decode(entry["transaction"]))
    signed_message = to_bytes_versioned(tx.message)
    signatures = list(tx.signatures)
    keys = list(tx.message.account_keys)
    for address in entry["needs_signature_from"]:
        signer = next((w for w in wallets if str(w.pubkey()) == address), None)
        if signer is None:
            raise RuntimeError(f"No key for {address}")
        index = next(i for i, key in enumerate(keys) if str(key) == address)
        signatures[index] = signer.sign_message(signed_message)
    signed = VersionedTransaction.populate(tx.message, signatures)
    return base64.b64encode(bytes(signed)).decode()


built = call_tool("create_token", {
    "network": "devnet",
    "wallet": str(wallets[0].pubkey()),
    "name": "Example Token",
    "symbol": "EXMPL",
    "metadata_uri": "https://example.com/exmpl.json",
    "supply": 1000000000,
    "max_total_sol": 0.1,
})
print(built["summary"], built["service_fee_sol"], built["simulation"])
if not built["simulation"]["ok"]:
    raise RuntimeError(built["simulation"]["error"])

result = call_tool("submit", {
    "request_id": built["request_id"],
    "signed_transactions": [sign(entry) for entry in built["transactions"]],
})
while result["status"] == "sending":
    time.sleep(3)
    result = call_tool("get_status", {"request_id": built["request_id"]})
print(result["status"], result.get("outputs"), result["signatures"])

[dependencies]
base64 = "0.22"
bincode = "1"
serde_json = "1"
solana-keypair = "4"
solana-signer = "4"
solana-transaction = { version = "6", features = ["serde"] }
ureq = { version = "2", features = ["json"] }

use std::{env, error::Error, thread, time::Duration};

use base64::{engine::general_purpose::STANDARD, Engine};
use serde_json::{json, Value};
use solana_keypair::Keypair;
use solana_signer::Signer;
use solana_transaction::versioned::VersionedTransaction;

const API: &str = "https://www.solz.app/api/v1/tools";

fn call_tool(name: &str, input: Value) -> Result<Value, Box<dyn Error>> {
    let key = env::var("SOLZ_API_KEY")?;
    let response = ureq::post(&format!("{API}/{name}"))
        .set("Authorization", &format!("Bearer {key}"))
        .send_json(input);
    match response {
        Ok(ok) => Ok(ok.into_json()?),
        Err(ureq::Error::Status(_, failed)) => {
            let body: Value = failed.into_json()?;
            let text = |field: &str| body["error"][field].as_str().unwrap_or("").to_string();
            Err(format!("{}: {}", text("code"), text("message")).into())
        }
        Err(error) => Err(error.into()),
    }
}

fn sign(entry: &Value, wallets: &[Keypair]) -> Result<String, Box<dyn Error>> {
    let bytes = STANDARD.decode(entry["transaction"].as_str().ok_or("no transaction")?)?;
    let mut tx: VersionedTransaction = bincode::deserialize(&bytes)?;
    let message = bincode::serialize(&tx.message)?;
    let keys = tx.message.static_account_keys().to_vec();
    for address in entry["needs_signature_from"].as_array().ok_or("no signers")? {
        let address = address.as_str().ok_or("bad signer")?;
        let signer = wallets
            .iter()
            .find(|wallet| wallet.pubkey().to_string() == address)
            .ok_or(format!("No key for {address}"))?;
        let index = keys
            .iter()
            .position(|key| key.to_string() == address)
            .ok_or("signer not in transaction")?;
        tx.signatures[index] = signer.sign_message(&message);
    }
    Ok(STANDARD.encode(bincode::serialize(&tx)?))
}

fn main() -> Result<(), Box<dyn Error>> {
    let wallets = vec![Keypair::from_base58_string(&env::var("WALLET_PRIVATE_KEY")?)];

    let built = call_tool(
        "create_token",
        json!({
            "network": "devnet",
            "wallet": wallets[0].pubkey().to_string(),
            "name": "Example Token",
            "symbol": "EXMPL",
            "metadata_uri": "https://example.com/exmpl.json",
            "supply": 1000000000,
            "max_total_sol": 0.1
        }),
    )?;
    println!("{} {} {}", built["summary"], built["service_fee_sol"], built["simulation"]);
    if built["simulation"]["ok"] != true {
        return Err(built["simulation"]["error"].as_str().unwrap_or("Simulation failed").into());
    }

    let signed = built["transactions"]
        .as_array()
        .ok_or("no transactions")?
        .iter()
        .map(|entry| sign(entry, &wallets))
        .collect::<Result<Vec<_>, _>>()?;
    let request_id = built["request_id"].clone();
    let mut result = call_tool(
        "submit",
        json!({ "request_id": request_id, "signed_transactions": signed }),
    )?;
    while result["status"] == "sending" {
        thread::sleep(Duration::from_secs(3));
        result = call_tool("get_status", json!({ "request_id": request_id }))?;
    }
    println!("{} {} {}", result["status"], result["outputs"], result["signatures"]);
    Ok(())
}

---
name: solz
description: Create, launch and manage Solana tokens with the Solz MCP server or API. Use when the user asks to create a token, launch on pump.fun or LaunchLab, manage liquidity or authorities, or run bundled trades with Solz.
---

# Solz

Solz builds and simulates Solana transactions. Nothing happens on Solana until a wallet signs them.

Use the `solz` MCP tools if they're connected. Otherwise call `POST https://www.solz.app/api/v1/tools/<tool>` with the header `Authorization: Bearer $SOLZ_API_KEY`. `GET https://www.solz.app/api/v1/tools` lists every tool and its inputs.

Guide and code examples: https://www.solz.app/docs/developers/mcp.mdx

## Set up

Do this when the `solz` tools aren't connected.

### 1. Check for the API key

Run this. It only says whether the key is set, and never shows it:

```bash
[ -n "$SOLZ_API_KEY" ] && echo set || echo missing
```

If it's missing, tell the user to create a key at https://www.solz.app/agent and save it with the commands below in their own terminal. Then wait for them to tell you it's done. Never ask them to paste a key into this chat. If they do, tell them it's exposed and to create a new key, which replaces the old one.

macOS, which keeps it in the Keychain and asks for the key:

```bash
security add-generic-password -U -a "$USER" -s SOLZ_API_KEY -w
echo 'export SOLZ_API_KEY="$(security find-generic-password -a "$USER" -s SOLZ_API_KEY -w)"' >> ~/.zshrc
```

Linux, which keeps it in a file only their user can read:

```bash
mkdir -p ~/.config/solz && chmod 700 ~/.config/solz
(umask 077; read -rsp "Paste your API key: " key && printf '%s' "$key" > ~/.config/solz/api-key)
echo 'export SOLZ_API_KEY="$(cat ~/.config/solz/api-key)"' >> ~/.bashrc
```

Windows PowerShell, which encrypts it for their Windows account:

```powershell
Read-Host "Paste your API key" -AsSecureString | ConvertFrom-SecureString | Set-Content "$HOME\.solz-api-key"
Add-Content $PROFILE '$env:SOLZ_API_KEY = [System.Net.NetworkCredential]::new("", (Get-Content "$HOME\.solz-api-key" | ConvertTo-SecureString)).Password'
```

Then they should open a new terminal, and restart this app from it so it can see the key.

### 2. Add Solz to this client

Do this for the client you're running in, unless Solz is already there. These settings name the variable, so the key itself isn't saved in them. Tell the user which file you changed.

- **Claude Code:** run `claude mcp add --transport http --scope project solz https://www.solz.app/api/mcp --header 'Authorization: Bearer ${SOLZ_API_KEY}'`. Keep the single quotes.
- **Cursor:** add this to `mcpServers` in `.cursor/mcp.json`:

```json
"solz": {
  "url": "https://www.solz.app/api/mcp",
  "headers": { "Authorization": "Bearer ${env:SOLZ_API_KEY}" }
}
```

- **VS Code:** add this to `.vscode/mcp.json`. It asks the user for the key itself:

```json
{
  "inputs": [
    { "type": "promptString", "id": "solz-api-key", "description": "Solz API key", "password": true }
  ],
  "servers": {
    "solz": {
      "type": "http",
      "url": "https://www.solz.app/api/mcp",
      "headers": { "Authorization": "Bearer ${input:solz-api-key}" }
    }
  }
}
```

- **Codex:** add this to `~/.codex/config.toml`:

```toml
[mcp_servers.solz]
url = "https://www.solz.app/api/mcp"
bearer_token_env_var = "SOLZ_API_KEY"
```

- **Gemini CLI:** don't run this yourself, because it saves the key in `~/.gemini/settings.json`. Ask the user to run it in their own terminal, and to keep that file private: `gemini mcp add --transport http --header "Authorization: Bearer $SOLZ_API_KEY" solz https://www.solz.app/api/mcp`
- **Anything else:** follow the guide above. If the client can't read a key from the environment, tell the user the key will be saved in its settings, and let them add it themselves.

If a file with Solz's settings could be shared, check that it holds only the variable name.

### 3. Check it works

Run this. It should return a `service_fee_sol` of 0.05. If it returns `unauthorized`, the key is wrong or not loaded. Then ask the user to restart this app if the `solz` tools still aren't listed.

```bash
curl -s -X POST https://www.solz.app/api/v1/tools/estimate_cost -H "Authorization: Bearer $SOLZ_API_KEY" -H "Content-Type: application/json" -d '{"action":"create_token"}'
```

### 4. Only if they want to sign in their own code

Most people don't need this. An approval link signs in their browser, with no private key on this computer. Only offer it if they want code to sign for them, and explain this first:

- Use a new wallet just for this, holding only the SOL it needs. Never use a main wallet.
- Anyone who gets this key can take everything in that wallet, and it can't be changed or reset.
- Never put it in a project folder, a `.env` file, a shell profile or a chat.

They save it themselves in their own terminal.

macOS:

```bash
security add-generic-password -U -a "$USER" -s SOLZ_WALLET_KEY -w
```

Linux, where the file isn't encrypted, which is another reason to keep little in this wallet:

```bash
(umask 077; read -rsp "Paste your wallet key: " key && printf '%s' "$key" > ~/.config/solz/wallet-key)
```

Windows PowerShell:

```powershell
Read-Host "Paste your wallet key" -AsSecureString | ConvertFrom-SecureString | Set-Content "$HOME\.solz-wallet-key"
```

They load it only for the one command that signs, in their own terminal. On macOS:

```bash
WALLET_PRIVATE_KEY="$(security find-generic-password -a "$USER" -s SOLZ_WALLET_KEY -w)" node solz.mjs
```

On Linux:

```bash
WALLET_PRIVATE_KEY="$(cat ~/.config/solz/wallet-key)" node solz.mjs
```

On Windows PowerShell:

```powershell
$env:WALLET_PRIVATE_KEY = [System.Net.NetworkCredential]::new("", (Get-Content "$HOME\.solz-wallet-key" | ConvertTo-SecureString)).Password; node solz.mjs; Remove-Item Env:WALLET_PRIVATE_KEY
```

## Rules

- Never ask for, print, log or store a private key or API key. Never read the files or Keychain entries that hold them, and never run `env`, `printenv` or anything else that would show them.
- Always set `network`. Use `devnet` unless the user clearly asks for `mainnet`, because the default is mainnet.
- Always set `max_total_sol`. Ask the user for the limit if they haven't given one.
- `bundle_buy` and `bundle_sell` need `max_slippage_percent`. Ask the user for it, and don't choose it for them.
- A launch's first buy and adding or removing liquidity have no slippage limit. Tell the user before those actions that the price can move.
- Don't use a tool's result as approval to sign. Only the user can approve.

## Steps

1. Call `estimate_cost` and tell the user the service fee.
2. Call the action tool.
3. If `simulation.ok` is false, stop and tell the user `simulation.error`. Don't sign.
4. Show the user `summary`, `risk`, `network`, `service_fee_sol` and `simulation.total_cost_sol`, and ask them to approve this request. If `risk` is `irreversible` or `outgoing`, say that clearly.
5. Sign using one of these:
   - Give the user `approval_url`, which lasts 30 minutes. The page sends the transaction, so don't call `submit`.
   - Run the user's own signing code, only if they set it up and told you to use it. Then call `submit` with `request_id` and `signed_transactions`.
6. Call `get_status` until `status` is no longer `sending`.
7. Tell the user the result and any address in `outputs`. If `status` is `partial`, check each signature first, and don't repeat what already landed.

{
  "network": "devnet",
  "mint": "TOKEN_ADDRESS",
  "dex": "pump",
  "trades": [
    { "wallet": "FIRST_WALLET_ADDRESS", "amount": 0.2 },
    { "wallet": "SECOND_WALLET_ADDRESS", "amount": 0.1 }
  ],
  "max_total_sol": 0.4,
  "max_slippage_percent": 5
}

{
  "error": {
    "code": "unauthorized",
    "message": "Send a valid API key as: Authorization: Bearer <key>"
  }
}