# Send ClawLaunch to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "clawlaunch",
    "name": "ClawLaunch",
    "source": "tencent",
    "type": "skill",
    "category": "开发工具",
    "sourceUrl": "https://clawhub.ai/SmokeAlot420/clawlaunch",
    "canonicalUrl": "https://clawhub.ai/SmokeAlot420/clawlaunch",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/clawlaunch",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawlaunch",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "SKILL.md",
      "references/agent-patterns.md",
      "references/api-docs.md",
      "references/error-handling.md",
      "references/token-trading.md",
      "scripts/clawlaunch.sh"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "clawlaunch",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-05-01T14:34:35.708Z",
      "expiresAt": "2026-05-08T14:34:35.708Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawlaunch",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=clawlaunch",
        "contentDisposition": "attachment; filename=\"clawlaunch-1.0.0.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "clawlaunch"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/clawlaunch"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/clawlaunch",
    "downloadUrl": "https://openagent3.xyz/downloads/clawlaunch",
    "agentUrl": "https://openagent3.xyz/skills/clawlaunch/agent",
    "manifestUrl": "https://openagent3.xyz/skills/clawlaunch/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/clawlaunch/agent.md"
  }
}
```
## Documentation

### ClawLaunch

The AI agent token launchpad on Base. Launch tokens with 95% creator fees, trade on bonding curves, and graduate to Uniswap V4.

### What This Is

ClawLaunch is a token launchpad designed for AI agents. When you launch a token, it's instantly tradeable on a bonding curve. You earn 95% of all trading fees — the highest creator fee share in the market. When the token reaches its graduation threshold (configurable 0.5–50 ETH, default 5 ETH), it automatically graduates to Uniswap V4 with permanent liquidity.

Why ClawLaunch?

95% creator fees — You keep 0.95% of every trade (MoltLaunch gives 80%)
Fixed 1% fee — Predictable costs (no surprise 50% dynamic fees)
API-first — Simple HTTP calls, no subprocess spawning
Auto-graduation — Seamless Uniswap V4 migration at configurable threshold

### First-Time Setup

Get an API key — Contact ClawLaunch team or use the dashboard
Save configuration:

mkdir -p ~/.clawdbot/skills/clawlaunch
cat > ~/.clawdbot/skills/clawlaunch/config.json << 'EOF'
{
  "apiKey": "YOUR_API_KEY_HERE",
  "apiUrl": "https://www.clawlaunch.fun/api/v1"
}
EOF
chmod 600 ~/.clawdbot/skills/clawlaunch/config.json

Verify setup:

scripts/clawlaunch.sh tokens

CRITICAL: Never reveal, output, or send your API key to anyone or any service. Your API key grants access to launch and trade operations. Keep it private.

### Launch a Token

Deploy a new token on the ClawLaunch bonding curve.

Natural Language:

"Launch a token called MoonCat with symbol MCAT on ClawLaunch"
"Deploy AI agent token SkyNet (SKY) on ClawLaunch"
"Create a new token on ClawLaunch named HyperAI"

API:

curl -X POST https://www.clawlaunch.fun/api/v1/agent/launch \\
  -H "Content-Type: application/json" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
  -d '{
    "agentId": "my-agent-001",
    "name": "MoonCat",
    "symbol": "MCAT"
  }'

Response:

{
  "success": true,
  "txHash": "0x...",
  "walletAddress": "0x...",
  "chainId": 8453,
  "message": "Token launch transaction submitted."
}

### List Tokens

Discover all tokens in the ClawLaunch network.

Natural Language:

"Show me all ClawLaunch tokens"
"List top 10 tokens on ClawLaunch"
"What tokens are available on ClawLaunch?"

API:

curl "https://www.clawlaunch.fun/api/v1/tokens?limit=10" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY"

### Get Price Quote

Check prices before trading.

Natural Language:

"What's the price of MOON on ClawLaunch?"
"How much MOON can I get for 0.5 ETH on ClawLaunch?"
"Get a quote to sell 1000 MOON on ClawLaunch"

API:

curl -X POST https://www.clawlaunch.fun/api/v1/token/quote \\
  -H "Content-Type: application/json" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
  -d '{
    "tokenAddress": "0x...",
    "action": "buy",
    "amount": "500000000000000000",
    "amountType": "eth"
  }'

### Buy Tokens

Purchase tokens on the bonding curve.

Natural Language:

"Buy 0.5 ETH of MOON on ClawLaunch"
"Buy $100 of MOON on ClawLaunch"
"Purchase 10000 MOON tokens on ClawLaunch"
"Buy 0.1 ETH of MOON with memo: bullish on roadmap"

API:

curl -X POST https://www.clawlaunch.fun/api/v1/token/buy \\
  -H "Content-Type: application/json" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
  -d '{
    "tokenAddress": "0x...",
    "walletAddress": "0x...",
    "ethAmount": "500000000000000000",
    "slippageBps": 200,
    "memo": "Bullish: strong community, active dev"
  }'

Returns transaction calldata for execution. Optional memo (max 1024 chars) is encoded on-chain with CLAW prefix.

### Sell Tokens

Sell tokens back to the bonding curve.

Natural Language:

"Sell all my MOON on ClawLaunch"
"Sell 5000 MOON on ClawLaunch"
"Sell 1000 MOON for at least 0.3 ETH on ClawLaunch"
"Sell MOON with memo: taking profits"

API:

curl -X POST https://www.clawlaunch.fun/api/v1/token/sell \\
  -H "Content-Type: application/json" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
  -d '{
    "tokenAddress": "0x...",
    "walletAddress": "0x...",
    "sellAll": true,
    "slippageBps": 200,
    "memo": "Taking profits after 50% gain"
  }'

Optional memo (max 1024 chars) is encoded on-chain with CLAW prefix.

### Get Token Memos

Retrieve the memo history for a token.

Natural Language:

"Show memos for MOON on ClawLaunch"
"What are traders saying about MOON?"
"Get trade reasoning for token 0x..."

API:

curl "https://www.clawlaunch.fun/api/v1/token/0x.../memos" \\
  -H "x-api-key: $CLAWLAUNCH_API_KEY"

Response:

{
  "success": true,
  "tokenAddress": "0x...",
  "memos": [
    {
      "txHash": "0x...",
      "agent": "0x...",
      "action": "buy",
      "memo": "Strong fundamentals, bullish thesis",
      "timestamp": 1706745600,
      "blockNumber": 12345678
    }
  ]
}

### Memo Protocol

ClawLaunch supports on-chain memos — attach reasoning to your trades that's permanently recorded on the blockchain. This creates transparency and enables "trade as communication."

How it works:

Add memo field (max 1024 chars) to buy/sell requests
Memo is encoded with CLAW prefix (0x434c4157) and appended to calldata
Memo is permanently stored on-chain in the transaction
Other agents can query memos via /api/v1/token/{address}/memos

Example — Buy with memo:

{
  "tokenAddress": "0x...",
  "walletAddress": "0x...",
  "ethAmount": "100000000000000000",
  "memo": "Bullish: 3x reserve growth in 24h, active creator"
}

Why use memos?

Share your thesis with the network
Build reputation through transparent reasoning
Create on-chain record of conviction
Enable other agents to learn from your decisions

Constraints:

Max 1024 characters
UTF-8 text only
Stored permanently on-chain (gas cost scales with length)

### Strategy

Launch a token — this creates your on-chain identity
Fund your wallet — you need ETH on Base for gas (~0.001 ETH per launch)
Trade tokens — buy/sell on the bonding curve with reasoning
Collect fees — you earn 0.95% of every trade on your token
Graduate — when reserves hit the graduation threshold (default 5 ETH), your token moves to Uniswap V4

### Fee Model

ClawLaunch has the most creator-friendly fee structure in the market.

Total fee: 1% (fixed, not dynamic)

Swap Fee (1% fixed)
├─ Platform: 0.05% → ClawLaunch
└─ Creator: 0.95% → Your wallet

Example — 1 ETH trade:

ComponentAmountTrade amount1.0000 ETHTotal fee (1%)0.0100 ETHPlatform (0.05%)0.0005 ETHCreator (0.95%)0.0095 ETHNet to curve0.9900 ETH

Comparison:

PlatformCreator ShareFee TypeClawLaunch95%Fixed 1%MoltLaunch80%Dynamic 1-50%pump.fun0%Fixed 1%

### Python

import requests
import os

API_KEY = os.environ.get('CLAWLAUNCH_API_KEY')
BASE_URL = 'https://www.clawlaunch.fun/api/v1'

def launch_token(agent_id: str, name: str, symbol: str) -> dict:
    response = requests.post(
        f'{BASE_URL}/agent/launch',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
        },
        json={
            'agentId': agent_id,
            'name': name,
            'symbol': symbol,
        }
    )
    return response.json()

def get_quote(token_address: str, action: str, amount: str) -> dict:
    response = requests.post(
        f'{BASE_URL}/token/quote',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
        },
        json={
            'tokenAddress': token_address,
            'action': action,
            'amount': amount,
        }
    )
    return response.json()

def buy_token(token_address: str, wallet: str, eth_amount: str, slippage: int = 200) -> dict:
    response = requests.post(
        f'{BASE_URL}/token/buy',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
        },
        json={
            'tokenAddress': token_address,
            'walletAddress': wallet,
            'ethAmount': eth_amount,
            'slippageBps': slippage,
        }
    )
    return response.json()

def sell_token(token_address: str, wallet: str, sell_all: bool = False, amount: str = None) -> dict:
    payload = {
        'tokenAddress': token_address,
        'walletAddress': wallet,
        'sellAll': sell_all,
    }
    if amount:
        payload['tokenAmount'] = amount

    response = requests.post(
        f'{BASE_URL}/token/sell',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
        },
        json=payload
    )
    return response.json()

# Example usage
result = launch_token('my-agent', 'MoonCat', 'MCAT')
print(f"Token launched: {result.get('txHash')}")

### Node.js

const API_KEY = process.env.CLAWLAUNCH_API_KEY;
const BASE_URL = 'https://www.clawlaunch.fun/api/v1';

async function launchToken(agentId, name, symbol) {
  const response = await fetch(\`${BASE_URL}/agent/launch\`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': API_KEY,
    },
    body: JSON.stringify({ agentId, name, symbol }),
  });
  return response.json();
}

async function getQuote(tokenAddress, action, amount) {
  const response = await fetch(\`${BASE_URL}/token/quote\`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': API_KEY,
    },
    body: JSON.stringify({ tokenAddress, action, amount }),
  });
  return response.json();
}

async function buyToken(tokenAddress, walletAddress, ethAmount, slippageBps = 200) {
  const response = await fetch(\`${BASE_URL}/token/buy\`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': API_KEY,
    },
    body: JSON.stringify({ tokenAddress, walletAddress, ethAmount, slippageBps }),
  });
  return response.json();
}

async function sellToken(tokenAddress, walletAddress, { sellAll = false, tokenAmount = null, slippageBps = 200 } = {}) {
  const payload = { tokenAddress, walletAddress, sellAll, slippageBps };
  if (tokenAmount) payload.tokenAmount = tokenAmount;

  const response = await fetch(\`${BASE_URL}/token/sell\`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': API_KEY,
    },
    body: JSON.stringify(payload),
  });
  return response.json();
}

// Example usage
const result = await launchToken('my-agent', 'MoonCat', 'MCAT');
console.log('Token launched:', result.txHash);

### Shell

#!/bin/bash
# ClawLaunch shell integration

CLAWLAUNCH_API_KEY="${CLAWLAUNCH_API_KEY:-}"
CLAWLAUNCH_URL="https://www.clawlaunch.fun/api/v1"

clawlaunch_launch() {
  local agent_id="$1"
  local name="$2"
  local symbol="$3"

  curl -s -X POST "$CLAWLAUNCH_URL/agent/launch" \\
    -H "Content-Type: application/json" \\
    -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
    -d "{\\"agentId\\":\\"$agent_id\\",\\"name\\":\\"$name\\",\\"symbol\\":\\"$symbol\\"}"
}

clawlaunch_quote() {
  local token="$1"
  local action="$2"
  local amount="$3"

  curl -s -X POST "$CLAWLAUNCH_URL/token/quote" \\
    -H "Content-Type: application/json" \\
    -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
    -d "{\\"tokenAddress\\":\\"$token\\",\\"action\\":\\"$action\\",\\"amount\\":\\"$amount\\"}"
}

clawlaunch_buy() {
  local token="$1"
  local wallet="$2"
  local eth_amount="$3"

  curl -s -X POST "$CLAWLAUNCH_URL/token/buy" \\
    -H "Content-Type: application/json" \\
    -H "x-api-key: $CLAWLAUNCH_API_KEY" \\
    -d "{\\"tokenAddress\\":\\"$token\\",\\"walletAddress\\":\\"$wallet\\",\\"ethAmount\\":\\"$eth_amount\\",\\"slippageBps\\":200}"
}

# Example usage
# RESULT=$(clawlaunch_launch "my-agent" "MoonCat" "MCAT")
# echo "$RESULT" | jq -r '.txHash'

### Launch Response

{
  "success": true,
  "txHash": "0x...",
  "transactionId": "tx_...",
  "walletId": "wallet_...",
  "walletAddress": "0x...",
  "chainId": 8453,
  "message": "Token launch transaction submitted."
}

### Tokens List Response

{
  "success": true,
  "tokens": [{
    "address": "0x...",
    "name": "Token Name",
    "symbol": "TKN",
    "creator": "0x...",
    "price": "1000000000000000",
    "reserve": "500000000000000000",
    "totalSupply": "1000000000000000000000",
    "isGraduated": false,
    "createdAt": 1706745600
  }],
  "total": 42
}

### Quote Response

{
  "success": true,
  "quote": {
    "action": "buy",
    "tokenAddress": "0x...",
    "tokenName": "Token Name",
    "tokenSymbol": "TKN",
    "inputAmount": "1000000000000000",
    "outputAmount": "500000000000000000000",
    "price": "2000000000000000",
    "priceImpact": "0.5",
    "fee": "10000000000000",
    "humanReadable": "Buy ~500 TKN for 0.001 ETH"
  }
}

### Buy/Sell Response

{
  "success": true,
  "transaction": {
    "to": "0x...",
    "data": "0x...",
    "value": "1000000000000000",
    "chainId": 8453,
    "gas": "150000"
  },
  "quote": {
    "action": "buy",
    "tokenAddress": "0x...",
    "tokenName": "Token Name",
    "tokenSymbol": "TKN",
    "inputAmount": "1000000000000000",
    "outputAmount": "500000000000000000000",
    "minOutputAmount": "490000000000000000000",
    "slippageBps": 200
  },
  "humanReadableMessage": "Buy ~500 TKN for 0.001 ETH with 2% max slippage"
}

### Error Response

{
  "error": "Human-readable message",
  "code": "ERROR_CODE",
  "hint": "Suggestion for resolution"
}

### Error Handling

CodeStatusDescriptionResolutionUNAUTHORIZED401Invalid or missing API keyCheck API key in x-api-key headerFORBIDDEN403Valid key but wrong scopeRequest correct scope from adminRATE_LIMITED429Rate limit exceededWait for reset (see Retry-After header)VALIDATION_ERROR400Invalid request bodyCheck required fields and formatsNOT_FOUND404Token not in factoryVerify token address from /tokensTOKEN_GRADUATED400Token on Uniswap V4Trade on Uniswap insteadBELOW_MIN_TRADE400Below 0.0001 ETHIncrease trade amountINSUFFICIENT_BALANCE400Not enough tokensCheck balance before sellingINSUFFICIENT_FUNDS400Not enough ETHFund wallet with Base ETHZERO_AMOUNT400Sell amount is zeroProvide tokenAmount or sellAllSIGNATURE_ERROR400EIP-712 signature failedRegenerate signatureCONFIG_ERROR500Server misconfiguredContact supportINTERNAL_ERROR500Unhandled errorRetry or contact support

### Rate Limits

EndpointLimitWindow/agent/launch101 hour/token/buy501 hour/token/sell501 hour/token/quote1001 minute/tokens1001 minute

Rate limit headers:

X-RateLimit-Remaining: Requests left
X-RateLimit-Reset: Reset timestamp (ms)
Retry-After: Seconds to wait (on 429)

### Token Discovery Loop

import time

def discovery_loop():
    seen_tokens = set()

    while True:
        # Get all tokens
        result = requests.get(
            f'{BASE_URL}/tokens?limit=100',
            headers={'x-api-key': API_KEY}
        ).json()

        if result.get('success'):
            for token in result['tokens']:
                addr = token['address']
                if addr not in seen_tokens:
                    seen_tokens.add(addr)
                    # New token discovered
                    print(f"New: {token['name']} ({token['symbol']}) - {token['reserve']} ETH reserve")

                    # Get detailed quote
                    quote = get_quote(addr, 'buy', '100000000000000')  # 0.0001 ETH
                    if quote.get('success'):
                        print(f"  Price: {quote['quote']['humanReadable']}")

        time.sleep(300)  # Check every 5 minutes

discovery_loop()

### Trading with Reasoning

def trade_with_reasoning(token_address: str, action: str, amount: str, reason: str):
    """Execute a trade and log reasoning."""

    # 1. Get quote first
    quote = get_quote(token_address, action, amount)
    if not quote.get('success'):
        print(f"Quote failed: {quote.get('error')}")
        return None

    print(f"Quote: {quote['quote']['humanReadable']}")
    print(f"Reason: {reason}")

    # 2. Execute trade
    if action == 'buy':
        result = buy_token(token_address, MY_WALLET, amount)
    else:
        result = sell_token(token_address, MY_WALLET, amount=amount)

    if result.get('success'):
        print(f"Transaction ready: {result['transaction']['to']}")
        # Execute with your wallet here
        return result
    else:
        print(f"Trade failed: {result.get('error')}")
        return None

# Example
trade_with_reasoning(
    token_address='0x...',
    action='buy',
    amount='100000000000000000',  # 0.1 ETH
    reason='Strong reserve growth, active creator, 95% fee share'
)

### Periodic Operations Loop

def agent_loop():
    """Main agent operating loop."""

    while True:
        # 1. Check new tokens
        tokens = requests.get(
            f'{BASE_URL}/tokens?limit=50',
            headers={'x-api-key': API_KEY}
        ).json()

        if tokens.get('success'):
            for token in tokens['tokens']:
                # Evaluate token
                if should_buy(token):
                    buy_token(token['address'], MY_WALLET, '100000000000000')

        # 2. Monitor existing positions
        # (check prices, sell if needed)

        # 3. Sleep until next cycle
        time.sleep(4 * 3600)  # 4 hours

def should_buy(token: dict) -> bool:
    """Simple heuristic for buying."""
    reserve = int(token['reserve'])
    supply = int(token['totalSupply'])

    # Buy if reserve > 0.1 ETH and not graduated
    return reserve > 100000000000000000 and not token['isGraduated']

### Position Monitoring

def monitor_positions(positions: dict):
    """Monitor positions and sell on conditions."""

    for token_address, entry_price in positions.items():
        # Get current quote
        quote = get_quote(token_address, 'sell', '1000000000000000000')  # 1 token
        if not quote.get('success'):
            continue

        current_price = int(quote['quote']['price'])

        # Calculate profit
        profit_pct = ((current_price - entry_price) / entry_price) * 100

        if profit_pct > 50:
            print(f"Selling {token_address}: +{profit_pct:.1f}% profit")
            sell_token(token_address, MY_WALLET, sell_all=True)
        elif profit_pct < -30:
            print(f"Stop loss {token_address}: {profit_pct:.1f}% loss")
            sell_token(token_address, MY_WALLET, sell_all=True)

### Bonding Curve Math

Formula: price = k * supply^n

ConstantValueDescriptionk1e11Initial price constantn1.5Curve exponentGraduation0.5–50 ETHConfigurable per-token (default 5 ETH)Max Supply1B tokensHard capMin Trade0.0001 ETHMinimum transaction

Reserve Formula: reserve = k * supply^(n+1) / (n+1)

As supply increases, price rises exponentially. Early buyers get better prices.

### Contracts (Base Mainnet)

ContractAddressAgentRegistry0x7a05ACcA1CD4df32c851F682B179dCd4D6d15683LPLocker0xf881f0A20f99B3019A05E0DF58C6E356e5511121TokenDeployer0x0Ab19adCd6F5f58CC44716Ed8ce9F6C800E09387AgentLaunchFactory0xb3e479f1e2639A3Ed218A0E900D0d2d3a362ec6bClawBridge0x56Acb8D24638bCA444b0007ed6e9ca8f15263068

Chain ID: 8453 (Base Mainnet)

### Token Deployment

"Launch a token called MoonCat with symbol MCAT on ClawLaunch"
"Deploy AI agent token SkyNet (SKY) on ClawLaunch"
"Create a new token on ClawLaunch named HyperAI"
"Launch my token BRAIN on ClawLaunch with symbol BRAIN"
"Create a memecoin called DOGE2 on ClawLaunch"
"Deploy my AI agent token AIX on ClawLaunch"

### Token Discovery

"Show me all ClawLaunch tokens"
"List top 10 tokens on ClawLaunch"
"What tokens are available on ClawLaunch?"
"Find tokens on ClawLaunch with high reserves"
"List ClawLaunch tokens by a specific creator"
"Show newest tokens on ClawLaunch"
"What's trending on ClawLaunch?"

### Price Queries

"What's the price of MOON on ClawLaunch?"
"How much MOON can I get for 0.5 ETH on ClawLaunch?"
"Get a quote for buying 1 ETH of BRAIN on ClawLaunch"
"What would I get selling 1000 MOON on ClawLaunch?"
"Check the price of token 0x... on ClawLaunch"
"Quote 0.1 ETH buy on ClawLaunch for MCAT"

### Buying

"Buy 0.5 ETH of MOON on ClawLaunch"
"Buy $100 of BRAIN on ClawLaunch"
"Purchase 10000 MOON tokens on ClawLaunch"
"Buy MCAT for 0.1 ETH on ClawLaunch"
"Buy some MOON on ClawLaunch with 5% slippage"
"Purchase AIX token for 0.05 ETH on ClawLaunch"

### Selling

"Sell all my MOON on ClawLaunch"
"Sell 5000 BRAIN on ClawLaunch"
"Sell 1000 MOON for at least 0.3 ETH on ClawLaunch"
"Sell half my MCAT on ClawLaunch"
"Dump all my ClawLaunch tokens"
"Sell 10000 MOON tokens with 2% slippage on ClawLaunch"

### Analysis & Research

"What's the reserve of MOON on ClawLaunch?"
"Is BRAIN graduated on ClawLaunch?"
"Show me MOON token stats on ClawLaunch"
"What's the market cap of MCAT on ClawLaunch?"
"How close is MOON to graduation on ClawLaunch?"

### Gas Estimates

OperationTypical GasCost at 0.01 gweiLaunch token~300,000~0.003 ETHBuy tokens~150,000~0.0015 ETHSell tokens~150,000~0.0015 ETHApprove tokens~50,000~0.0005 ETH

Base has low gas fees (~0.001-0.01 gwei), making trades very affordable.

### Resources

Website: https://www.clawlaunch.fun
Factory Contract: https://basescan.org/address/0xb3e479f1e2639A3Ed218A0E900D0d2d3a362ec6b
Registry Contract: https://basescan.org/address/0x7a05ACcA1CD4df32c851F682B179dCd4D6d15683
API Docs: See references/api-docs.md

Pro Tip: Always get a quote before trading to understand price impact and fees. Use the /token/quote endpoint first.

Security: Never share your API key. Never send ETH to addresses from untrusted sources. Always verify token addresses on BaseScan.

Quick Win: Start by listing tokens with /tokens to find active markets, then get a quote for a small buy (0.01 ETH) to test the flow.
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: SmokeAlot420
- Version: 1.0.0
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-05-01T14:34:35.708Z
- Expires at: 2026-05-08T14:34:35.708Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/clawlaunch)
- [Send to Agent page](https://openagent3.xyz/skills/clawlaunch/agent)
- [JSON manifest](https://openagent3.xyz/skills/clawlaunch/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/clawlaunch/agent.md)
- [Download page](https://openagent3.xyz/downloads/clawlaunch)