# FlexYield

> One API key, one meter, one bill for multi-chain JSON-RPC access, with automatic multi-provider failover and a public measured status page. No wallet, no crypto required.

FlexYield is a unified RPC gateway: point your application at a single endpoint and every JSON-RPC 2.0 request is routed to the best healthy upstream provider, with automatic failover and per-key usage metering. Accounts are email-based, plans are card-billed, and a live dashboard shows volume, latency, and spend per API key.

## Getting started

1. Sign up (free tier included): https://v2.flexyield.io/registration/new
2. Create an API key in the dashboard — the plaintext token is shown exactly once.
3. Relay JSON-RPC requests:

    curl -X POST https://v2.flexyield.io/rpc/eth_mainnet \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber"}'

## Agent Skill

Full agent instructions (keys, budgets, fleet pattern, MCP): https://v2.flexyield.io/skill.md

## Supported chains

Relay to any of these with POST https://v2.flexyield.io/rpc/{chain}:

- arbitrum_one — Arbitrum One
- base_mainnet — Base Mainnet
- eth_mainnet — Ethereum Mainnet
- optimism_mainnet — OP Mainnet
- polygon_pos — Polygon PoS
- solana_mainnet — Solana Mainnet

## Data API (beyond raw RPC)

Same bearer API key and metering as /rpc. Requires a paid plan (free-tier
keys receive error -32010). Status: premium data upstreams are
onboarding — these endpoints answer 503 until a data-capable provider is live.

- GET https://v2.flexyield.io/data/{chain}/balances/{address} — native balance (all chains); ERC-20 token balances on chains with a data-capable upstream
- GET https://v2.flexyield.io/data/{chain}/history/{address} — recent asset transfers, newest first (chains with a data-capable upstream)
- GET https://v2.flexyield.io/toolbox/gas/{chain} — EIP-1559 gas recommendations (slow/standard/fast) computed from the multi-provider pool, EVM chains, 1 unit/call, every tier; also the get_prices(kind: "gas") MCP tool. Toolbox services can be disabled per account — a disabled service answers -32012 (HTTP 403) with the enable path; an optional per-service monthly cap answers -32014 (HTTP 429) once reached.
- GET https://v2.flexyield.io/toolbox/tx/{chain}/{hash} — transaction status on any supported chain (confirmed/failed/pending/unknown; confirmations + gas on EVM, slot + commitment on Solana), 2 units/call (computed per hash); also the get_tx_status MCP tool.
- GET https://v2.flexyield.io/toolbox/ens/resolve/{name} and /toolbox/ens/reverse/{address} — on-chain ENS resolution (Ethereum mainnet), 1 unit/call; also the resolve_ens MCP tool. Reverse records are self-declared — forward-verify before trusting.
- GET https://v2.flexyield.io/toolbox/prices?symbols=eth,btc — USD prices read on-chain from Chainlink aggregator feeds (no third-party price API; symbols eth, btc, link — more on request), honest stale flags, 1 unit/call; also the get_prices(kind: "token") MCP tool.
- GET https://v2.flexyield.io/toolbox/abi/{chain}/{address} — verified contract ABI + name from Sourcify's open dataset (unverified answers verified:false with the fix path); POST /toolbox/decode/{chain}/{address} with data=0x… decodes calldata to function signature + arguments. 1 unit each; MCP tools get_abi, decode_calldata.
- GET https://v2.flexyield.io/toolbox/utils/checksum/{address} · /toolbox/utils/convert?value=&from=&to= · /toolbox/utils/selector?signature= · /toolbox/utils/keccak?text= — stateless EVM utilities (EIP-55, unit conversion, 4-byte selectors + topic0, keccak256), 1 unit each; MCP tool convert_evm. POST /toolbox/utils/verify-signature (EIP-191 personal_sign: message + signature + optional expected address) and POST /toolbox/utils/verify-siwe (EIP-4361: exact signed message + signature — signature + expiry verified, domain/nonce policy is yours), 1 unit each; MCP tool verify_signature. Recovery only — no keys held.

## x402 — pay-per-use, no signup (for agents)

