Your own corridor, built and handed over

Not an app: the machine that makes them. Your own BotTrunk in your own country under your own brand — the x402 gateway deployed and settling real money, the catalog, the ledger, the admin queue, MCP distribution, your wallet, your facilitator relationship. Then the part that cannot be downloaded: hiring and training the people who fulfil, the queue discipline, the refund rules, the capacity limits that stop a promise being made twice. Phased and milestone-billed, starting with four weeks of discovery that tells you honestly whether to continue. Exclusive for your territory for the term.

POST https://api.bottrunk.com/s/corridor-build

On request A person does this work. Write to us first so we can agree scope and timing; the endpoint answers 503 until then, so nothing can be charged by accident.

Add to my agent

Overview Call it Behaviour Input Output

Call it

# once, on the machine your agent runs on
npx bottrunk-mcp wallet   # prints the address; send it 0.3 ALGO, then USDC
claude mcp add bottrunk -- npx -y bottrunk-mcp

# then ask your agent for it — the tool is `bottrunk_corridor_build`

# Ask. You get a 402 with the payment requirements.
curl https://api.bottrunk.com/s/corridor-build \
  -H "Content-Type: application/json" \
  -d '{"territory":"…"}'

# Pay and retry. Any x402 client does this for you.
curl https://api.bottrunk.com/s/corridor-build \
  -H "PAYMENT-SIGNATURE: <signed USDC transfer>" \
  -H "Content-Type: application/json" \
  -d '{"territory":"…"}'

# pip install "x402-avm[avm,requests]==2.0.2"
import base64, os
from algosdk import encoding, mnemonic
from x402 import x402ClientSync
from x402.http import x402HTTPClientSync
from x402.http.clients.requests import x402_requests
from x402.mechanisms.avm import ALGORAND_MAINNET_CAIP2
from x402.mechanisms.avm.exact import ExactAvmScheme

class MnemonicSigner:  # signs the payment with your agent's 25-word mnemonic
    def __init__(self, words):
        self._sk = mnemonic.to_private_key(words)
        self.address = encoding.encode_address(base64.b64decode(self._sk)[32:])

    def sign_transactions(self, unsigned_txns, indexes_to_sign):
        return [base64.b64decode(encoding.msgpack_encode(
                    encoding.msgpack_decode(base64.b64encode(t).decode()).sign(self._sk)))
                if i in indexes_to_sign else None
                for i, t in enumerate(unsigned_txns)]

# A wallet holding 0.3 ALGO, opted in to USDC, funded with the USDC it may spend.
signer = MnemonicSigner(os.environ["ALGORAND_MNEMONIC"])
client = x402ClientSync().register(ALGORAND_MAINNET_CAIP2,
    ExactAvmScheme(signer, algod_url="https://mainnet-api.algonode.cloud"))

with x402_requests(client) as session:   # answers the 402, pays, retries
    r = session.post("https://api.bottrunk.com/s/corridor-build", json={"territory": "…"})
    print(r.json())
    receipt = x402HTTPClientSync(client).get_payment_settle_response(r.headers.get)
    print(receipt.transaction)            # the settlement on-chain

// npm install @x402-avm/fetch @x402-avm/avm @x402-avm/core algosdk
import algosdk from "algosdk";
import { x402Client } from "@x402-avm/core/client";
import { ExactAvmScheme } from "@x402-avm/avm/exact/client";
import { toClientAvmSigner } from "@x402-avm/avm";
import { wrapFetchWithPayment } from "@x402-avm/fetch";

// A wallet holding 0.3 ALGO, opted in to USDC, funded with the USDC it may spend.
const { sk } = algosdk.mnemonicToSecretKey(process.env.ALGORAND_MNEMONIC!);
const signer = toClientAvmSigner(Buffer.from(sk).toString("base64"));
const client = new x402Client().register("algorand:wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
  new ExactAvmScheme(signer, { algodUrl: "https://mainnet-api.algonode.cloud" })); // default is TestNet
const fetchWithPay = wrapFetchWithPayment(fetch, client);

const r = await fetchWithPay("https://api.bottrunk.com/s/corridor-build", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({"territory":"…"}),
});
console.log(await r.json());

How it behaves

The decisions this service makes on your behalf, and the ones that end in a refusal. A 4xx is never settled, so a refusal costs you nothing.

Phase 0 — discovery, four weeks	The regulatory map for your territory: who licenses money movement there, what a corridor can legally carry, which partner you need. It is also the phase that tells you not to continue, if that is the answer. Paid on its own.
Phase 1 — the rail	The gateway deployed under your brand, settling real payments, with your team able to operate it. Not a fork thrown over a wall.
Phase 2 — the operation	Hiring, training, the SOPs, the admin queue, the refund discipline. Everything this codebase encodes about not charging for work you did not do.
Phase 3 — a year alongside you	Your first services built, your first corridor live, support while it becomes yours.
How it is paid	Per milestone, never in advance, each phase stoppable. And in USDC over x402 if you want it — your first experience of the product is paying for it with it.

Who does the work

A person, not a script. The payment settles on-chain first; the job then enters our queue and is done within the stated window. You get an order id immediately and can poll it until the proof comes back — a bank receipt reference, photos, or the finished text. If we cannot deliver, the USDC is returned to the paying wallet and the refund transaction is recorded on the order.

Input

territory	string	Where you want to operate.
contact_email	string	Where to reply.

Output

scope

object

The phased plan and milestones, once we have talked.