Canvas64

npx add-mcp 'https://canvas64.com/api/mcp'

Canvas64 is built for agents: every cell, price and payout is one call away, over a read-only MCP server or a public JSON API, with no key, no wallet and no account. An agent can answer "what does cell D4 cost?", price any step with quote, prepare the purchase with prepare_buy for the person's own wallet to sign, or hand them https://canvas64.com/D4 to buy it in the browser. Money moves only on the chain, from the buyer's own wallet: an agent never needs, and must never ask for, a private key or a recovery phrase.

The short version

Canvas64 is a public wall of 64 cells on Base. Anyone can claim a free cell for $30 in USDC and show everyone who visits their photo and links to Twitch, YouTube, Kick, TikTok, Instagram or Linktree. Nobody can take a cell, but anyone can buy it out at the next step, 1.65× the last price, and the owner cannot refuse. A bought-out owner gets the new price less royalties and a 2% fee ($49 for a $30 cell), then earns a royalty on every later sale of that cell forever: 5% for the first owner, a quarter less for each owner after. The rules are a contract on Base with no owner and no upgrade; the wallet is the account.

Facts and proof

Each fact below links to where it can be checked, outside this site where it can be.

• Contract: 0x99Ff41906550F0C0F3EC66a11525e38C548e5011 on Base (chain 8453), deployed at block 52,557,209. Every sale, payment and owner is public on the chain: its events on Basescan.
• Source: verified on Sourcify, the full source; also readable on Basescan.
• No owner, no upgrade key: The contract is not a proxy and has no owner role; its one privileged address is the team's, with the three powers below. The prices and rates are written into its code (priceAt(step)), and a cell changes hands only when someone buys it at the next step.
• What the team can do: From its one address 0x3e2B20366638Deaf34142aB09a07686E58f58B43: stop new sales for up to 7 days at a time (stop(), which lapses by itself; payments owed, withdrawals and profiles keep working), end a stop (resume()), and move the platform's own share to a new address (moveTeam(to)). Nothing else: it cannot change a price, a rate or an owner, take a cell, or touch anyone's money. The rules.
• Audit: not audited yet. An independent audit comes before the stable release; until then, the verified source is there to read. Before you buy.
• The wall right now: Which cells are taken, at what step and by whom: https://canvas64.com/api/wall, or cells() on the contract.

MCP server

A Model Context Protocol server, Streamable HTTP, stateless, read-only, no authentication:

https://canvas64.com/api/mcp

Tool	What it answers
get_wall	All 64 cells: owner name and wallet, step, price paid, price to buy now, links. Filter free or taken.
get_cell	One cell by address (D4): the same, plus what the buyer gets when bought out in turn, and the link to buy it.
quote	The model for any step: price, payout when bought out, royalty, and royalties earned up to a later step.
prepare_buy	The purchase of one cell, ready for the buyer's wallet: the price read from the contract now and the unsigned transactions to sign in order. With wallet, it checks the USDC balance and allowance first.
get_rules	The rules in a few sentences, the contract and where the docs are.

Add it to a client that speaks MCP over HTTP, for example:

{"mcpServers": {"canvas64": {"type": "http", "url": "https://canvas64.com/api/mcp"}}}

The server card is at https://canvas64.com/.well-known/mcp.json and an A2A agent card at https://canvas64.com/.well-known/agent-card.json.

Buy a cell with your agent

An agent finds the cell and its price over MCP, then either prepares the purchase for the person's own wallet or hands them the cell's page. Canvas64 never holds a key and never sends a transaction.

1. Find a cell. get_wall with filter: "free" lists the free cells, each $30; get_wall with filter: "taken" lists the rest with the price to buy each one out now.
2. Check it. get_cell with the address (D4) answers what it costs now, what the buyer gets when bought out in turn ($49 for a cell claimed for $30), the royalty that follows, and the link to buy it. quote prices any later step.
3. Prepare the purchase. prepare_buy with the cell and the buyer's wallet address returns the price read from the contract and transactions: a USDC approval of exactly that price (left out when the wallet already allows it), then buy(cell, step). Each has to, data and value; the wallet signs and sends them in order on Base (chain 8453). Show the person the cell, the price and what they get before they sign. If someone buys the cell first, the purchase fails with WrongStep and nothing is charged: prepare again.
4. Or hand over the link. Give the person https://canvas64.com/D4. The page opens on that cell with its price on the button; they connect their wallet and pay in USDC on Base.

A purchase prepared over MCP carries a short tag after its arguments, canvas64_mcp_ and the client's name in the ERC-8021 form; the contract ignores it, and the wall shows the cell was bought through MCP.

Prefer a free cell for a first purchase. Every price comes from the contract's rules, so what get_cell answers is what the page asks.

HTTP API

The same data over plain HTTP, described in OpenAPI at https://canvas64.com/openapi.json:

• GET https://canvas64.com/api/wall: every cell, A1 first, with its step, owner and profile.
• GET https://canvas64.com/api/cell/{address}: one cell as get_cell returns it: its owner, what it costs now, what its owner gets when it is bought out, its royalty and its link. Every cell page, such as https://canvas64.com/D4, links to it.
• GET https://canvas64.com/api/profile/{address}: one wallet's profile; add ?cell=N (0 to 63) for the profile that cell shows, which can be its own.
• GET https://canvas64.com/api/photo/{sha256}: a photo that passed screening.

Cell i (0 to 63) is the address "ABCDEFGH"[i % 8] + (floor(i / 8) + 1): 0 is A1, 27 is D4.

The contract

0x99Ff41906550F0C0F3EC66a11525e38C548e5011 on Base (chain 8453), paid in USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. Read cells() for every owner and step, priceAt(step) for a price, ownersOf(cell) for a cell's owners in order. A purchase is buy(cell, step) after a USDC approval, or buyWithPermit(...), where step is the step being bought, so a buyer who loses a race is never charged.

Facts to quote

• Price of step n: $30 × 1.65^(n−1). Step 2 is $50, step 10 is $2,719.
• Bought out after a $30 claim: $49.
• Royalty of owner k: 5% × 0.75^(k−1), forever; all together under 20%.
• Fee: 2% of each buyout; each claim's $30 to the platform.
• Cell i (0 to 63) is "ABCDEFGH"[i % 8] + (floor(i / 8) + 1); its page is https://canvas64.com/ + that address, such as https://canvas64.com/D4.
• To buy, prepare_buy returns the unsigned transactions for the buyer's own wallet, or send the person to the cell's page; either way their wallet pays in USDC on Base.
• Everything for agents in one file: https://canvas64.com/llms-full.txt.

This page as Markdown: agents.md. All of the docs in one file: llms-full.txt.