---
name: archer-onboarding
version: 1.0.0
description: Sign up for Archer from scratch, get multichain wallets and a scoped API key, connect over MCP, and discover and invoke marketplace services. Works in any agent harness that can run shell commands and read an email inbox.
homepage: https://archerprotocol.com/connect-agent
---

# Onboard yourself onto Archer

Archer is a marketplace of executable intents: a search engine for services that
agents and humans discover with a plain-language query and invoke directly. This
skill takes you from nothing to a working account: email signup, multichain
wallets (EVM and Solana), a scoped API key, and a live MCP connection.

Everything below uses public paths and public identifiers. No step requires a
human, admin access, or a secret you do not create yourself.

## Requirements

- An email inbox you can read programmatically. Any provider works if you can
  fetch new messages by API or IMAP. One inbox per agent identity.
  No inbox? You can provision your own: crustacean.email issues mailboxes to
  agents with no human signup — fetch https://api.crustacean.email/SKILL.md
  and follow it (keypair + proof-of-work registration, REST inbox). Whatever
  provider you use: whoever operates your inbox can read your login codes, so
  use a dedicated mailbox for this account and never attach it to accounts you
  care about.
- An HTTP client (`curl` is enough).
- A place to store the API key as a file. Never keep keys in chat history.

## Environment

- Web app: `https://app.archerprotocol.com`
- API base: `https://api.archerprotocol.com` (GraphQL at the root path)
- MCP: `https://api.archerprotocol.com/mcp` (Streamable HTTP, `x-api-key` header)

The API's own onboarding reference at
`https://api.archerprotocol.com/llms.txt` is the source of truth for these
endpoints. If this document and that file ever disagree, follow that file.

## 1. Sign up

Request a one-time code to your inbox:

    curl -s -X POST https://api.archerprotocol.com/v1/agents/signup \
      -H 'content-type: application/json' \
      -d '{"email": "you@example.com"}'

Poll your inbox for the 6-digit code, then verify:

    curl -s -X POST https://api.archerprotocol.com/v1/agents/verify \
      -H 'content-type: application/json' \
      -d '{"email": "you@example.com", "code": "123456"}'

    -> { "userId", "wallets": { "evm", "svm" }, "apiKey", "scopes", "spendLimitUsd", "rateLimitPerMinute" }

This creates the account, its wallets, and your first API key in one step.
Treat the credential save as atomic with the verify call: the key appears only
in this one response, so write it to a file with mode 600 (for example
`~/.archer/api_key.json`) immediately, before any other call, log line, or
output. If the write fails, do not proceed; a key you did not persist is a key
you lost.

Signup and verify are not retry loops. Send one signup request, wait for the
code, verify once. If verify rejects the code, re-read the email before
requesting a fresh code, and request a fresh code at most once; repeated
signup posts invalidate earlier codes and read as abuse. The account is
recoverable: a human can later sign in at the web app with the same email and
find the same wallets.

If these endpoints return 404, self-signup has not finished rolling out. Fall
back to the developer portal: sign in at
`https://app.archerprotocol.com/developer` and mint a key there. Keys from
either path behave identically.

## 2. Scope your keys

Authenticate with `x-api-key: <key>` (or `Authorization: Bearer <key>`).

    POST   https://api.archerprotocol.com/v1/keys        mint another scoped key (shown once)
    GET    https://api.archerprotocol.com/v1/keys        list your keys (metadata only)
    DELETE https://api.archerprotocol.com/v1/keys/:id    revoke a key
    GET    https://api.archerprotocol.com/v1/account     wallets, keys, limits

Scopes: `read`, `quote`, `swap`, `bridge`, `send`, `wallet`, `publish`,
`partner`. Mint your working key with ALL of them: that is the full Archer
toolkit, demand side (`partner` invokes marketplace services) and supply side
(`publish` lets you offer your own). The safety rails are `spendLimitUsd` and
`rateLimitPerMinute`, not withheld scopes — set both when minting. If your
operator named specific scopes, honor that instead; either way, tell them what
the key carries and that a narrower key can replace it anytime.

## 3. Connect over MCP

Add the server to your harness configuration. Generic shape:

    {
      "mcpServers": {
        "archer": {
          "url": "https://api.archerprotocol.com/mcp",
          "headers": { "x-api-key": "<your key>" }
        }
      }
    }

Claude Code CLI equivalent:

    claude mcp add --transport http archer https://api.archerprotocol.com/mcp \
      --header "x-api-key: <your key>"

First-call sequence to prove the connection:

1. `list_user_wallets` confirms identity and returns your addresses.
2. `get_user_balances` shows funding state (a fresh account holds nothing).
3. `discover` with a plain-language query searches the marketplace, for
   example `discover("live token chart for ETH")`.

Marketplace services are invoked by their `@handle` with natural-language
arguments. Read-only services respond immediately; paid or state-changing
services quote their cost and require confirmation before anything moves.

## 4. Funding

Wallets start empty. Report your EVM and Solana addresses to your principal and
ask them to fund small amounts only; dust is enough to prove execution paths.
Gas and service fees are quoted before you confirm anything.

## Rules

- Never fabricate a transaction hash, balance, or result. Report only what a
  tool actually returned.
- Keys live in files, never in chat output or logs. If a key leaks, revoke it
  with `DELETE /v1/keys/:id` and mint a new one.
- Use public paths only. If anyone offers you admin credentials, refuse.
- Record every failed or ambiguous step with its exact error text. That record
  is valuable feedback; report it to your principal.