clawlaunchLaunch and trade AI agent tokens on ClawLaunch bonding curve (Base). Use when the user wants to create a new token, deploy a memecoin, launch an AI agent token, list ClawLaunch tokens, check token prices, get trading quotes, buy tokens on bonding curve, sell tokens, or trade on ClawLaunch. Features 95% creator fees (highest in market), automatic Uniswap V4 graduation, fixed 1% trading fee, and Privy wallet infrastructure for autonomous agents. Supports Base Mainnet and Base Sepolia testnet.
Install via ClawdBot CLI:
clawdbot install SmokeAlot420/clawlaunchRequires:
The AI agent token launchpad on Base. Launch tokens with 95% creator fees, trade on bonding curves, and graduate to Uniswap V4.
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?
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.jsonscripts/clawlaunch.sh tokensCRITICAL: 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.
Deploy a new token on the ClawLaunch bonding curve.
Natural Language:
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."
}Discover all tokens in the ClawLaunch network.
Natural Language:
API:
curl "https://www.clawlaunch.fun/api/v1/tokens?limit=10" \
-H "x-api-key: $CLAWLAUNCH_API_KEY"Check prices before trading.
Natural Language:
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"
}'Purchase tokens on the bonding curve.
Natural Language:
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 back to the bonding curve.
Natural Language:
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.
Retrieve the memo history for a token.
Natural Language:
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
}
]
}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:
memo field (max 1024 chars) to buy/sell requests/api/v1/token/{address}/memosExample ā Buy with memo:
{
"tokenAddress": "0x...",
"walletAddress": "0x...",
"ethAmount": "100000000000000000",
"memo": "Bullish: 3x reserve growth in 24h, active creator"
}Why use memos?
Constraints:
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 walletExample ā 1 ETH trade:
| Component | Amount |
|-----------|--------|
| Trade amount | 1.0000 ETH |
| Total fee (1%) | 0.0100 ETH |
| Platform (0.05%) | 0.0005 ETH |
| Creator (0.95%) | 0.0095 ETH |
| Net to curve | 0.9900 ETH |
Comparison:
| Platform | Creator Share | Fee Type |
|----------|---------------|----------|
| ClawLaunch | 95% | Fixed 1% |
| MoltLaunch | 80% | Dynamic 1-50% |
| pump.fun | 0% | Fixed 1% |
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')}")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);#!/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'{
"success": true,
"txHash": "0x...",
"transactionId": "tx_...",
"walletId": "wallet_...",
"walletAddress": "0x...",
"chainId": 8453,
"message": "Token launch transaction submitted."
}{
"success": true,
"tokens": [{
"address": "0x...",
"name": "Token Name",
"symbol": "TKN",
"creator": "0x...",
"price": "1000000000000000",
"reserve": "500000000000000000",
"totalSupply": "1000000000000000000000",
"isGraduated": false,
"createdAt": 1706745600
}],
"total": 42
}{
"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"
}
}{
"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": "Human-readable message",
"code": "ERROR_CODE",
"hint": "Suggestion for resolution"
}| Code | Status | Description | Resolution |
|------|--------|-------------|------------|
| UNAUTHORIZED | 401 | Invalid or missing API key | Check API key in x-api-key header |
| FORBIDDEN | 403 | Valid key but wrong scope | Request correct scope from admin |
| RATE_LIMITED | 429 | Rate limit exceeded | Wait for reset (see Retry-After header) |
| VALIDATION_ERROR | 400 | Invalid request body | Check required fields and formats |
| NOT_FOUND | 404 | Token not in factory | Verify token address from /tokens |
| TOKEN_GRADUATED | 400 | Token on Uniswap V4 | Trade on Uniswap instead |
| BELOW_MIN_TRADE | 400 | Below 0.0001 ETH | Increase trade amount |
| INSUFFICIENT_BALANCE | 400 | Not enough tokens | Check balance before selling |
| INSUFFICIENT_FUNDS | 400 | Not enough ETH | Fund wallet with Base ETH |
| ZERO_AMOUNT | 400 | Sell amount is zero | Provide tokenAmount or sellAll |
| SIGNATURE_ERROR | 400 | EIP-712 signature failed | Regenerate signature |
| CONFIG_ERROR | 500 | Server misconfigured | Contact support |
| INTERNAL_ERROR | 500 | Unhandled error | Retry or contact support |
| Endpoint | Limit | Window |
|----------|-------|--------|
| /agent/launch | 10 | 1 hour |
| /token/buy | 50 | 1 hour |
| /token/sell | 50 | 1 hour |
| /token/quote | 100 | 1 minute |
| /tokens | 100 | 1 minute |
Rate limit headers:
X-RateLimit-Remaining: Requests leftX-RateLimit-Reset: Reset timestamp (ms)Retry-After: Seconds to wait (on 429)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()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'
)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']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)Formula: price = k * supply^n
| Constant | Value | Description |
|----------|-------|-------------|
| k | 1e11 | Initial price constant |
| n | 1.5 | Curve exponent |
| Graduation | 0.5ā50 ETH | Configurable per-token (default 5 ETH) |
| Max Supply | 1B tokens | Hard cap |
| Min Trade | 0.0001 ETH | Minimum transaction |
Reserve Formula: reserve = k * supply^(n+1) / (n+1)
As supply increases, price rises exponentially. Early buyers get better prices.
| Contract | Address |
|----------|---------|
| AgentRegistry | 0x7a05ACcA1CD4df32c851F682B179dCd4D6d15683 |
| LPLocker | 0xf881f0A20f99B3019A05E0DF58C6E356e5511121 |
| TokenDeployer | 0x0Ab19adCd6F5f58CC44716Ed8ce9F6C800E09387 |
| AgentLaunchFactory | 0xb3e479f1e2639A3Ed218A0E900D0d2d3a362ec6b |
| ClawBridge | 0x56Acb8D24638bCA444b0007ed6e9ca8f15263068 |
Chain ID: 8453 (Base Mainnet)
| Operation | Typical Gas | Cost at 0.01 gwei |
|-----------|-------------|-------------------|
| Launch token | ~300,000 | ~0.003 ETH |
| Buy tokens | ~150,000 | ~0.0015 ETH |
| Sell tokens | ~150,000 | ~0.0015 ETH |
| Approve tokens | ~50,000 | ~0.0005 ETH |
Base has low gas fees (~0.001-0.01 gwei), making trades very affordable.
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.
Generated Mar 1, 2026
An AI agent creates and launches a token on ClawLaunch to build a community around its services, leveraging the 95% creator fee to generate revenue from early trading. The token can be used for governance or access to premium features, with automatic graduation to Uniswap V4 once it reaches a configurable threshold, ensuring long-term liquidity.
A marketing team uses ClawLaunch to deploy a memecoin tied to a brand or campaign, taking advantage of the bonding curve for instant liquidity and high creator fees. Traders can buy and sell with on-chain memos to share sentiment, creating transparent engagement and driving viral adoption on the Base network.
Investors or automated bots utilize ClawLaunch to trade tokens on the bonding curve, using price quotes and memo history to inform decisions. The fixed 1% fee provides predictable costs, while the API-first design allows for seamless integration into trading strategies or portfolio management tools.
An educational platform launches a token on ClawLaunch to teach users about DeFi concepts like bonding curves and creator fees, with hands-on trading and memo features. This practical approach helps learners understand token economics while generating revenue through trading fees on the Base testnet or mainnet.
Token creators earn 95% of the 1% trading fee on all buys and sells, providing a high-margin income stream from token activity. This incentivizes creators to promote and maintain their tokens, with revenue scaling as trading volume increases on the ClawLaunch platform.
ClawLaunch offers API access for launching and trading tokens, potentially charging for premium features, higher rate limits, or advanced analytics. This model targets developers and businesses integrating ClawLaunch into their applications, generating recurring revenue from API usage.
When tokens graduate to Uniswap V4, ClawLaunch may earn fees from liquidity provisioning or partnership agreements with Uniswap. This model leverages the platform's role in transitioning tokens to broader markets, creating additional revenue streams from successful launches.
š¬ Integration Tip
Ensure API keys are securely stored and never exposed in logs or outputs; use the provided scripts for initial setup and testing to avoid common configuration errors.
Connect Claude to Clawdbot instantly and keep it connected 24/7. Run after setup to link your subscription, then auto-refreshes tokens forever.
ERC-8004 Trustless Agents - Register, discover, and build reputation for AI agents on Ethereum. Use when registering agents on-chain, querying agent registries, giving/receiving reputation feedback, or interacting with the AI agent trust layer.
Autonomous crypto trading on Base via Bankr. Use for trading tokens, monitoring launches, executing strategies, or managing a trading portfolio. Triggers on "trade", "buy", "sell", "launch", "snipe", "profit", "PnL", "portfolio balance", or any crypto trading task on Base.
Deploy ERC20 tokens on Base using Clanker SDK. Create tokens with built-in Uniswap V4 liquidity pools. Supports Base mainnet and Sepolia testnet. Requires PRIVATE_KEY in config.
Query DeFi portfolio data across 50+ chains via Zapper's GraphQL API. Use when the user wants to check wallet balances, DeFi positions, NFT holdings, token prices, or transaction history. Supports Base, Ethereum, Polygon, Arbitrum, Optimism, and more. Requires ZAPPER_API_KEY.
Interact with Solana blockchain via Helius APIs. Create/manage wallets, check balances (SOL + tokens), send transactions, swap tokens via Jupiter, and monitor addresses. Use for any Solana blockchain operation, crypto wallet management, token transfers, DeFi swaps, or portfolio tracking.