---
name: flexyield-gateway
description: >
  Use FlexYield as your blockchain access layer: one API key per agent with a
  monthly budget, JSON-RPC for 6 chains, a toolbox of
  higher-level tools (gas, ENS, prices, tx status), free response caching, and
  full account control over MCP. Card-billed by the key owner — no wallet needed.
license: Proprietary — see https://flexyield.io/terms
---

# FlexYield Gateway — Agent Skill

FlexYield is a unified access layer for blockchain infrastructure. You (an
agent) get a key, a budget, and measured routing; the human who runs you gets
one dashboard and one invoice.

## Three doors — nothing logs in

| Door | How | You get |
|---|---|---|
| 1 anonymous | `POST https://flexyield.io/keys` (no body) or MCP `get_key` | a capability key at once: public supply, 10,000 weighted units per UTC day, 5 req/s, every tool; 3 keys per IP address per day |
| 2 bound | `POST /keys/bind/start {address}` → sign the SIWE message with your wallet → `POST /keys/bind {address, signature}` (MCP: `bind_key_start`, `bind_key_complete`) | the same key, persistent across sessions, 1M units/month; one key per wallet |
| 3a pay per call | x402: `GET /x402` for the menu, settle, `POST /x402/redeem {tx_hash, tier, signature}` (signature = EIP-191 personal_sign by the paying wallet over the message the menu states), send the returned one-time credential as `X-PAYMENT` | premium units without an account (testnet rehearsal until mainnet) |
| 3b adopted | show your owner the `claim_code` from the welcome; they paste it at /agents | the owner's plan: premium supply, fast, packs, fleet budgets, statements, support with evidence |

Every refusal on a door key is a doorway with the next door in the body (`-32016` = daily units used up).

## Authentication

Every call authenticates with an API key in the Authorization header:

    Authorization: Bearer fy_...

A key comes through any of the three doors above — no human needed. A human can also
create an account and keys at https://flexyield.io (free tier, no card required); an
adopted door key inherits that account. Everything else is done by agents over MCP.

## JSON-RPC relay

    POST https://flexyield.io/rpc/{chain}
    Content-Type: application/json
    {"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}

Chains:
- `arbitrum_one`
- `base_mainnet`
- `eth_mainnet`
- `optimism_mainnet`
- `polygon_pos`
- `solana_mainnet`

Weighted metering: standard calls count 1 unit, heavy calls (traces, wide
getLogs) 2, data-API calls 10, toolbox calls 1 (tx status 2). **Cache hits
count 0** — repeated identical reads inside the freshness window are free.
Details: https://flexyield.io/docs#caching

## Toolbox (higher-level tools, one call instead of many)

    POST https://flexyield.io/toolbox/{service}

Services: gas (fee oracle), ens (resolve), prices (token prices), tx
(status/decode), abi (contract ABI), utils (EVM helpers). Same key, same
meter. Reference: https://flexyield.io/toolbox

## MCP — full account control for agents

    https://flexyield.io/mcp   (Streamable HTTP, POST JSON-RPC; Authorization: Bearer <key>)
    The legacy HTTP+SSE door (/mcp/sse, /mcp/messages) closed on 2026-09-26 (announced for 2026-09-28); it answers 410 Gone with this pointer.

Tools (35, verb-first, one job each): keys — `create_api_key(name, monthly_request_cap?)` ·
`configure_key(id, monthly_request_cap?, enabled[]?, caps{}?)` — budget and the services one key
may use, with per-service unit caps (a fenced service answers -32012 with `blocked_by: key`, a
capped one -32014 with `scope: key`; a key is never wider than its account) · `revoke_api_key(api_key_id)` ·
`list_api_keys(scope: keys|agents)`. Account — `get_billing_status` · `configure_services(enabled?,
caps?)` (no arguments = read) · `update_account(notify_incidents?, time_zone?, use_case?, …)` ·
`list_plans`. Usage — `get_usage(view: report|stats|volume, …)` per key, per report, over time ·
`get_statement(period?)` (`period: "list"` lists the periods). Support — `manage_tickets(action:
create|list|get|reply, …)` · `manage_feedback(action: submit|list, …)`. The relay itself —
`rpc_call(chain, method, params?)`: one JSON-RPC call through the same routing, cache and meter as
`POST /rpc/{chain}`. Data and toolbox — `get_balances`, `get_history`, `get_prices(kind: gas|token)`,
`get_tx_status`, `resolve_ens`, `get_abi`, `decode_calldata`, `convert_evm`, `verify_signature`.
Same meter, same fences on both doors: MCP data tools burn the same units and answer the same
doorways as their HTTP twins (-32005 rate, -32006 budget, -32007 quota, -32014 service cap);
management tools are rate-limited only. **The agent menu, no key needed:** `get_key` ·
`bind_key_start` / `bind_key_complete` · `what_can_i_do` (your door, budgets, fences as doorways, the
ladder priced at your own volume, the break-even sentence) · `get_quote(chain, method, tier?)` ·
`explain_error(code)` · `recommend(what: chain|route, …)` — recommendations from our probes, never|route, …)` — recommendations from our probes, never
hearsay · `migrate(config)` — paste your current provider config, get every endpoint mapped and every
method weighed, keys masked, nothing stored · `buy_pack` inside an adopted account. The pre-v2 names (usage_report, quote, pick_chain,
set_key_budget, …) went with the legacy door on 2026-09-26 (announced for 2026-09-28); the 35 names above, on POST /mcp, are the tool set.

## The fleet pattern (one owner, many agents)

**Already have an agent? Claim it.** An existing agent (any EVM wallet identity)
joins the fleet by proving ownership: `claim_agent_start(name, address)` returns
a standard sign-in message (EIP-4361); the agent's wallet signs it;
`claim_agent_complete(address, signature)` verifies and equips a budgeted key
(default 50000 requests/month) — shown once. `list_api_keys(scope: "agents")`
shows the fleet. Humans do the same on https://flexyield.io/agents with one
"Sign with wallet" click (the message is issued for the site you are on, so
the wallet shows no domain warning; no transaction, no gas).


1. The owner creates the account and one owner key.
2. For each agent, mint a key with a budget:
   `create_api_key(name: "agent-7", monthly_request_cap: 50000)`.
3. Each agent uses only its own key. Budgets are enforced per key on the hot
   path; an over-budget key gets a clear refusal with an upgrade doorway, and
   every other key keeps working.
4. `get_usage(view: "report")` shows spend per key; `configure_key` adjusts the budget and
   fences a key to e.g. gas + prices only (the robot may reach the charger, not the bank);
   `revoke_api_key` kills a leaked or retired key instantly.

Worked example: https://flexyield.io/docs · demo script in the repo
(`bin/demo/fleet_keys.rb`).

## Fair-use & doorways

Rate and plan limits answer with structured errors that say what to do next —
never a bare 429. If you need more than the fences allow, the response tells
you (or your human) exactly where the doorway is. A transaction submission
(`eth_sendRawTransaction`, `sendTransaction`) is posted to exactly one endpoint and
never re-sent by us: a failure after it left answers `-32017 unknown outcome` —
look the hash up before re-signing (`explain_error(-32017)`).

## When a call fails: file it, with the request_id

Every error body — HTTP and MCP — carries `data.request_id` and `data.support`
(`/support/new?request_id=…`); the `X-Request-Id` header on every answer, success included,
is the same id — quote it when a 200 was slow or wrong. Over MCP: `manage_tickets(action: "create", subject,
message, request_id)` opens a ticket for the account; we attach that exact call, the
last 24 h of refusals, the key's caps and the chain status, plus the steps that
usually fix it. `manage_tickets(action: "get", reference)` shows the thread and the
suggested path; `manage_tickets(action: "reply", reference, message, resolve: true)`
closes the loop when it is fixed. The same symptom within an hour joins the open ticket
instead of opening a new one. Wishes and chain requests: `manage_feedback(action: "submit",
kind, title, chain?)` — private to the account, answered on the item (`action: "list"`).

## Your statement, without a dashboard

`get_statement(period: "list")` → the account's billing periods (its own subscription cycle, or
calendar months); `get_statement(period?)` → invoice facts plus usage grouped by
key and agent, by chain and method class: requests, weighted units, cache hits
(free), refusals. **A key that belongs to an agent gets that agent's usage only** —
every agent can read its own bill. Same over HTTP with the bearer key:
`GET https://flexyield.io/api/statements/<period>` (JSON) or `.csv`.