Machine customers can use the gateway WITHOUT an account, paying per
use on-chain. GET https://v2.flexyield.io/x402 returns the measured
route menu (cheap = public supply · balanced = wholesale blend · fast =
premium slice — priced from OUR OWN instruments, not a supplier's card)
and the payment challenge. Settle on the stated network, then
POST /x402/redeem { tx_hash, tier, signature } — the signature is an
EIP-191 personal_sign by the paying wallet over "FlexYield x402 redeem\n<tx_hash>"
(proof you own the settlement; the tx hash alone is public) — to receive a
one-time credential (fyx_…); call the gateway with header
X-PAYMENT: <credential> until units or the window are used up. Prices are
net; VAT is added by your location where it applies.
TESTNET ONLY for now — real-money settlement opens after regulatory sign-off.

## How we count (weighted units)

Quotas and rate windows count weighted units, not raw calls:

- standard calls = 1 unit
- heavy calls = 2 units — the debug_* / trace_* family, eth_simulateV1,
  eth_getLogs over more than 128 blocks, and state reads deeper than 128
  blocks from the chain head
- data API calls = 10 units
- toolbox calls = 1 unit (tx status: 2 — computed per hash); served from
  community supply and heavily cached — deliberately the cheapest line on
  the meter
- served from our cache = 0 units — an identical request inside the
  published TTL, RPC and toolbox alike; the rate window still counts it

## Caching (what we cache, for how long)

Cache hits cost 0 units and carry the header X-FlexYield-Cache: hit.
Quota, per-key caps and per-service caps are never consumed by a hit;
rate windows count every request. Only deterministic answers, only for
an identical request inside the TTL — never eth_call, eth_getLogs,
balances, nonces or anything relative to "latest":

- chain constants (eth_chainId, net_version): 1 week
- head reads: eth_blockNumber (2 s), eth_gasPrice (2 s), getSlot (1 s)
- by-hash lookups (eth_getBlockByHash, eth_getTransactionByHash, eth_getTransactionReceipt): 1 week, only once the block is 64 blocks below the head
- toolbox gas oracle: 12 s
- toolbox transaction status: 5 s
- toolbox ens resolve: 5 min
- toolbox token prices: 30 s
- toolbox contract intelligence: 24 h
- toolbox evm utilities: computed every call (never cached)

This table is identical on EVERY tier, free included — same catalog,
same weights, same parameter caps, same doorways. Upgrading changes how
much you can use and which supply serves you, never how we count.

## Method catalog and parameter limits

FlexYield serves an explicit catalog of JSON-RPC methods.

- A method outside the catalog answers error -32601 (HTTP 404). The error
  carries data.contact — that is an invitation, not a wall: write to
  hello@flexyield.io with what you are building and we enable or tailor it,
  usually within a day.
- eth_getLogs ranges are capped at 1,000 blocks and eth_feeHistory at 1,024
  blocks; beyond that the answer is -32602 (HTTP 400). Paginate, or ask us
  for a tailored package.
- getProgramAccounts is not served today (every upstream we measured fences
  it); the same doorway applies.

## Pricing

- Free: free — 1,000,000 requests/month included · burst up to 100 requests per 15 minutes
- Builder: $12.00/month — A steady 30 requests/second on community supply, around the clock — soft ceiling 20M units a month, then 10 req/s; no overage billing
- Pro: $99.00/month — 15,000,000 requests/month included · burst up to 6,000 requests/min
- Scale: $299.00/month — 60,000,000 requests/month included · burst up to 12,000 requests/min
- Growth: $899.00/month — 200,000,000 requests/month included · burst up to 18,000 requests/min
- Pro (yearly): $990.00/year — 15,000,000 requests/month included · burst up to 6,000 requests/min
- Scale (yearly): $2,990.00/year — 60,000,000 requests/month included · burst up to 12,000 requests/min
- Growth (yearly): $8,990.00/year — 200,000,000 requests/month included · burst up to 18,000 requests/min
- Enterprise: custom plans with dedicated capacity — hello@flexyield.io

## The price ladder (one rule, machine-readable at https://v2.flexyield.io/openapi.json → x-pricing)

Rule: price per unit falls with commitment, never with identity — more volume committed per month → lower USD per 1M
units; yearly < monthly; per call is the dearest lane, no pack ever undercuts the yearly tier, and at its included
volume a subscription is the cheapest per unit. Route tiers on every door: cheap ×0.5 ·
balanced ×1 · fast ×2 (standard units only). USD per 1,000,000 standard units, balanced tier; "planned" = decided,
not yet purchasable:
- Scale (yearly): $4.15/M (subscription, premium supply)
- Growth (yearly): $3.75/M (subscription, premium supply)
- Pro (yearly): $5.50/M (subscription, premium supply)
- Scale: $4.98/M (subscription, premium supply)
- Growth: $4.50/M (subscription, premium supply)
- Pack L: $6.25/M (pack, premium supply)
- Pro: $6.60/M (subscription, premium supply)
- Pack M: $7.14/M (pack, premium supply)
- Pack S: $8.33/M (pack, premium supply)
- Per call (x402) / PAYG: $9.00/M (per_call, premium supply, planned)
- Builder: $0.60/M (flat, public supply)
- Free: $0.00/M (free, public supply)
- Anonymous key (door 1): $0.00/M (free, public supply, planned)
- Founding (Pro locked 12 months; until 2026-12-05 or while seats last): $5.27/M (subscription, premium supply)
An account is always at least as cheap per unit as paying per call on the same supply, and the account is where the
features live: fleet keys with budgets, service fences, premium allowances, statements per key, support with evidence.

Full pricing: https://v2.flexyield.io/pricing

## MCP (for AI agents)

FlexYield exposes its capabilities as an MCP server at https://v2.flexyield.io/mcp (Streamable HTTP: POST JSON-RPC, stateless, one JSON answer per request; the legacy HTTP+SSE door at https://v2.flexyield.io/mcp/sse closed on 2026-09-26 (announced for 2026-09-28) and answers 410 Gone with the pointer). Public tools need no authentication; account tools authenticate with your API key as a bearer token in the Authorization header.

Tools:
- get_key: Get a FlexYield API key with no signup: public supply, 10,000 weighted units per UTC day, 5 requests/s, every tool. Use it once, when you have no key yet; then send the key as the bearer on every other call. Not for a key you already hold (use what_can_i_do to see where it stands) and not for a human's paid plan (use list_plans). Returns JSON: key (shown once), key_prefix, door (how the key was obtained: public, wallet-bound or owner-adopted), fences (the limits) with doorways (the path past each limit), terms, skill. Creates a key; at most 3 per IP per day. No key needed.
- bind_key_start: Step 1 of binding the API key you are calling with to a wallet: returns the exact SIWE (EIP-4361) message that wallet must sign. Use it when your key came from get_key and you want it to persist across sessions with 1M units/month. Not for claiming an agent you already run on another key (use claim_agent_start) and not for a key that is already bound. Returns JSON: message_to_sign, expires_in_seconds, note. Follow with bind_key_complete before the message expires. Needs your API key.
- bind_key_complete: Step 2 of binding the API key you are calling with to a wallet: pass the wallet's signature over the message from bind_key_start. Use it right after bind_key_start, with the same key. Not for the first step (use bind_key_start) and not for agent claims (use claim_agent_complete). Returns JSON: bound, door (now wallet-bound), key_prefix, bound_address, fences (the limits) with doorways (the path past each), terms, skill. Idempotent for the same wallet. Needs your API key.
- claim_agent_start: Step 1 of claiming an agent by its EVM address for the account you are calling with: returns the exact SIWE message the agent's wallet must sign. Use it when an account owner wants a budgeted key for an agent that proves control of a wallet. Not for binding your own key (use bind_key_start) and not for plain key creation without a wallet (use create_api_key). Returns JSON: address, message_to_sign, expires_in_seconds, note. Follow with claim_agent_complete. Needs your API key.
- claim_agent_complete: Step 2 of claiming an agent: verify the wallet's signature over the message from claim_agent_start and equip the agent with its own budgeted API key (default 50000 requests/month). Use it right after claim_agent_start. Not for the first step and not for changing a budget later (use configure_key). Returns JSON: agent, address, monthly_request_cap, plaintext_token (shown once — store it), note. Creates a key. Needs your API key.
- create_api_key: Create an additional API key on the account you are calling with (a name, optional monthly unit cap). Use it to give a service or a teammate its own key with its own budget. Not for your first key (use get_key, no signup) and not for a wallet-proven agent key (use claim_agent_start). Returns JSON: id, name, monthly_request_cap, prefix, plaintext_token (shown once — store it, it cannot be read again), note. Creates a key; a key obtained from get_key cannot mint further keys. Needs your API key.
- configure_key: Configure one API key of your account by id: monthly_request_cap (a monthly unit budget; omitted = unchanged, 0 = remove the cap), enabled (the list of services it may use: rpc, data, gas, tx_status, ens, prices, contracts, utils) and caps ({service_key: units} per service). Use it to budget or restrict one key; key ids come from list_api_keys. Not for account-wide service settings (use configure_services) and not for revoking (use revoke_api_key). Returns JSON: id, name, monthly_request_cap, note when the budget changed; id, name, window, key_id, services when services changed. Needs your API key.
- revoke_api_key: Revoke one API key of your account by id; calls with that key stop working immediately and the key cannot be restored. Use it when a key leaked or a service is retired; ids come from list_api_keys. Not for pausing a key (set its budget to a small cap with configure_key instead) and not for the key you are calling with unless you hold another. Returns JSON: id, name, revoked_at. Idempotent. Needs your API key.
- rotate_key: Rotate one API key of your account by id: a new secret with the same budget, services, caps and door; the old secret stops working immediately (revoked). Use it after a leak or a quarantine (-32018), or as hygiene. The new plaintext key is returned ONCE — store it. A quarantined key cannot rotate itself: call with another key of the account (or the owner clicks Rotate on the keys page). Not for retiring a key for good (use revoke_api_key) and not for pausing one (use quarantine_key). Returns JSON: id, name, prefix, plaintext_token, rotated_from. Needs your API key.
- quarantine_key: Pause one API key of your account by id (quarantine): every request with it answers -32018 and nothing bills to it, until you rotate it (rotate_key) or release it here with release: true. Use it when a key may have leaked and you want to stop the bleeding before deciding. A quarantined key cannot release itself — call with another key. Not for a new secret (use rotate_key) and not for retiring a key (use revoke_api_key). Returns JSON: id, name, status, quarantined_at, reason. Needs your API key.
- list_api_keys: List the API keys of your account (scope='keys', default) or its agent fleet with wallet claims and budgets (scope='agents'). Use it to find a key id before configure_key or revoke_api_key, or to see which keys are in use. Not for usage numbers (use get_usage) and not for your own key's standing (use what_can_i_do). Returns JSON: count, keys[{id, name, prefix, status, monthly_request_cap, created_at, last_used_at, agent}] for keys; an array of {name, address, claimed_via, claimed_at, key_id, key_prefix, monthly_request_cap, services_off} for agents. Read-only. Needs your API key.
- get_billing_status: Billing state of your account: tier, whether payments are live, the subscription (plan, interval, price in USD cents, status, period end, cancel-at-period-end), the card on file (brand, last4, expiry — never the number), prepaid pack balances, any founding-price reservation and the soft-landing state. Use it before buy_pack or when a call was refused for budget reasons. Not for usage numbers (use get_usage), invoices (use get_statement) or plan prices (use list_plans). Returns JSON: tier, payments_live, billing_customer, subscription, payment_method, founding_reservation, packs, soft_landing. Read-only; plan changes happen in the web console. Needs your API key.
- configure_services: Read or change the account-wide service settings: which gateway services (rpc, data, gas, tx_status, ens, prices, contracts, utils) are enabled and an optional monthly unit cap per service. Use it with no arguments to read; pass enabled and/or caps to change. Not for one key's budget or services (use configure_key). Returns JSON: window, key_id, services[{service, enabled, cap, used}]. A capped service answers error -32014 once month-to-date units reach the cap; a disabled one answers -32012. Needs your API key.
- update_account: Update your account's preferences: notifications (notify_incidents, time_zone) and/or the insights that tailor the service (use_case, team_size, volume, region, previous_provider, referral_source, chains, wish_chains, wish_chain_other). Use it when the owner's preferences change; only the fields you pass change. Not for keys (use configure_key), services (use configure_services) or billing (web console). Returns JSON: notify_usage_80, notify_usage_100, notify_incidents, time_zone after a notification change; insights after an insights change. Needs your API key.
- join_enterprise_wishlist: Send FlexYield an enterprise wishlist: what would need to be true for you to run on FlexYield (chains, SLAs, compliance, features, prices; max 1000 chars) plus a contact email; the founders reply by email. Use it when the public plans do not fit and a human wants to talk. Not for bugs or account questions (use manage_tickets) and not for product ideas from a signed-in account (use manage_feedback). Returns JSON: sent, contact. Creates a record and a mail. No key needed.
- join_waitlist: Join the FlexYield early-access waitlist with an email and a qualifier (developer, investor or curious). Use it only when a human asked to be kept informed; an agent that needs access now should call get_key instead. Not for support (use manage_tickets) or enterprise needs (use join_enterprise_wishlist). Returns JSON: joined, already_on_list. Creates a waitlist entry. No key needed.
- list_plans: List FlexYield's public plans: price in integer USD cents, billing interval, monthly included units and burst rate limits, plus the enterprise line and the signup URL. Use it to compare plans or before telling an owner what an upgrade costs. Not for what a single call costs (use get_quote), your own tier or balances (use get_billing_status) or the break-even at your volume (use what_can_i_do). Returns JSON: plans[{key, name, price_cents, interval, included_units, rate_limit, …}], enterprise, signup_url. Read-only. No key needed.
- get_usage: Your account's usage in one of three views. view='report': requests, weighted units, errors and latency per key, method and chain over a look-back window (hours, default 24; optional chain). view='stats': one console report — report='latency' | 'errors' | 'spend' | 'cache' — for a window ('24h', '7d', '30d'). view='volume': request counts over time (optional chain). Use it to answer 'how much did we use, where, and how fast'. Not for invoices (use get_statement), balances (use get_billing_status) or one key's settings (use list_api_keys). Returns JSON: report → since, total_requests, weighted_units, by_class, cache_hits, success_rate, p50/p95_duration_ms, by_key, by_method, by_chain; stats → window, buckets, series, summary and report-specific totals; volume → window, bucket_seconds, buckets. Read-only. Needs your API key.
- get_statement: Your account's statement for one billing period (default: the current one): invoice facts plus usage grouped by API key or agent, chain and method class — requests, weighted units, cache hits, refusals; period='list' enumerates the periods available. Use it for month-end reconciliation or to show an owner what a period cost. Not for live usage (use get_usage) or the card and subscription (use get_billing_status). Returns JSON: account, period, scope, plan, invoices, totals, at_the_limit, keys, generated_at; for 'list' → scope, periods. An agent's own key sees only that agent's usage; periods follow the subscription cycle or calendar months. Read-only. Needs your API key.
- export_audit_log: Your account's action audit log as a portable, hash-chained document: one entry per tool call, confirmation, signing decision or promotion, oldest first, from since_seq on (exclusive; default the start) — at most limit entries (default 200, max 1000); page on with next_since_seq. Each entry's hash is SHA-256 over its canonical JSON (sorted keys, no whitespace) and carries prev_hash, so the export verifies offline. Arguments are never stored, only their digest. Use it to prove what your keys did, or to archive the log. Not for usage or cost (use get_usage or get_statement). Returns JSON: format, account, scope, since_seq, exported_at, entries (account_id, seq, kind, actor_type, actor_id, subject_type, subject_id, tool_name, effect, args_digest, outcome, outcome_code, occurred_at, prev_hash, hash), next_since_seq. An agent's own key sees only its own entries (scope 'actor'). Read-only. Needs your API key.
- export_mandate: Your key's mandate of record as one signed document: what this key may do (cap in cents, allowed chains, RPC methods and tools, denylist, action types, rate and daily fences, covered keys, expiry) and its receipts over the last window_days (default 7, max 90) with a per-receipt verdict inside, outside or no_mandate. Signed as a W3C VC 2.0 compact JWS (EdDSA, Ed25519); verify it offline against the keys at https://flexyield.io/.well-known/flexyield. mandate_hash is sha256 over the JWS bytes. It states authority only, never ownership or identity. Use it to show a door, a holder or your owner what this key may do and what it did; a door key not yet adopted also gets its claim code to bring to its owner. Not for usage reports (use get_usage) or the action log (use export_audit_log). Returns JSON: format, version, jws, mandate_hash, payload (format json; omitted for format jws), verify (keys, spec), claim (door keys only). Read-only. Needs your API key; covers that key only.
- get_project: Read one of your account's project manifests by slug or id — chains, contracts (address, ABI ref, verified source), API keys + budgets, signers + policies, dependencies (oracles, bridges, sequencers, RPC vendors), monitors, runbooks, status page — with its version and recent version history; call it without arguments to list every project. Use it before acting on a project, to learn what it runs on and which keys and signers belong to it. Not for the project.yml file (use export_project) and not for changing a manifest (use update_project). Returns JSON: id, slug, name, version, updated_at, manifest, versions; without arguments → projects, count. Read-only. Needs your API key; an agent's own key may read.
- update_project: Create or replace one of your account's project manifests: pass the slug and the WHOLE manifest as a JSON or YAML string with any of the sections chains, contracts, keys, signers, dependencies, monitors, runbooks, status_page. The manifest is validated (unknown keys, unknown chains, addresses that do not fit the chain, API key ids of another account are refused with code manifest_invalid and the path of each error); a valid change becomes a new version with your note, an identical manifest writes nothing. A new slug creates the project at version 1. Use it to record what a project runs on. Not for a full project.yml file with its header (use import_project) and not for reading (use get_project). Returns JSON: id, slug, name, version, updated_at, manifest, versions, changed, created. Needs your API key — the account owner's; an agent's own key is refused (owner_key_required).
- export_project: Export one of your account's projects as project.yml: a header (flexyield_manifest: 1, project slug and name, version, exported_at) and the canonical manifest. Two exports of the same version differ only in exported_at, so the file diffs cleanly in a repository. Use it to keep the manifest next to your code or to move it to another tool. Not for reading the manifest as JSON (use get_project). Returns JSON: slug, version, filename, content_type, yaml (the file's text). Read-only. Needs your API key; an agent's own key may export.
- import_project: Import a project.yml (the text export_project returns, or the same document as JSON) into your account: the header's project slug picks the project — created at version 1 when new, a new version when the manifest differs, nothing written when it is identical. The header must say flexyield_manifest: 1; the manifest is validated like update_project (code manifest_invalid with the path of each error). Use it to apply a manifest kept in a repository. Not for a bare manifest without the header (use update_project). Returns JSON: id, slug, name, version, updated_at, manifest, versions, changed, created. Needs your API key — the account owner's; an agent's own key is refused (owner_key_required).
- watch_dependency: Add a dependency to one of your account's projects and get its first measured reading back. Kinds: oracle (Chainlink price feed: fresh or stale against its heartbeat), sequencer (Chainlink L2 sequencer uptime feed: up or down; Arbitrum One, OP Mainnet and Base need only the chain id), bridge (liveness from the contract's newest event in about the last hour of blocks), rpc_vendor (FlexYield's RPC supply on one chain, from its own probes; identifier = the chain, e.g. base_mainnet or eip155:8453), other (recorded, not read). Identifier otherwise: eip155:<chain id>:<address>, optionally ?heartbeat=<seconds> or ?window=<blocks>. Use it to have a project's monitors follow what it relies on: readings every 10 minutes, a stale or down reading opens an alert, the next ok one closes it. Not for reading the current state (use get_dependencies). Returns JSON: project, dependency, reading (status ok|stale|down|unknown|unsupported, read_at, summary, value), version, changed. Needs your API key — the account owner's; an agent's own key is refused (owner_key_required).
- get_dependencies: Read the measured state of one project's dependencies: for each oracle, sequencer, bridge and RPC vendor in the manifest, its latest reading (status ok|stale|down|unknown|unsupported, read_at, age_s, summary, the measured values) and its open alert, plus every open alert. Readings are taken every 10 minutes. Use it to check what a project depends on before acting, or after an incident. Not for adding a dependency (use watch_dependency) and not for the whole manifest (use get_project). Returns JSON: project, interval_s, dependencies, open_alerts. Read-only, no charge. Needs your API key; an agent's own key may read.
- get_project_status: Read one project's status as measured: for each dependency in its manifest the status (ok|stale|down|unknown|unsupported), chain, last reading time and age, a one-line detail and the measured values; the open alerts (since, dependency, what the reading showed); and an overall line where the worst status wins. Readings are taken every 10 minutes; a dependency not read for 30 minutes shows unknown. Works whether or not the project's public status page is published; publication says if it is and at which path. Use it for a one-call health check of what a project relies on. Not for adding a dependency (use watch_dependency) and not for the raw readings (use get_dependencies). Returns JSON: format, project, publication, generated_at, interval_s, overall, dependencies, open_alerts. Read-only, no charge. Needs your API key; an agent's own key may read.
- watch_action: Have FlexYield confirm that an action reported as done (by you, your agent or a job) actually landed on chain, with an alert when it did not. Kinds: tx (tx_hash is mined with status 0x1; a reverted receipt counts as missed), event (the contract at address emits a log matching topics and/or signature, e.g. Transfer(address,address,uint256), from since_block on), state (eth_call to + data returns expected_result). Give a deadline: deadline_seconds and/or deadline_blocks (whichever passes first, up to 7 days). EVM chains only. Read every 2 minutes; past the deadline with nothing landed the action settles missed, opens an alert and is recorded in the audit log. Read-only: nothing is ever signed or sent. Use it right after an agent reports a transaction, keeper run or scheduled job as done. Not for sending (use rpc_call) or listing (use get_watched_actions). Returns JSON: watched_action (id, kind, chain, spec, deadline_at, deadline_block, status landed|missed|pending|unknown, evidence, alert), settled. At most 100 unsettled per account. Needs your API key; an agent's own key may register.
- get_watched_actions: Read the actions the Keeper watchdog is confirming for your account: each one's kind (tx, event, state), chain, spec, deadline, status (pending | landed | missed | unknown | cancelled), evidence (block number, receipt status, log index, the value read, or why it could not be read) and its alert, plus every open alert ("reported success, nothing landed"). Filter by project slug and status. Use it to check whether what an agent reported as done is on chain, or to review missed actions. Not for adding one (use watch_action). Returns JSON: interval_s, project, watched_actions, open_alerts. Read-only, no charge. Needs your API key; an agent's own key may read.
- cancel_watched_action: Stop the Keeper watchdog from confirming one watched action, or acknowledge a missed one. A pending or unknown action becomes cancelled (no alert, no further reads); a missed action stays missed and its open alert is closed as acknowledged. Use it when the action was withdrawn on purpose, or after you handled the miss. Not for reading (use get_watched_actions). Returns JSON: watched_action. Landed or already settled actions answer watched_action_settled. Needs your API key — the account owner's; an agent's own key is refused (owner_key_required), so an agent cannot hide its own missed action.
- subscribe_events: Register an https endpoint (public address) for this account's events as signed JSON POSTs, or update one by url: kinds, enabled, rotate_secret. Kinds: dependency.alert.opened, dependency.alert.closed, key.quarantined, key.rotated, session.promoted, audit.refused, supply.demotion, test.ping. Chain sources: chain_source event (chain, address, signature e.g. Transfer(address,address,uint256) and/or topics) → chain.event; chain_source block (chain, every_blocks) → chain.block; both wait for confirmations, a reorg re-sends the orphan as removed: true; 10 per endpoint, 50 per account; remove_chain_source_ids removes. Deliveries are signed, carry X-FlexYield-Event-Id to dedupe on, retry 1 m to 8 h and are kept 7 days (replay_deliveries). Use it instead of polling for alerts or contract events. Not for reading deliveries (use list_subscriptions) or testing (use send_test_event). Returns JSON: endpoint, secret (shown ONCE, on create or rotate), created, chain_source, removed_chain_sources, signing. Needs your API key — the owner's; an agent's own key is refused (owner_key_required).
- list_subscriptions: List this account's webhook endpoints (url, kinds, status enabled|paused|disabled with the reason, failure_count), its on-chain sources (kind event|block, chain, address, topics, every_blocks, confirmations, cursor — the last block scanned —, last_block and last_delivered_at) and the most recent deliveries, newest first: kind, event_id, attempt, status pending|delivered|failed|dead, response_code, error, next_attempt_at, delivered_at. Use it to see whether events reach your endpoint, how far a chain source has read, why an endpoint was disabled, or which deliveries to replay. Not for registering an endpoint or a chain source (use subscribe_events) and not for re-sending (use replay_deliveries). The signing secret is never listed. Returns JSON: endpoints, chain_sources, deliveries, kinds, chain (chain kinds, limits, default confirmations and minimum every_blocks per chain). Read-only, no charge. Needs your API key; an agent's own key may read.
- send_test_event: Send a test.ping event to your enabled webhook endpoints (or only endpoint_id) — signed, retried and logged exactly like a real event, whatever kinds the endpoint subscribed to. Use it right after subscribe_events to check that your receiver verifies the signature and answers 2xx. Not for re-sending real events (use replay_deliveries) and not for reading results (use list_subscriptions a few seconds later). Returns JSON: event_id, deliveries (one per endpoint), next_step. Needs your API key — the account owner's; an agent's own key is refused (owner_key_required).
- replay_deliveries: Re-send the webhook deliveries of a time window to your enabled endpoints: since (ISO 8601, at most 7 days back — deliveries are kept 7 days), until (default now), optionally one endpoint_id; at most 1,000 per call, oldest first. Each goes out again from attempt 1 with its ORIGINAL event id, so a receiver that already has it can drop it. Use it after your receiver was down or rejected events. Not for new events (they are pushed as they happen) and not for testing (use send_test_event). Returns JSON: replayed, truncated, next_since (call again from there when truncated). Needs your API key — the account owner's; an agent's own key is refused (owner_key_required).
- manage_tickets: Your support tickets with FlexYield. action='create' (subject, message, optional request_id of the failing call, optional category) opens a ticket with the call's evidence attached; action='list' (optional status); action='get' (reference); action='reply' (reference, message, optional resolve/reopen). Use it when a call was refused or failed and the doorway said to file it, or to follow up. Not for reading what an error code means (use explain_error first) and not for product ideas (use manage_feedback). Returns JSON: create/reply → reference, subject, status, category, priority, channel, created_at, last_activity_at, url; list → tickets; get → the same plus messages, evidence, suggested_paths. Needs your API key.
- manage_feedback: Product feedback to FlexYield. action='submit' (kind: 'feature' | 'chain' | 'praise' | 'complaint' | 'other', title, optional body, optional chain) files it and we answer on the feedback page; action='list' (optional status) shows what you filed and our replies. Use it for ideas, a chain you want added, or praise and complaints that need no fix on your account. Not for a failing call or a refusal (use manage_tickets, it carries the evidence) and not for enterprise terms (use join_enterprise_wishlist). Returns JSON: submit → id, kind, title, chain, status, reply, created_at; list → feedback. Needs your API key.
- get_balances: Native balance and ERC-20 token balances of an address on one chain (eth_mainnet, base_mainnet, arbitrum_one, optimism_mainnet, polygon_pos, solana_mainnet; tokens where a data-capable upstream exists). Use it for a portfolio or a pre-flight funds check. Not for transfer history (use get_history) and not for a raw eth_getBalance you want to shape yourself (use rpc_call). Returns JSON: chain, address, native, tokens, tokens_note. Read-only; costs 10 weighted units, metered on your key. Needs your API key.
- get_history: Recent asset transfers (sent and received, newest first) of an address on one EVM chain with a data-capable upstream. Use it to answer 'what moved in or out of this address lately'. Not for current balances (use get_balances), one transaction's state (use get_tx_status) or Solana. Returns JSON: chain, address, transfers[]. Read-only; costs 10 weighted units, metered on your key. Needs your API key.
- get_prices: Prices. kind='gas' (chain): EIP-1559 gas recommendations (slow/standard/fast) computed from our pool on an EVM chain, 1 weighted unit. kind='token' (symbols, comma-separated e.g. 'ETH,USDC'): current token prices in USD. Use it before sending a transaction (gas) or to value a balance (token). Not for what a FlexYield call costs in units (use get_quote) and not for plan prices (use list_plans). Returns JSON: gas → chain, base_fee_per_gas, recommendations, computed_from, computed_at, unit_weight; token → prices, quote, source, checked_at. Read-only. Needs your API key.
- get_tx_status: Status of one transaction hash on any supported chain: confirmed, failed, pending or unknown, with confirmations and gas on EVM chains or slot and commitment on Solana. Use it to poll a transaction you sent or were told about. Not for an address's transfers (use get_history) and not for decoding what the transaction did (use decode_calldata). Returns JSON: chain, hash, status, checked_at, unit_weight, plus block_number, confirmations, gas_used, effective_gas_price_wei (EVM) or slot, confirmation_status (Solana). Read-only; metered on your key. Needs your API key.
- resolve_ens: ENS resolution on Ethereum mainnet: pass a name ('vitalik.eth') to get its address, or an address (0x…) to get its reverse-record name, read on-chain through our pool. Use it whenever a user gives you a .eth name instead of an address. Not for other name systems and not for balances (use get_balances with the resolved address). Returns JSON: forward → name, address, resolved, checked_at; reverse → address, name, resolved, note, checked_at. Reverse records are self-declared — forward-resolve the name before trusting it. Read-only. Needs your API key.
- get_abi: The verified ABI of a contract (with its name and match level) from Sourcify's open dataset on eth_mainnet, base_mainnet, arbitrum_one, optimism_mainnet or polygon_pos. Use it before calling or decoding a contract you do not have the ABI for. Not for decoding a specific calldata blob (use decode_calldata, it fetches the ABI itself) and not for a function selector (use convert_evm). Returns JSON: chain, address, verified, name, match, abi, source; an unverified contract returns verified=false with a note on how to verify it. Read-only. Needs your API key.
- decode_calldata: Decode a transaction's calldata against the target contract's verified ABI (Sourcify): the function signature, its selector and the argument values (static types decoded; dynamic types shown raw and labelled). Use it to explain what a pending or past transaction does. Not for the whole ABI (use get_abi), a transaction's status (use get_tx_status) or computing a selector from a signature (use convert_evm). Returns JSON: chain, address, function, selector, args, source. Read-only. Needs your API key.
- convert_evm: Offline EVM utilities, no chain call: op='checksum' (EIP-55 checksum and validity of input=address), op='convert' (unit conversion wei…gwei…eth: input=value, from=unit, to=unit), op='selector' (4-byte selector and topic0 of input=function signature) and op='keccak' (keccak256 of input text). Use it for address hygiene and unit maths before an rpc_call. Not for verifying a signature (use verify_signature) or decoding calldata (use decode_calldata). Returns JSON: checksum → valid_address, checksummed; convert → value, from, to, result; selector → signature, selector, topic0; keccak → input, keccak256. Read-only, deterministic. Needs your API key.
- verify_signature: Verify a signature offline: mode='personal' checks an EIP-191 personal_sign signature (message, 65-byte 0x signature, optional expected address); mode='siwe' checks a SIWE / EIP-4361 message (the exact signed text plus signature — parses the fields, checks signature and expiry; domain and nonce policy stay with you). Use it to authenticate a wallet-holder or validate a login message. Not for binding or claiming keys on FlexYield (use bind_key_complete / claim_agent_complete, they verify themselves) and not for hashing (use convert_evm). Returns JSON: personal → recovered_address, valid, expected_address; siwe → valid, recovered_address, expired, fields, note. Recovery only — FlexYield never holds keys. Read-only. Needs your API key.
- what_can_i_do: The status overview of the API key you are calling with: its door (how it was obtained: public via get_key, wallet-bound, or adopted by a paying owner), its tier, the budgets left (month, day, prepaid packs), the fences (its limits) each with a doorway (the path past that limit: bind, adopt, buy a pack, or a ticket), your last-30-day volume priced on every lane (a lane = a price tier: cheap, balanced, fast), the break-even sentence (the volume at which a paid plan beats pay-per-call, for your owner), the account features and the other doors. Use it first in a session, and whenever a call was refused, to decide what to do next. Not for detailed usage (use get_usage), billing facts (use get_billing_status) or a single call's price (use get_quote). Returns JSON: you, budgets, fences_as_doorways, volume_30d_units, ladder_at_your_volume, break_even, recommendation, active_advice, account_features, doors, pricing. Read-only; no parameters. Needs your API key.
- get_quote: Quote one JSON-RPC call before making it: the weighted units it costs (standard 1, heavy 2, or not offered) and the USD per 1M units on every lane (a lane = a price tier: cheap, balanced, fast). Use it when an owner asks what a workload would cost or before a heavy method. Not for gas or token prices (use get_prices), plan prices (use list_plans) or your own balances (use get_billing_status). Returns JSON: chain, method, offered, units, tier, multiplier, lanes, note; a method we do not offer returns offered=false with a reason. Read-only. No key needed.
- explain_error: Explain a FlexYield error code (e.g. -32007): what it means, the steps to take and its doorway (the path past the limit that caused it). Use it whenever a call returned an error with a code you do not know, before retrying or filing a ticket. Not for upstream chain errors that are not ours and not for filing the problem (use manage_tickets with the request_id). Returns JSON: code, http, title, meaning, steps, doorway, decoder; an unknown code returns known=false with a hint. Read-only. No key needed.
- recommend: A recommendation from our live measurements. what='chain': which chain fits a task (optional family, candidates, prefer), ranked from our probes and method rules. what='route': which lane (price tier: cheap, balanced, fast) to use for one call (chain, method, optional need). Use it when you can choose the chain or the lane and want the measured answer. Not for the price itself (use get_quote), current gas (use get_prices) or making the call (use rpc_call). Returns JSON: chain → pick, reason, ranked, measured_at, note; route → chain, method, offered, units, weight_class, pick, reason, tiers, note. Read-only. No key needed.
- migrate: A switching report for moving your RPC traffic to FlexYield: paste your current config as text (endpoint URLs, env lines, code) and get every endpoint mapped to our chain URL, every method you name with its unit weight and limits, and what changes. Add your usage export (calls per method) and it estimates a month here in dollars on every lane, against your current invoice if you name it. With repoint true it also returns your endpoints rewritten to our URLs. Use it before you swap URLs, or to see what the switch saves. Not for a priced estimate of one call (use quote) or for making calls (use rpc_call). Keys in the pasted text are masked and nothing is stored. Returns JSON: ready, summary, endpoints (source, chain, served, replacement, key_in_url, note), methods (name, weight, offered, note), changes (what, before, after), next_steps; with usage: estimate (period_days, monthly_calls, monthly_units, methods, unpriced, recommended, lanes, invoice_usd, saving_usd); with repoint: repoint (edits, auth, kept). No key needed.
- buy_pack: Start the purchase of a prepaid unit pack (size 's': 1.2M units $10, 'm': 7M $50, 'l': 32M $200, +5 % units when bought here) and get a checkout URL the account owner completes on a card; units become available when the payment lands, are consumed after the plan's monthly quota and stay valid 12 months. Use it when what_can_i_do or a refusal says the monthly budget is running out. Not for changing the plan (web console) and not for reading balances (use get_billing_status). Returns JSON: checkout_url, size, units, bonus_units, total_units, price_usd, note. Creates a checkout; no money moves until a human pays. Needs your API key.
- rpc_call: Send one JSON-RPC call through the FlexYield gateway — the same routing, failover, cache and meter as POST /rpc/{chain}. chain: 'eth_mainnet' | 'base_mainnet' | 'arbitrum_one' | 'optimism_mainnet' | 'polygon_pos' | 'solana_mainnet'; method e.g. 'eth_blockNumber'; params as the method expects. Use it for any read the shaped tools do not cover (blocks, logs, eth_call, storage) and for sending signed transactions. Not for balances, transfers or transaction status when a shaped tool exists (use get_balances, get_history, get_tx_status — one call, decoded) and not for pricing a call first (use get_quote). Returns JSON: the raw JSON-RPC body — jsonrpc, id, result — or jsonrpc, id, error with our request_id and the doorway in error.data when refused. Metered on your key (standard 1 unit, heavy 2; cache hits 0). Needs your API key.
- configure_session: Pin this API key's session before acting on chains: declare intent 'testnet' or 'mainnet', optionally one chain (a slug like 'base_sepolia' or 'eip155:84532'), and dry_run (default true). From then on every tool call with a chain argument that disagrees — another chain than the pinned one, a mainnet under a testnet intent — is refused with a typed error before it reaches the gateway, and chain writes (rpc_call with a send method) answer their planned outcome instead of sending until you call promote. Calling it again replaces the session and ends any promotion; reset: true removes it. Use it first in any agent run that touches a chain. Not for key budgets or services (use configure_key). Returns JSON: session (chain, intent, dry_run, live, promoted, live_until), next_step. Needs your API key.
- promote: Switch this API key's session from dry run to live for a few minutes so chain writes (rpc_call with a send method) are really sent: minutes 1–60 (0 ends the live window now), with an optional reason. Every promotion is written to your audit log as its own 'promotion' entry, and each live write inside the window records that it was promoted. Needs a session first (configure_session). Use it only at the moment you mean to send, for as few minutes as the send needs. Not for raising budgets (use configure_key). Returns JSON: session (chain, intent, dry_run, live, promoted, live_until), audit_seq, next_step. Needs your API key.
- resolve_address: Whether a contract's source is verified, under which contract name, and where its ABI and sources are — with provenance (source sourcify, match full | partial | none, fetched_at). EVM chains: eth_mainnet, base_mainnet, arbitrum_one, optimism_mainnet, polygon_pos and their testnets (or eip155:<id>). Pass project (a slug) to record the result in that project's manifest contracts (the account owner's key only). An unverified contract answers verified=false — treat it as unknown code. Use it before you call or sign against a contract. Not for the ABI itself (use get_abi) and not for ENS names (use resolve_ens). Returns JSON: verified, name, abi_ref, source_url, provenance (source, match, fetched_at), chain, address; with project also project (slug, version, changed). Cached for a day. Needs your API key.
- check_report: Check a run summary against the audit log before you report it: pass the summary text and a window (window_hours, default 24, max 168). The claims in it — tool names with their call counts, chains, 'sent' and 'signed' — are compared with what this API key's audit-log entries recorded in the window (dry runs are not sends). Rule-based, no model. Use it as the last step of an agent run, or to audit a report you were given. Not for exporting the log (use export_audit_log). Returns JSON: verdict honest | overclaims | underclaims | unverifiable, claimed, recorded, differences (kind, about, claimed, recorded, note), unverifiable. Read-only. Needs your API key.
- start_run: Start recording an agent run on this API key: label (what the run is for, up to 120 characters) and optionally project (a project slug). Until finish_run — or 24 hours, or the next start_run, which closes the open run first — every tool call this key makes is one step of the run: the tool, a digest and a scrubbed copy of the arguments (secrets are never stored), a digest and excerpt of the answer, the outcome and the signing decision (dry_run, promoted, live, refused). Use it at the start of an agent run you may want to review or replay. Not for the audit log itself (every call is in it anyway; use export_audit_log). Returns JSON: run (id, label, project, status, started_at, expires_at), superseded_run_id, next_step. Needs your API key.
- finish_run: Finish this API key's open run (started with start_run): recording stops and the run gets its trace digest — SHA-256 over its steps in order (tool, arguments digest, answer digest, outcome, signing decision), the same for two runs that made the same calls and got the same answers. Use it as the last step of a recorded agent run, before replay_run or check_report. Not for reading a run's steps (use get_run). Returns JSON: run (id, label, project, status, started_at, finished_at, trace_digest), summary (steps, tools, outcomes, signing_decisions, duration_s), next_step. Needs your API key.
- get_run: Read one recorded run and its steps: run_id (default this key's newest run), after_seq to page on (exclusive) and limit (default 50, max 200). Each step carries seq, tool_name, effect, args_digest, args (a scrubbed copy — secrets are never stored), response_digest, response_excerpt (scrubbed, at most 2 KB), outcome, outcome_code, signing_decision and the audit_seq of its audit-log entry. Use it to review what an agent run did, step by step. Not for re-running it (use replay_run) and not for the whole account history (use export_audit_log). Returns JSON: run (id, label, project, status, replayed_from, replay_target, replay_verdict, started_at, finished_at, trace_digest), steps, next_after_seq. An agent's key sees only its own runs. Read-only. Needs your API key.
- replay_run: Replay a finished recorded run and compare: run_id, target 'dry' (default) or 'fork'. On 'dry' each recorded call (the first 200 steps) runs again through the normal tool path with this key: reads run live and are metered as usual, every chain write answers its planned outcome (nothing is sent), and calls that changed account state are skipped. Each step is same, differs (with both answer digests) or skipped with a reason; the replay is recorded as a run of its own. 'fork' replays against a chain fork and is not available yet (typed error fork_unavailable). Use it to check that a scenario still behaves as recorded. Not for reading a run (use get_run). Returns JSON: verdict same | differs | inconclusive, target, run_id, replay_run_id, both trace digests, steps_total, steps_replayed, truncated, counts, steps (seq, tool_name, result, reason, replay_seq, diff). Needs your API key.
- publish_recipe: Publish a finished recorded run (start_run … finish_run) as a public recipe at /recipes/<slug>: your title, what it does in plain text and an author handle (default the account name), with the run's steps — tool, arguments as recorded (scrubbed when recorded and again on the page), result in one line — and the receipts FlexYield signed for the run's key within the run's window. The slug is made once; calling again for the same run edits the title, summary and handle or republishes it. At most 20 published recipes per account; unpublish in console › Runs. The re-run check reads not_checked until fork re-runs exist. Use it to share a repeatable agent run with its evidence. Not for reading a run (use get_run) or re-running one (use replay_run). Returns JSON: url, recipe (format flexyield-recipe/1: title, slug, summary, author, chains, steps, receipts, signed_receipts, recheck). Needs your API key — the owner's; an agent's own key is refused (owner_key_required).
- explain_tx: Explain a transaction hash, an address or an error in plain English with the decoded evidence: every sentence cites the fields it came from, and what cannot be decoded is listed under unknowns, never guessed. Pass an EVM chain and exactly one of hash, address or error. A hash: status, block, time, sender, recipient (Sourcify-verified name), value, the decoded call and logs (verified ABI, or the standard ERC-20 Transfer/Approval and ERC-721 Transfer), gas and fee in native units (L1 data fee on Base and OP Mainnet), the revert reason. An address: contract or account, verified name, balance, nonce, an ERC-20 name, symbol and decimals. An error: FlexYield and JSON-RPC codes, revert data, Solidity panic codes, common revert strings. Use it before acting on a transaction, contract or error you do not understand. Not for polling a pending transaction (get_tx_status) or simulating a call (simulate_call). Returns JSON: kind, summary, evidence, decoded, provenance, unknowns. Read-only; metered on your key (at most 4 relay calls per hash, 6 per address, none per error). Needs your API key.
- simulate_call: Simulate an EVM call before you send it and explain the outcome in plain English: every sentence cites its source (call result, gas estimate, trace) and states it is a simulation at a block, not a receipt. Pass a chain and either to (+ data, from, value in wei, block; default latest) or the hash of a transaction sent but not yet mined. Runs eth_call (return value decoded against the verified ABI from Sourcify; a revert decoded as Error(string), Solidity panic code or custom error), eth_estimateGas (skipped when the call reverts) and debug_traceCall (call tree, inner value transfers, the reverting inner call); where the serving supply offers no trace, the answer says so and the other results stand. Use it before sending a transaction or calling a contract you are unsure about. Not for sending (it signs and sends nothing) or for a mined transaction (explain_tx). Returns JSON: kind, summary, evidence, decoded, provenance, unknowns. Read-only; metered on your key (at most 3 relay calls per call, 5 per pending hash; the trace is heavy). Calldata up to 32,768 bytes. Needs your API key.
- decode_payload: Decode what a wallet asks you to sign, before anyone signs it: a raw transaction (legacy, EIP-1559 and other typed envelopes, EIP-7702 authorizations), calldata (Safe execTransaction with its inner call and operation, nested MultiSend batches, any call) or EIP-712 typed data (SafeTx, Permit, Permit2; any other type field by field). Every call carries its contract (Sourcify-verified name, or unverified with the raw selector and data), function, arguments and value moved, and the flags "delegatecall to <address>", "unlimited approval", "changes the owner / implementation" and "sends value to an address not in your intent". Pass intent in plain words ("send 100 USDC to 0x…") for one line per point where the payload differs; an intent it cannot read gets no line. Use it before you sign or co-sign a payload you did not build. Not for a mined transaction (explain_tx) or a call's outcome (simulate_call); it signs and sends nothing. Returns JSON: input, calls, control, flags, mismatches, unknowns, provenance. Read-only, no charge; payload up to 128 KB. Needs your API key.
- get_prices_table: The dollar table: every method's price per million weighted units on every lane, with the date of the last change. Same source as quote and /pricing. Use it to compare lanes before you pick one, or to see what a method costs where you are. Not for a priced estimate of one call (use quote) or for this key's own spending (use forecast_spend). Returns JSON: as_of, tier, currency, lanes (lane, rung, usd_per_m_units) and rows per method (units, usd_per_m_units and usd_per_m_calls per lane, last_change_at). No key needed.
- forecast_spend: This key's spend forecast for the next 30 days from its own last 30 days, in dollars, with the pace it rests on. Use it to see where the month is heading before a cap or a plan change. Not for what was already billed (use get_usage or get_statement) or for prices (use get_prices_table). Returns JSON: forecast_usd, forecast_units, pace_units_per_day, window_days_observed, lane, usd_per_m_units, basis, confidence (normal or low), as_of. Needs your API key.
- suggest_ideas: Three questions in, three ideas out, each with a recipe or a build request. "No chain needed" is a valid answer and is given when it is true. Use it when you know your business but not what a chain could do for it. Not for running anything on chain (it only proposes) or for prices (use get_prices_table). Returns JSON: questions, or ideas (title, need, difficulty, cost_per_month_usd, recipe_slug or build_request, legal_note). No key needed.
- get_verdicts: Read the verdicts FlexYield's on-call watch wrote for your account, newest first: one per signal — a lane demotion on a chain one of your projects lists, a paused key (usage burst, public-repository match or a manual pause), a day's units far above the average of the 7 days before, or requests refused at the rate limit. Each verdict has a kind (resolved | fyi | escalate), a severity (info | low | medium | high), a proposed action as a label (none | switch_lane | rotate_key | review_spend | review_limits — nothing is executed), 3–5 lines with the measured numbers and links to your console pages. Rule-based; signals are read every 2 minutes, statement units once a day. Use it to see what changed on your account and what needs a human. Not for the full action log (use export_audit_log) or usage numbers (use get_usage). Returns JSON: verdicts (id, kind, severity, signal_class, proposed_action, created_at, lines, evidence). Read-only, no charge. Needs your API key; an agent's own key reads only the verdicts about that key.
- plan: Compose a plan: a numbered list of typed tool calls for one request. Pass request (one sentence, up to 2,000 characters), or playbook (a playbook key) with slots ({name: value}). Fixed rules match the request against a catalogue of playbooks; no model reads it, it is never returned, and only its digest and a scrubbed excerpt of at most 200 characters are kept for the owner's receipt page. One of three answers: plan (stored for 30 minutes, nothing executed), needs (the questions still open; answer them in slots) or no_plan with the nearest playbooks. A plan holds no chain write. Use it to turn a task into steps you can read before anything runs. Not for running the steps (use confirm), for what each step does (use explain_plan) or for billing plans (use list_plans). Returns JSON: plan (id, digest, status, playbook, created_at, expires_at, steps: position, tool, arguments, effect), or needs (slot, question) with playbook, or no_plan with nearest (key, title, slots); next_step. Needs your API key.
- explain_plan: Explain a stored plan step by step: plan_id. Per step: what the tool does, its effect (read, simulate or write), whether it is metered, and — for an agent's own key — whether that key may run it; plus what confirm will and will not do. Every line is a fixed template and nothing is executed. Use it before confirm, to read what a plan would do under this key. Not for composing a plan (use plan) or running it (use confirm). Returns JSON: plan (id, digest, status, playbook, created_at, expires_at, confirmed_at, finished_at), steps (position, tool, arguments, effect, does, effect_line, units_line, key_line, outcome, outcome_code), limits. A plan of another account is not found. Read-only. Needs your API key.
- confirm: Run a stored plan once: plan_id and the digest plan returned. It executes exactly the stored steps, in order, through the normal tool path under the calling key's own budgets, fences and rate limits; each step leaves its own audit entry and the plan one confirmation entry. The first refused or failed step stops the plan: later steps do not run and nothing is rolled back. Refused when the digest differs, the plan was already confirmed, it expired (30 minutes) or it belongs to another account. Use it after explain_plan, when the steps are what you mean to run. Not for composing a plan (use plan) and not for chain writes (a plan holds none; use rpc_call). Returns JSON: receipt (plan_id, digest, status finished or stopped, playbook, confirmed_at, finished_at, steps_total, steps_run, stopped_at, steps: position, tool, effect, ran, outcome, outcome_code, excerpt, audit_seq), receipt_path. Needs your API key.

Resources:
- flexyield://plans: FlexYield subscription plans: prices in integer USD cents, billing interval, and rate limits.
- flexyield://getting-started: How to go from zero to a relayed JSON-RPC request on FlexYield.
- flexyield://reliability: Measured per-chain gateway reliability: uptime over 24h/7d/30d windows and latency percentiles (last 24h), from synthetic probes every 5 minutes.

## Pages

- Home: https://v2.flexyield.io/
- Docs (API reference): https://v2.flexyield.io/docs
- Integration guides (viem, ethers, web3.py, Solana web3.js, LangChain, CrewAI, OpenAI Agents SDK, MCP): https://flexyield.io/docs/guides
- Methods and limits (per-method weight, cache class, limit, doorway): https://flexyield.io/docs/methods
- Error decoder (every gateway error code, meaning, what to do, exact body): https://flexyield.io/docs/errors
- Chain pages (measured uptime/latency, methods per dialect): https://flexyield.io/chains
- Signed requests to FlexYield's doors: https://flexyield.io/spec/request-signing (JSON: https://flexyield.io/spec/request-signing.json)
- The FlexYield mandate and receipts document: https://flexyield.io/spec/mandate (JSON: https://flexyield.io/spec/mandate.json)
- Pricing: https://v2.flexyield.io/pricing
- Status (measured per-chain uptime and latency): https://v2.flexyield.io/status
- /decode — decode a signing payload: calls, flags, mismatch against your intent (free, nothing stored)
- /explain/<chain>/<hash> — a transaction explained with its evidence (free, embeddable, .json twin)
- /recipes — recorded agent runs published with their receipts
- /ideas — what you could build: ideas composed from FlexYield's tools, with cost, difficulty and a recipe when one exists
- Sign up: https://v2.flexyield.io/registration/new