ed@edheltzel: ~/log/clankers-in-your-codebase
ed@edheltzel:~/log$ cat clankers-in-your-codebase.md

Clankers in your codebase

cryptobasefarcasterautomation
Terminal window showing a Clanker SDK token deployment

I spent a week plugging Clanker into a deploy pipeline. The idea was simple: launch a token on Base every time a Farcaster community hit a participation milestone, fully automated, no human clicking buttons on clanker.world. The reality took more plumbing than I expected.

What Clanker actually is

Clanker is a token launcher on Base. You tag @clanker in a Farcaster cast with a name, ticker, and optional image, and the bot deploys an ERC-20 with locked Uniswap V4 liquidity, creator fee splits, and optional vaults. It went from a single-person Farcaster bot in November 2024 to something Farcaster acquired in October 2025. Billions in cumulative volume on Base according to Messari tracking.

For quick launches, the Farcaster bot or the web UI at clanker.world/deploy works fine. For automation, you want the TypeScript SDK.

The SDK path

Install clanker-sdk and viem:

npm install clanker-sdk viem

The basic deploy script looks like this:

import { Clanker } from 'clanker-sdk';
import { createPublicClient, createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

const clanker = new Clanker({
  wallet: createWalletClient({ account, chain: base, transport: http() }),
  publicClient: createPublicClient({ chain: base, transport: http() }),
});

const address = await clanker.deployToken({
  name: 'Community Token',
  symbol: 'COMM',
  image: 'ipfs://YOUR_CID',
  pool: {
    quoteToken: '0x4200000000000000000000000000000000000006',
    initialMarketCap: '10',
  },
  vault: { percentage: 10, durationInDays: 30 },
  devBuy: { ethAmount: 0 },
  rewardsConfig: {
    creatorReward: 75,
    creatorAdmin: account.address,
    creatorRewardRecipient: account.address,
    interfaceAdmin: account.address,
    interfaceRewardRecipient: account.address,
  },
});

The deployToken call hits the Clanker factory on Base, creates the token, sets up the Uniswap V4 pool, locks LP forever, and returns the token address. Total supply is 100 billion by default and you can’t mint more after deploy.

Things that tripped me up

Vault limits are enforced on-chain. You can only vault up to 30% of supply, minimum 31 days. The SDK won’t warn you if you pass bad values; the transaction just reverts. I burned gas figuring that out.

IPFS images need to be pinned first. If you pass a URL that goes down, the token page on clanker.world shows a broken image forever. Pin to IPFS and use the ipfs:// URI.

The REST API requires a partner key. The clanker-sdk deploys through on-chain transactions from your wallet. The HTTP API at clanker.world/api has partner-only deploy endpoints with rate limits. If you need platform-scale automation (hundreds of deploys/day), talk to the Clanker team for API access. For one-off scripted launches, the SDK is better anyway because you control the wallet directly.

Reward splits are fixed after deploy. I set the wrong creatorRewardRecipient on my first test token and there was no way to change it. Verify addresses before you deploy. The creator earns from LP trading fees, and on bot deploys that split defaults to 80% creator / 20% protocol.

CLI for quick jobs

If you don’t need a full Node.js service, the SDK has a CLI:

npx clanker-sdk deploy \
  --name "Quick Token" --symbol "QTK" \
  --chain base --private-key "$PRIVATE_KEY" --json

Add --dry-run when testing. The output gives you the expected address and a cost estimate before you commit ETH.

What I’d do differently

Run on Base Sepolia first. I wasted real ETH on reverted transactions because I was too eager to see it work on mainnet. Use a dedicated hot wallet with minimal funds, not your main wallet. And keep IPFS metadata in a proper pinning service like Pinata or web3.storage, not a local IPFS node that might go offline.

The official docs are auto-generated from TypeDoc, so they read like API dumps. The npm README has the real examples. Pin your SDK version because the Clanker contracts moved from V3 to V4 (Uniswap V4 hooks) and the deploy params changed.

One more thing: Clanker also ships “Droids” now, AI agents with their own Farcaster accounts that get funded from LP reward carve-outs. I haven’t tried wiring those into automation yet, but the concept of a token that funds its own marketing agent is worth watching.

Most of these tokens go to zero. That’s the memecoin game. But the infrastructure is genuinely interesting, and having programmatic access to it opens up ideas I wouldn’t have considered when token launches required a full Solidity deployment.

cd ~/log | cd ~