## Three intentions — which lane is yours

- **Try it:** a door-1 key (10,000 units/day), a wallet-bound key (1,000,000/month) or a Free account — public supply, no card.
- **Run production:** Pro / Scale / Growth — premium supply, measured failover, packs, a soft landing at the limit; your owner adopts your key by claim code.
- **Govern a fleet:** Enterprise, or any plan with fleet keys — a budget per agent, service fences, statements per key, a premium allowance on request.

## Paying for it — the ladder, in your numbers

One rule: price per unit falls with commitment, never with identity. Per call (x402, testnet rehearsal today) is the
uncommitted lane; packs are cheaper per unit; a subscription is cheaper still and carries the features an owner
wants: fleet keys with budgets, service fences, a premium allowance on request, statements per key, support that arrives with
the failing call. Route tiers on every door: cheap ×0.5 · balanced ×1 · fast ×2 on standard units. Every price is
net; VAT is added where it applies — at checkout for cards, in the x402 menu by your location for per call.
- Pro (yearly): $5.50 per 1M standard units
- Pro: $6.60 per 1M standard units
- Pack M: $7.14 per 1M standard units
- Per call (x402) / PAYG: $9.00 per 1M standard units (planned)
- Builder: $0.60 per 1M standard units
- Free: $0.00 per 1M standard units
Break-even you can relay to your owner: every pack is cheaper per unit than per call when its units are used within
the year (leftover units stay valid 12 months; below a twelfth of the pack per month, per call is cheaper); Pro yearly beats per call above ~9.2M units/month and is the cheapest committed lane up to its quota. The full
table with your own volume priced on every lane is the `what_can_i_do` tool; the same numbers sit in
https://flexyield.io/openapi.json → x-pricing.

## Status & trust

- Live measured status: https://flexyield.io/status (public, per chain)
- Terms: https://flexyield.io/terms · Privacy: https://flexyield.io/privacy
- Machine summary of the whole site: https://flexyield.io/llms.txt
- Third parties: FlexTrust is mentioned for information only. FlexYield does not endorse FlexTrust and accepts no
  liability for its service; FlexTrust's own terms apply to it.