# A2A Protocol
Source: https://docs.coinfello.com/agent/a2a

Connect your agent to CoinFello via Agent-to-Agent protocol

The Agent-to-Agent (A2A) protocol lets your agent communicate with CoinFello through a standardized JSON agent card. Use this if your agent already has its own wallet.

## Agent Card

```
https://app.coinfello.com/agent/chat/.well-known/agent-card.json
```

Fetch this URL to discover CoinFello's capabilities and communication interface.

## A2A Endpoint

```
POST https://app.coinfello.com/api/a2a
```

This endpoint implements JSON-RPC 2.0 per the [A2A protocol spec](https://a2a-protocol.org/latest/). Supported methods: `message/send`, `message/stream`, `tasks/get`, `tasks/cancel`.

Before calling this endpoint, complete the [SIWE authentication flow](/api-reference/authentication) to obtain a session cookie. Unauthenticated requests return a `401` error.

Each `message/send` or `message/stream` request must include an `agentId`. The endpoint is agent-agnostic — pass the numeric agent ID in `params.configuration.agentId` (or as a `DataPart`). The agent's ID is available in the agent card above.

See the [Bring Your Own Frontend](/agent/byof) guide for usage examples.


# Bring Your Own Frontend
Source: https://docs.coinfello.com/agent/byof

Integrate CoinFello directly into your own app

Build CoinFello into your own frontend by hitting the A2A endpoint directly. The API follows the [Agent-to-Agent protocol spec](https://a2a-protocol.org/latest/).

<Card title="Demo Project" icon="github" href="https://github.com/CoinFello/byof-demo">
  A working example app showing authentication, streaming, and client-side tool call handling.
</Card>

## Endpoint

```
POST https://app.coinfello.com/api/a2a
```

All requests use [JSON-RPC 2.0](https://www.jsonrpc.org/specification).

## Methods

| Method           | Description                                        |
| ---------------- | -------------------------------------------------- |
| `message/send`   | Send a message and get a response                  |
| `message/stream` | Send a message and stream the response via SSE     |
| `tasks/get`      | Get a task by ID (optionally limit history length) |
| `tasks/cancel`   | Cancel a running task                              |

## Agent ID

Every `message/send` and `message/stream` request must include an `agentId`. The endpoint is agent-agnostic — the agent is resolved at request time from the value you supply.

Pass it in `params.configuration`:

```json theme={null}
{
  "params": {
    "configuration": { "agentId": 1 },
    "message": { ... }
  }
}
```

Omitting `agentId` on a new request returns: `"agentId is required: provide in configuration.agentId or as a DataPart"`. Once a task exists, subsequent messages that include its `taskId` do not need to repeat it.

Find the numeric ID in the [agent card](https://app.coinfello.com/agent/chat/.well-known/agent-card.json) under skills where each entry is a separate chat agent.

## Example: Send a Message

```bash theme={null}
curl -b cookies.txt -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "configuration": { "agentId": 1 },
      "message": {
        "role": "user",
        "parts": [{ "type": "text", "text": "What are the best yields for ETH right now?" }]
      }
    }
  }'
```

## Streaming

Use `message/stream` to get Server-Sent Events back. Each event is a JSON-RPC response wrapping an A2A stream event:

```bash theme={null}
curl -b cookies.txt -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/stream",
    "params": {
      "configuration": { "agentId": 1 },
      "message": {
        "role": "user",
        "parts": [{ "type": "text", "text": "Swap 0.1 ETH to USDC" }]
      }
    }
  }'
```

## Authentication

Authentication uses SIWE (Sign-In with Ethereum). Complete the SIWE flow to obtain a session cookie before making requests. See [Authentication](/api-reference/authentication) for the full flow with curl examples.

## Client-side tool calls

The CoinFello chat agent which you can get from [its agent card](https://app.coinfello.com/agent/chat/.well-known/agent-card.json) returns tool call requests as part of its A2A responses. Your frontend is responsible for handling these calls — rendering UI, prompting the user for approval, executing wallet transactions, and returning results back to the agent.

Tool calls appear in the agent's response as `functionCall` parts:

```json theme={null}
{
  "role": "agent",
  "parts": [
    {
      "type": "functionCall",
      "name": "execute_lifi_swap",
      "id": "call_abc123",
      "parameters": {
        "fromChainId": 1,
        "toChainId": 1,
        "fromTokenAddress": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
        "toTokenAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "fromAmount": "100000000000000000",
        "slippage": 0.005,
        "fromTokenSymbol": "ETH",
        "toTokenSymbol": "USDC",
        "fromTokenDecimals": 18,
        "toTokenDecimals": 6
      }
    }
  ]
}
```

After the user approves or the action completes, submit the result back via `message/send` with a `functionReturn` part:

```json theme={null}
{
  "role": "user",
  "parts": [
    {
      "type": "functionReturn",
      "id": "call_abc123",
      "name": "execute_lifi_swap",
      "result": { "txHash": "0xabc..." }
    }
  ]
}
```

### Tool reference

<AccordionGroup>
  <Accordion title="call_smart_contract_function">
    Proposes a generic smart contract call for the user to approve or reject. Display the contract address, function name, arguments, and value before submitting the transaction.

    | Parameter      | Type       | Description                             |
    | -------------- | ---------- | --------------------------------------- |
    | `to`           | `string`   | Contract address                        |
    | `functionName` | `string`   | Name of the contract function           |
    | `args`         | `string[]` | Encoded function arguments              |
    | `chainId`      | `number`   | Target chain ID                         |
    | `value`        | `string`   | Native token value in wei               |
    | `abi`          | `string[]` | ABI fragments needed to encode the call |
  </Accordion>

  <Accordion title="send_native_gas_token">
    Sends native gas token (e.g. ETH) to an address. Show the recipient and amount for user confirmation before broadcasting.

    | Parameter | Type     | Description       |
    | --------- | -------- | ----------------- |
    | `to`      | `string` | Recipient address |
    | `chainId` | `number` | Target chain ID   |
    | `value`   | `string` | Amount in wei     |
  </Accordion>

  <Accordion title="transfer_nft">
    Transfers an NFT to another address. Display the NFT details and recipient before the user approves.

    | Parameter         | Type     | Description                                  |
    | ----------------- | -------- | -------------------------------------------- |
    | `contractAddress` | `string` | NFT contract address                         |
    | `tokenId`         | `string` | Token ID                                     |
    | `toAddress`       | `string` | Recipient address                            |
    | `amount`          | `string` | Amount (for ERC-1155; use `"1"` for ERC-721) |
    | `chainId`         | `number` | Target chain ID                              |
  </Accordion>

  <Accordion title="show_token_balance_ui">
    Requests a visual token balance display. Render balance cards or a portfolio summary using the provided data — no wallet transaction required.

    | Parameter    | Type       | Description                                                               |
    | ------------ | ---------- | ------------------------------------------------------------------------- |
    | `address`    | `string`   | Wallet address                                                            |
    | `balances`   | `object[]` | Array of token balance objects (symbol, amount, price, value, logo, etc.) |
    | `totalValue` | `number`   | Total portfolio value in USD                                              |
  </Accordion>

  <Accordion title="execute_lifi_swap">
    Executes a token swap or cross-chain bridge via LI.FI. Fetch a quote from LI.FI using the provided parameters, show the route to the user, then execute on approval.

    | Parameter           | Type     | Description                                |
    | ------------------- | -------- | ------------------------------------------ |
    | `fromChainId`       | `number` | Source chain ID                            |
    | `toChainId`         | `number` | Destination chain ID                       |
    | `fromTokenAddress`  | `string` | Source token address                       |
    | `toTokenAddress`    | `string` | Destination token address                  |
    | `fromAmount`        | `string` | Amount in source token's smallest unit     |
    | `slippage`          | `number` | Slippage tolerance (e.g. `0.005` for 0.5%) |
    | `fromTokenSymbol`   | `string` | Source token symbol                        |
    | `toTokenSymbol`     | `string` | Destination token symbol                   |
    | `fromTokenDecimals` | `number` | Source token decimals                      |
    | `toTokenDecimals`   | `number` | Destination token decimals                 |
  </Accordion>

  <Accordion title="enter_staking_yield">
    Prepares a staking transaction for a specific yield opportunity. Show the APY, protocol, pool, and lockup period before requesting approval.

    | Parameter            | Type       | Description                    |
    | -------------------- | ---------- | ------------------------------ |
    | `yieldId`            | `string`   | Yield opportunity ID           |
    | `amount`             | `string`   | Amount to stake                |
    | `walletAddress`      | `string`   | User's wallet address          |
    | `tokenSymbol`        | `string`   | Token to stake                 |
    | `tokenAddress`       | `string`   | Token contract address         |
    | `chainId`            | `number`   | Target chain ID                |
    | `network`            | `string`   | Network name                   |
    | `protocol`           | `string`   | Protocol name                  |
    | `poolName`           | `string`   | Pool name                      |
    | `apy`                | `number`   | Current APY                    |
    | `lockupPeriod`       | `string`   | Human-readable lockup duration |
    | `rewardTokenSymbols` | `string[]` | Reward token symbols           |
  </Accordion>

  <Accordion title="exit_staking_yield">
    Prepares an unstaking transaction to withdraw from a staking position.

    | Parameter       | Type     | Description           |
    | --------------- | -------- | --------------------- |
    | `yieldId`       | `string` | Yield opportunity ID  |
    | `amount`        | `string` | Amount to withdraw    |
    | `walletAddress` | `string` | User's wallet address |
  </Accordion>

  <Accordion title="aave_supply / aave_borrow / aave_repay / aave_withdraw">
    Aave V4 lending market interactions. All four share the same parameter shape and require user approval before executing.

    | Parameter       | Type     | Description                     |
    | --------------- | -------- | ------------------------------- |
    | `marketAddress` | `string` | Aave market contract address    |
    | `tokenAddress`  | `string` | Token contract address          |
    | `tokenSymbol`   | `string` | Token symbol                    |
    | `amount`        | `string` | Amount in token's smallest unit |
    | `walletAddress` | `string` | User's wallet address           |
    | `chainId`       | `number` | Target chain ID                 |
  </Accordion>

  <Accordion title="request_auto_rebalance_permission">
    Asks the user to grant permission for automatic yield rebalancing. Display the current position, minimum yield increase threshold, and maximum lockup before the user accepts or declines.

    | Parameter                  | Type     | Description                                  |
    | -------------------------- | -------- | -------------------------------------------- |
    | `chainId`                  | `number` | Target chain ID                              |
    | `tokenAddress`             | `string` | Token to rebalance                           |
    | `currentPosition.protocol` | `string` | Current protocol                             |
    | `currentPosition.amount`   | `string` | Current staked amount                        |
    | `currentPosition.apy`      | `number` | Current APY                                  |
    | `minYieldIncrease`         | `number` | Minimum APY improvement to trigger rebalance |
    | `maxLockupDays`            | `number` | Maximum lockup days the user will accept     |
  </Accordion>
</AccordionGroup>

## React Package

Interested in a drop-in `@coinfello/react` package? [Reach out to us](https://coinfello.com) — it's on the roadmap.


# Agent CLI
Source: https://docs.coinfello.com/agent/cli

Give your agent a wallet and connect to CoinFello from the command line

The [`@coinfello/agent-cli`](https://www.npmjs.com/package/@coinfello/agent-cli) npm package gives your agent a wallet backed by the macOS Secure Enclave and a CLI interface to CoinFello. Use this if your agent doesn't have a wallet yet.

```bash theme={null}
npm install -g @coinfello/agent-cli
```

## How It Works

1. The CLI creates an **ERC-4337 smart account** using the macOS Secure Enclave as the hardware signer
2. Your agent writes fine-grained **ERC-7710 delegations** to CoinFello (e.g. swap permissions on specific tokens)
3. CoinFello executes delegated actions from your agent's smart account — even when your agent isn't connected

<Note>
  Funds never leave your agent's wallet. ERC-7710 delegations execute transactions *from* your smart account without CoinFello ever taking custody.
</Note>

## Example: Automated Rebalancing

Delegate swap permissions to let CoinFello automatically rebalance your agent's token portfolio:

1. Agent connects via CLI and creates a smart account
2. Agent delegates swap permissions for specific tokens
3. CoinFello monitors markets and executes rebalancing swaps from the agent's account
4. Agent can revoke delegations at any time

## Key Standards

| Standard           | Role                                                 |
| ------------------ | ---------------------------------------------------- |
| **ERC-4337**       | Smart account for the agent's wallet                 |
| **ERC-7710**       | Fine-grained delegation for non-custodial automation |
| **Secure Enclave** | Hardware-level key management                        |


# ERC-8004
Source: https://docs.coinfello.com/agent/erc-8004

CoinFello's on-chain agent registration

CoinFello is registered on [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004), the open protocol for agent discoverability on Ethereum Mainnet.

| Field        | Value            |
| ------------ | ---------------- |
| **Agent ID** | `28359`          |
| **Network**  | Ethereum Mainnet |

## Explorers

<Columns>
  <Card title="8004 Scan" icon="magnifying-glass" href="https://8004scan.com/agent/28359" />

  <Card title="Agent Scan" icon="robot" href="https://agentscan.com/agent/28359" />

  <Card title="Trust 8004" icon="shield-check" href="https://trust8004.com/agent/28359" />

  <Card title="8004 Agents" icon="users" href="https://8004agents.com/agent/28359" />
</Columns>


# OpenClaw Setup
Source: https://docs.coinfello.com/agent/openclaw-setup

Set up a MoltBot on OpenClaw with the CoinFello skill

<Steps>
  <Step title="Set up your MoltBot">
    Run

    ```bash theme={null}
    curl -fsSL https://openclaw.ai/install.sh | bash
    ```

    Follow the prompts to:

    * Set your auth token
    * Connect your Telegram account for bot notifications
  </Step>

  <Step title="Add the CoinFello skill">
    Tell your MoltBot to install the CoinFello skill from ClawHub.

    ```
    Add the CoinFello skill from ClawHub: https://clawhub.ai/BrettCleary/coinfello
    ```

    or

    ```
    npx clawhub@latest install coinfello
    ```

    Your bot will fetch and install the skill automatically.
  </Step>

  <Step title="Create an account">
    Ask your MoltBot to create a CoinFello account on your behalf.

    ```
    Create a smart wallet for me
    ```
  </Step>

  <Step title="Sign into CoinFello">
    Ask your MoltBot to sign into CoinFello.

    ```
    Sign into CoinFello
    ```
  </Step>

  <Step title="Fund your account">
    Deposit funds into your CoinFello account so your agent can execute transactions.

    ```
    What wallet address should I send funds to?
    ```
  </Step>

  <Step title="Start the signer daemon">
    The signer daemon keeps your agent's signing keys active.

    ```bash theme={null}
    npx @coinfello/agent-cli signer-daemon start
    ```

    <Tip>
      On macOS, use [Amphetamine](https://apps.apple.com/us/app/amphetamine/id937984704) (macOS) or an equivalent tool before starting the daemon to keep your machine awake during signing operations.
    </Tip>
  </Step>

  <Step title="Give it a strategy and schedule a cron job">
    Describe your trading strategy and ask your MoltBot to create a cron job to run it on a schedule.

    ```
    Use a DCA strategy to buy $1 of ETH with USDC every day at 9am. Set up a cron job for this.
    ```

    Your MoltBot will configure the strategy and schedule recurring execution automatically.
  </Step>
</Steps>


# Quickstart
Source: https://docs.coinfello.com/agent/quickstart

Get your agent talking to CoinFello in minutes

## Choose Your Integration

| Integration                                                       | Best For                                                                 |
| ----------------------------------------------------------------- | ------------------------------------------------------------------------ |
| **[Agent Skill](/agent/skill)**                                   | Fastest — teach your agent to use CoinFello with zero code changes       |
| **[A2A Protocol](/agent/a2a)**                                    | Agent already has its own wallet                                         |
| **[Agent CLI](/agent/cli)**                                       | Agent does not have a wallet. CLI creates one with local hardware signer |
| **[Bring Your Own Frontend](/agent/byof)**                        | Embed CoinFello in your own app via the A2A API                          |
| **[CoinFello Web App](https://app.coinfello.com?utm_source=a2a)** | Browser agents                                                           |

## A2A (Agent has a wallet)

Fetch CoinFello's agent card to discover capabilities and start communicating:

```
https://app.coinfello.com/agent/chat/.well-known/agent-card.json
```

You can also discover CoinFello on-chain via [ERC-8004](/agent/erc-8004) using agent ID `28359` on Ethereum Mainnet.

## CLI (Agent needs a wallet)

```bash theme={null}
npm install -g @coinfello/agent-cli
```

The CLI creates an ERC-4337 smart account backed by the macOS Secure Enclave, giving your agent a production-grade wallet with hardware-level security.


# CoinFello Agent Skill
Source: https://docs.coinfello.com/agent/skill

The fastest way to give your agent CoinFello capabilities

The CoinFello Agent Skill teaches your agent how to use the `@coinfello/agent-cli`. Install the skill and your agent can immediately start interacting with CoinFello — no manual integration work required.

<Columns>
  <Card title="OpenClaw" icon="paw" href="https://clawhub.ai/BrettCleary/coinfello">
    Available now for OpenClaw Agents
  </Card>

  <Card title="skills.sh" icon="bolt" href="https://skills.sh/">
    Coming soon
  </Card>
</Columns>

## OpenClaw Quickstart

Ready to get going? Follow the [OpenClaw quickstart guide](/agent/openclaw-setup).


# Authentication
Source: https://docs.coinfello.com/api-reference/authentication

Authenticate with CoinFello using Sign-In with Ethereum (SIWE)

The CoinFello API uses [Sign-In with Ethereum (EIP-4361)](https://eips.ethereum.org/EIPS/eip-4361) for authentication. You must complete the SIWE flow to obtain a session cookie before calling the A2A endpoint. Unauthenticated requests return a `401` error.

## Flow overview

<Steps>
  <Step title="Request a nonce">
    Fetch a one-time nonce from the server tied to your wallet address.
  </Step>

  <Step title="Construct and sign the SIWE message">
    Build an EIP-4361 message using the nonce, then sign it with your wallet.
  </Step>

  <Step title="Verify the signature">
    Submit the signed message to the server. On success, you receive a session cookie valid for subsequent requests.
  </Step>
</Steps>

## Step 1: Request a nonce

```bash theme={null}
curl -c cookies.txt -X POST https://app.coinfello.com/api/auth/siwe/nonce \
  -H "Content-Type: application/json" \
  -d '{
    "walletAddress": "0xYourWalletAddress",
    "chainId": 1
  }'
```

**Response**

```json theme={null}
{
  "nonce": "abc123xyz"
}
```

The `-c cookies.txt` flag saves the session cookie jar for use in subsequent requests.

## Step 2: Construct and sign the SIWE message

Build an [EIP-4361](https://eips.ethereum.org/EIPS/eip-4361) message using the nonce. The message format is:

```
app.coinfello.com wants you to sign in with your Ethereum account:
0xYourWalletAddress

URI: https://app.coinfello.com
Version: 1
Chain ID: 1
Nonce: abc123xyz
Issued At: 2024-01-01T00:00:00.000Z
```

Sign this message with your wallet to produce a signature. Most wallet libraries (viem, ethers.js, wagmi) expose a `signMessage` method for this.

<Note>
  The exact string you sign must match what you submit in step 3. Use a SIWE library (e.g., [`viem/siwe`](https://viem.sh/docs/siwe/utilities/createSiweMessage)) to construct and parse the message consistently.
</Note>

## Step 3: Verify the signature

Submit the signed message and signature to authenticate. Include `-b cookies.txt` to send the cookie from step 1 and `-c cookies.txt` to save the updated session cookie.

```bash theme={null}
curl -b cookies.txt -c cookies.txt -X POST https://app.coinfello.com/api/auth/siwe/verify \
  -H "Content-Type: application/json" \
  -d '{
    "message": "app.coinfello.com wants you to sign in with your Ethereum account:\n0xYourWalletAddress\n\nURI: https://app.coinfello.com\nVersion: 1\nChain ID: 1\nNonce: abc123xyz\nIssued At: 2024-01-01T00:00:00.000Z",
    "signature": "0xYourSignature",
    "walletAddress": "0xYourWalletAddress",
    "chainId": 1
  }'
```

On success the server sets an authenticated session cookie. Pass this cookie with all subsequent A2A requests.

## Making authenticated requests

Use the saved cookie jar with every API call:

```bash theme={null}
curl -b cookies.txt -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "message": {
        "role": "user",
        "parts": [{ "type": "text", "text": "What are the best yields for ETH right now?" }]
      }
    }
  }'
```


# API Reference
Source: https://docs.coinfello.com/api-reference/introduction

Integrate CoinFello into your applications

## A2A Endpoint

CoinFello exposes a single API endpoint that implements the [Agent-to-Agent protocol spec](https://a2a-protocol.org/latest/) over JSON-RPC 2.0.

```
POST https://app.coinfello.com/api/a2a
```

### Methods

| Method           | Description                                                      |
| ---------------- | ---------------------------------------------------------------- |
| `message/send`   | Send a message and get a response                                |
| `message/stream` | Send a message and stream the response via SSE                   |
| `tasks/get`      | Get a task by ID (optionally limit history with `historyLength`) |
| `tasks/cancel`   | Cancel a running task                                            |

### Agent ID

Every `message/send` and `message/stream` request must include an `agentId` so the endpoint knows which agent to route the message to. The endpoint is agent-agnostic — there is no hardcoded default.

Pass the `agentId` (a number) in `params.configuration`:

```json theme={null}
{
  "params": {
    "configuration": { "agentId": 1 },
    "message": { ... }
  }
}
```

Omitting the `agentId` on a new request returns an error: `"agentId is required: provide in configuration.agentId or as a DataPart"`. Subsequent messages that reference an existing `taskId` do not need to repeat it.

Retrieve the agent's numeric ID from the [agent card](https://app.coinfello.com/agent/chat/.well-known/agent-card.json) under skills where each entry is a separate chat agent.

### Send a Message

```bash theme={null}
curl -b cookies.txt -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/send",
    "params": {
      "configuration": { "agentId": 1 },
      "message": {
        "role": "user",
        "parts": [{ "type": "text", "text": "What are the best yields for ETH right now?" }]
      }
    }
  }'
```

### Stream a Response

Use `message/stream` to receive Server-Sent Events. Each SSE `data` line is a JSON-RPC response wrapping an A2A stream event.

```bash theme={null}
curl -b cookies.txt -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "message/stream",
    "params": {
      "configuration": { "agentId": 1 },
      "message": {
        "role": "user",
        "parts": [{ "type": "text", "text": "Swap 0.1 ETH to USDC" }]
      }
    }
  }'
```

### Get a Task

```bash theme={null}
curl -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tasks/get",
    "params": { "id": "task-id-here", "historyLength": 5 }
  }'
```

### Cancel a Task

```bash theme={null}
curl -X POST https://app.coinfello.com/api/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tasks/cancel",
    "params": { "id": "task-id-here" }
  }'
```

## Authentication

Authentication uses SIWE (Sign-In with Ethereum). Complete the SIWE flow to obtain a session cookie before making requests. Unauthenticated requests return a `401` error.

See the [Authentication](/api-reference/authentication) page for the full SIWE flow with curl examples.

## Errors

Errors follow standard JSON-RPC 2.0 error format:

| Code     | Meaning                  |
| -------- | ------------------------ |
| `-32600` | Invalid JSON-RPC request |
| `-32601` | Unknown method           |
| `-32001` | Task not found           |
| `-32002` | Task not cancelable      |
| `-32603` | Internal server error    |

## Rate Limits

API requests are rate-limited. Current limits are provided in response headers:

| Header                  | Description                           |
| ----------------------- | ------------------------------------- |
| `X-RateLimit-Limit`     | Maximum requests per minute           |
| `X-RateLimit-Remaining` | Requests remaining in current window  |
| `X-RateLimit-Reset`     | Unix timestamp when the window resets |


# FAQ
Source: https://docs.coinfello.com/faq



## **Getting Started With CoinFello**

**How do I start using CoinFello?**\
Visit [<u>app.coinfello.com</u>](http://app.coinfello.com) and connect your wallet (or create a new wallet). Prompt away. You can ask things like "swap 0.5 ETH to USDC" or "find me the best staking yields on Base."

**Is my wallet controlled by CoinFello?**\
CoinFello is built for 100% self-custody. CoinFello never holds keys or custodies your assets, instead relying on granular permissions you grant from your wallet. We will soon be launching trusted execution environments so that even your AI model runs in an environment you control. Self-sovereignty is at the core of our values.

**What happens when I connect my wallet?**\
CoinFello reads your public portfolio data (no private keys). You explicitly approve any transactions via MetaMask, the experience you’re likely already familiar with when interacting with dapps. In the future, you’ll be able to delegate permissions for certain actions to be automated or occur without ongoing approvals.

**Do I need ETH for network fees (gas) to use CoinFello?**\
Yes, for onchain actions. CoinFello optimizes gasless/batched txs via EIP-7702 when possible, but in many scenarios you'll still need to pay network fees.

**Can CoinFello access my full wallet balance?**\
Your CoinFello agent only reads public onchain data. You control every spend/approval, or you can give the agent permissions and delegations to manage specific funds in an automated way. This experience will keep improving with some upcoming updates to Ethereum and our wallet partners.

**What actions can CoinFello perform?**\
Currently supported: Dollar cost averaging (DCA), token swaps (best-price routing), sends/transfers, staking, bridging across chains, yield discovery, and portfolio analysis. **Custom automations using natural language are coming soon.**

**What if I'm new to DeFi?**\
CoinFello explains everything step-by-step. Start with "explain my portfolio" or "walk me through yield farming”. You can ask as many questions at any level that suits your situation best.

## **Delegations & Permissions**

**What are delegations?**\
Delegations are fine-grained permissions you grant to CoinFello (or your agent like OpenClaw or Claude Code) to act on your wallet's behalf within strict boundaries. Think of it like giving someone a debit card with a daily spending limit. They can make purchases, but only up to the amount you set, and you can revoke access anytime.

**What controls can I set on a delegation?**\
You can set spending limits per token, time-bound expiry (daily, weekly, or monthly allowances), and restrict which types of actions are permitted. The delegation architecture is built on EIP-7702 smart accounts with ERC-7710 permissions, giving you granular control without giving up custody.

**Can CoinFello access my full wallet balance?**\
No. CoinFello can only read your public onchain data and act within the specific delegation you've approved. If you grant a 0.1 ETH weekly allowance, that's the maximum CoinFello can spend, regardless of your total balance.

**Can I revoke a delegation?**\
Yes. You can revoke any delegation at any time. Your funds remain in your wallet throughout. Delegations are permissions, not transfers.

**How is this different from giving an agent a private key?**\
Most agent wallets today require funds to be transferred to their own wallets and keys (vulnerable to total fund loss through exploits or agent hallucination) and make it difficult for users to control the permissions and behavior of the agent outside of a binary transfer of funds to the agent. CoinFello's delegation model means the agent never holds your keys. It operates through bounded, revocable permissions on your existing wallet. If CoinFello Labs disappeared tomorrow, your funds and keys remain exactly where they are.

## **Security & Trust**

**Does CoinFello ever have access to my private keys or full wallet?**\
CoinFello is built around self-custody. Your private keys are never shared with or accessible to CoinFello. All onchain actions go through the delegation framework: bounded permissions that you set and can revoke. Every transaction is presented in plain-language for your review before execution.

**How does CoinFello protect against prompt injection or AI errors?**\
Your CoinFello agent only accepts prompts from the user themself. It cannot receive prompts from outside third parties.

**Is CoinFello decentralized?**\
CoinFello's smart contract layer is built on decentralized standards (ERC-7702, 7710, 7715). Our backend infrastructure is currently centralized, and we're transparent about that. On our roadmap is migration to self-sovereign verifiable Trusted Execution Environments (TEEs). We believe decentralization is progressive, and we're ahead of the market on the permission and delegation layer.

**What happens if CoinFello goes offline?**\
Your funds and keys are unaffected. CoinFello operates through delegations on your wallet, not by holding assets. If our service is unavailable, your wallet functions normally through MetaMask or any other wallet interface. This is what we call the "walkaway test", and CoinFello passes it.

## **For Developers**

**Can my product's agent use CoinFello for onchain transactions?**\
Yes. CoinFello is designed as an execution layer that other agents can delegate to. If you're building an AI agent that needs onchain capabilities (swaps, sends, staking, bridging), you can integrate CoinFello rather than building your own wallet and transaction infrastructure. Your agent sends natural language or structured intents, and CoinFello returns constructed transactions. [<u>Learn more</u>](https://docs.coinfello.com/agent/quickstart)

**How do I integrate with CoinFello?**\
CoinFello supports multiple integration patterns:

| **Integration**                                                         | **Best for**                                                             |
| :---------------------------------------------------------------------- | :----------------------------------------------------------------------- |
| [<u>Agent Skill</u>](https://docs.coinfello.com/agent/skill)            | Fastest — teach your agent to use CoinFello with zero code changes       |
| [<u>A2A Protocol</u>](https://docs.coinfello.com/agent/a2a)             | Agent already has its own wallet                                         |
| [<u>Agent CLI</u>](https://docs.coinfello.com/agent/cli)                | Agent does not have a wallet. CLI creates one with local hardware signer |
| [<u>Bring Your Own Frontend</u>](https://docs.coinfello.com/agent/byof) | Embed CoinFello in your own app via the A2A API                          |
| [<u>CoinFello Web App</u>](https://app.coinfello.com/?utm_source=a2a)   | Browser agents                                                           |

**What is ERC-8004, and how does CoinFello use it?**\
ERC-8004 is an onchain registry standard for agent discovery and reputation. CoinFello is listed on ERC-8004 on Ethereum Mainnet, making it discoverable by other agents at runtime. Future integrations will allow agents to discover CoinFello, evaluate its trustworthiness via registry metadata, and request delegations dynamically.

**Can I revoke a delegation?**\
Yes. You can revoke any delegation at any time. Your funds remain in your wallet throughout. Delegations are permissions, not transfers.

## **Business Inquiries**

**I’m interested in investing in CoinFello. How do I get in touch?**\
Great! Send us an email at [<u>hello@coinfello.com</u>](mailto:hello@coinfello.com) 

**I’m a reporter and would like to know more about CoinFello. How do I get in touch?**\
Please reach out to [<u>hello@coinfello.com</u>](mailto:hello@coinfello.com).

**I want to explore a partnership or integration with CoinFello.**\
We're actively exploring partnerships with wallets, protocols, agent platforms, and infrastructure providers. Reach out at [<u>hello@coinfello.com</u>](mailto:hello@coinfello.com) with details on your project and we'll follow up.