# Mercatura (remote · mercatura.network) Claim a $10 Vlad account for an AI agent and open factor accounts on Robinhood Chain. - Trust score: 0/100 (low) - Change this week: −62 - Registry status: deprecated - Liveness: dead - Owner verified: no - Last scored: 2026-11-03 > **Deprecated**: this server is marked deprecated in the MCP registry. The registry records this reason: "Mercatura has closed and this server is offline." > **Dead**: every channel of this server has been unreachable for long enough to be marked dead. Its trust score is pinned to 0 and does not recover automatically. ## Components - remote · `mercatura.network`: 0/100 (this document), [markdown](https://verifymcp.io/servers/network-mercatura-mercatura/mercatura.md), [page](https://verifymcp.io/servers/network-mercatura-mercatura/mercatura) ## Channel facts - Endpoint: `https://mercatura.network/mcp` - Transports: `streamable-http` - Auth: `none` - Version: `1.7.0` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-03. - **Endpoint Security**: 11/100 - TLS not yet verified: we couldn't open a connection to check the certificate. - Authorisation not yet verified: we couldn't confirm whether this endpoint requires it. - HTTPS is enforced; there's no plaintext access path. - HSTS not yet verified: we couldn't read the response headers to check for it. - DNSSEC not yet verified: we couldn't validate it against a resolver. - **Transport & Reachability**: 0/100 - Transport check failed: declared streamable-http, but we couldn't connect to verify it. - **Schema Quality & AI Usability**: 0/100 - Schema not yet verified: we couldn't read the endpoint's schema, or could read only part of its tool list. - **Stability & Change Management**: 0/100 - Stability not yet verified: not enough scan history yet (needs a 30-day window). - **Tool Coverage**: 0/100 - Tool coverage not yet verified: we couldn't read the endpoint's tools, or could read only part of the list. - **Tool Safety**: 0/100 - Tool safety not yet verified: we couldn't read the endpoint's tools, or could read only part of the list. - **Capabilities**: 0/100 - Capabilities not yet verified: we couldn't read the endpoint's capabilities. **Unverified: 5 categories.** Categories scored 0 because we could not verify them: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm. ## Install ### How do I install the Mercatura MCP server? Mercatura is a hosted endpoint at https://mercatura.network/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http network-mercatura-mercatura 'https://mercatura.network/mcp' ``` ### Cursor ```json { "mcpServers": { "network-mercatura-mercatura": { "url": "https://mercatura.network/mcp" } } } ``` ### VS Code ```json { "servers": { "network-mercatura-mercatura": { "type": "http", "url": "https://mercatura.network/mcp" } } } ``` ### Codex ```toml [mcp_servers.network-mercatura-mercatura] url = "https://mercatura.network/mcp" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "network-mercatura-mercatura": { "type": "remote", "url": "https://mercatura.network/mcp", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add network-mercatura-mercatura --url 'https://mercatura.network/mcp' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: network-mercatura-mercatura: url: "https://mercatura.network/mcp" ``` ### Netclaw ```json { "McpServers": { "network-mercatura-mercatura": { "Transport": "http", "Url": "https://mercatura.network/mcp" } } } ``` ### Vellum ```bash assistant mcp add network-mercatura-mercatura -t streamable-http -u 'https://mercatura.network/mcp' ``` ### Other ```json { "mcpServers": { "network-mercatura-mercatura": { "type": "http", "url": "https://mercatura.network/mcp" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-03 (score 0, −12) The score moved with no change recorded against any check. We would rather say so than guess. ### 2026-11-02 (score 12, −13) The score moved with no change recorded against any check. We would rather say so than guess. ### 2026-11-01 (score 25, −12) The score moved with no change recorded against any check. We would rather say so than guess. ### 2026-10-31 (score 37, −13) The score moved with no change recorded against any check. We would rather say so than guess. ### 2026-10-30 (score 50, −12) The score moved with no change recorded against any check. We would rather say so than guess. ### 2026-10-28 (score 62, 0) - [security regression] Endpoint reachability: reachable → unreachable - [security regression] DNSSEC: fail → unverified - [security regression] Stability: 0.10 → unverified - [security regression] Authorization: fail → unverified - [security regression] Tool safety: pass → unverified - [security regression] TLS certificate: pass → unverified - [security regression] HSTS header: pass → unverified - [security regression] Transport: pass → fail - [functional regression] Capabilities: fail → unverified - [functional regression] Tool coverage: 100 → unverified - [functional] First check of Schema quality: unverified ### 2026-10-27 (score 62, 0) - [security] The server rewrote its instructions, which are the text every model session reads - [security] New tool “alerts_unsubscribe”, which the server declares destructive - [security] New tool “factor_alerts_revoke”, which the server declares destructive - [security] Tool “account_request_message” rewrote its description, which is the text the model reads - [security] Tool “merca_lock” rewrote its description, which is the text the model reads - [security] Tool “merca_lock_status” rewrote its description, which is the text the model reads - [functional regression] Schema quality: 8477 → 10136 - [functional improvement] Destructive annotations: 10% → 18% - [functional] Server version: 1.6.0 → 1.7.0 - [functional] New tool “activity” - [functional] New tool “alerts_subscribe_webhook” - [functional] New tool “alerts_verify_webhook” - [functional] New tool “factor_alerts_list” - [cosmetic] “account_request_message” added an optional parameter “destination” - [cosmetic] “account_request_message” added an optional parameter “id” - [cosmetic] “account_request_message” added an optional parameter “nonce” - [cosmetic] “account_request_message” added an optional parameter “rules” ### 2026-10-26 (score 62, +1) - [security] The server rewrote its instructions, which are the text every model session reads - [security] Tool “merca_lock” rewrote its description, which is the text the model reads - [security] Tool “merca_lock_status” rewrote its description, which is the text the model reads - [security] Tool “merca_request_unlock” rewrote its description, which is the text the model reads - [functional regression] Destructive annotations: 20% → 10% - [functional regression] Schema quality: 6425 → 8477 - [functional] Server version: 1.5.0 → 1.6.0 - [functional] Server version: 1.3.0 → 1.5.0 - [functional] New tool “pay_account” - [functional] New tool “pay_account_fund_eth_transaction” - [functional] New tool “pay_account_open_transaction” - [functional] New tool “pay_account_spender_transaction” - [functional] New tool “pay_account_withdraw_transaction” - [functional] New tool “x402_payment_typed_data” - [functional] New tool “portfolio” - [functional] New tool “shielded_status” - [cosmetic] Tool “merca_lock” changed its title: $MERCA: lock it to pay less in factor fees → $MERCA: lock it for lower factor fees and higher Pay limits ## MCP tools (44) ### `vlad_program` (~60 tokens) Vlad accounts: the program now Vlad accounts right now: the seed, how many accounts are open to claim, claims today and the daily cap, the three funds (0 Conservative, 1 Moderate, 2 Aggressive) with share prices, holdings and targets, and the rules. ### `vlad_check_eligibility` (~129 tokens) Check whether an agent can claim Whether this ERC-8004 agent can claim a Vlad account from this wallet. Returns every check (identity, the wallet the identity names, one account per agent, owner and wallet, wallet history, seeds left, today's cap) with pass or fail and a plain reason. The wallet must be the identity's agent wallet, or its owner when no agent wallet is set. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `wallet` (string, required): The wallet that will send the claim. ### `vlad_claim_transaction` (~174 tokens) Get the claim transaction Runs the checks, gets Mercatura's signed voucher (good for 15 minutes) and returns the exact claim transaction { to, data, chainId, value } for `wallet` to sign and send itself on Robinhood Chain. Nothing is claimed until that wallet sends it. fund: 0 Conservative, 1 Moderate, 2 Aggressive. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `fund` (integer, required): 0 Conservative (mostly dollars and the S&P 500), 1 Moderate (index funds and big tech), 2 Aggressive (fast stocks and the chain's coins). - `wallet` (string, required): The wallet that will send the claim: the same one the eligibility check passed for. ### `vlad_account` (~82 tokens) Read a Vlad account One agent's Vlad account: fund, shares, value in dollars, unlock date, and gains: how much could come out today (availableUsd), how much has (takenOutUsd) and when next (nextAt). Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. ### `vlad_withdraw_gains_transaction` (~126 tokens) Get the gains withdrawal transaction Before unlock, once a UTC day, the account's wallet can take its gains out in kind. Returns the account's gains now and the unsigned withdrawGains transaction for the account's own wallet to sign and send; the contract refuses it from any other wallet, on a day gains already came out, while a price is stale, or when there is no gain. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `to` (string, required): Where the gains go. ### `vlad_withdraw_transaction` (~95 tokens) Get the year-end withdrawal transaction After the account unlocks (365 days from the claim), its wallet takes everything out in kind. Returns the account and the unsigned withdraw transaction for the account's own wallet to sign and send; refused by the contract before unlock. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `to` (string, required): Where everything goes. ### `vlad_contribute_transaction` (~225 tokens) Add money to a Vlad account Anyone can add USDG to an agent's Vlad account. Runs the checks (the account is open, the fund takes additions now, the fund's room today, and the sending wallet's USDG when `from` is given) and returns two unsigned transactions in order: USDG.approve(VladBank, exactly amount), then VladBank.contribute(agentId, amount). Money added buys more of the account's fund, is the agent's, and unlocks with the account; neither the sender nor Mercatura can take it back. Additions pause while a price the fund uses is stale (stock prices stop over weekends). Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `amount` (string|number, required): Dollars of USDG, like "25" or "2.50" (at least 0.01, at most 6 decimals). - `from` (string): Optional: the wallet that will send the USDG; its balance is checked. ### `vlad_standing_order` (~125 tokens) Standing orders: read an account's order A standing order makes a Vlad account pay its agent's bills from its gains each day: creditsPct as AI credits on Raeto (one balance for 400+ models and APIs), at most gasPct to keep the wallet's ETH at gasTargetEth, and the rest in USDG to the wallet. The seed and money added stay locked. Returns the order, whether it is running and what it has paid so far. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. ### `vlad_standing_order_transactions` (~318 tokens) Standing orders: set one up For the account's own wallet: two unsigned transactions in order, StandingOrders.setOrder(agentId, creditsBps, gasBps, gasTarget, minRun), then VladBank.moveTo(agentId, StandingOrders). Send setOrder first and wait for it to confirm before sending moveTo. For the wallet of an order already running: setOrder alone, to change its terms. Defaults: credits 75, gas 25 (percent of each day's gains), gasTarget 0.0003 ETH (at most 0.01), minRun 1 dollar (at least 0.50). Cancel any time; the account moves straight back. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `credits` (string|number): Percent of each day's gains paid as AI credits on Raeto, 0 to 100. Default 75. - `gas` (string|number): Percent of each day's gains, at most, used to top the wallet's ETH up to gasTarget. Default 25. - `gasTarget` (string|number): ETH the wallet is topped up to, at most 0.01. Default 0.0003. - `minRun` (string|number): Dollars of gains a day before anything is paid, at least 0.50. Default 1. - `wallet` (string, required): The account's wallet now (or the wallet of its running order). ### `vlad_cancel_standing_order_transaction` (~89 tokens) Standing orders: cancel For the order's wallet: the unsigned StandingOrders.cancel(agentId) transaction. The order stops and the account moves straight back to that wallet, locked as before. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `wallet` (string, required): The wallet of the account's standing order. ### `portfolio` (~207 tokens) Read a portfolio: holdings and performance What a wallet or an agent holds at Mercatura and how it has done. Give a wallet (every Vlad account it holds, owns as the agent's ERC-8004 owner, or is paid by through a standing order) or an agentId (its own account). Returns totals (value, gain since the claim in dollars and percent, the past day), each stock and coin held through the fund with amount, price, value, past-day change, share and target, each account, and the value one point an hour (series.points, [unix, dollars]). Read from the program feed: no chain read. Factor accounts are not in it: their owner reads them with a signed request (balance_sheet). Input parameters: - `agentId` (string|integer): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `wallet` (string): A wallet: the agent's own, or the one that owns the agent's ERC-8004 identity. ### `list_factors` (~74 tokens) Factor accounts: the factor directory Every listed factor (an AI agent that manages money for other agents) with its mandate's limits (and its plain text where Mercatura publishes it), its fee, its record from the ERC-8004 Reputation Registry and its place in the directory, which is ordered by record. It never shows which clients a factor serves. ### `account_request_message` (~319 tokens) Factor accounts: the text the owner signs The exact text the account owner's wallet signs (EIP-191) to read or act on its factor account, and when the signature expires (five minutes). request: read, deposit, choose-factor, limits, pay, withdraw, exit, fire-factor, pause, outbox (read the house factor's sealed reviews), outbox-delete (with item, the envelope's name), activity (read its activity), alerts (subscribe: with destination, the webhook URL; rules; and nonce, new random hex), alerts-list (its subscriptions) or alerts-revoke (with id, a subscription's or "all", and nonce). Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `destination` (string): alerts only: the webhook URL the alerts go to. - `id` (string): alerts-revoke only: the subscription's id, or all. - `issued` (string): Optional ISO 8601 UTC time; now when left out. - `item` (string): outbox-delete only: the envelope's name. - `nonce` (string): alerts and alerts-revoke: 16 to 64 random lowercase hex characters, new for every request (it works once). - `request` (string, required) - `rules` (string): alerts only: the rules, comma-separated (factorMoves, factorPayments, factorFees, factorWithdrawals, factorChanges). - `wallet` (string, required): A 0x address. ### `open_account` (~226 tokens) Factor accounts: open an account Checks the agent's ERC-8004 identity and that `wallet` may open its account (the identity's agent wallet, or its owner when none is set), then returns the account's address and the unsigned AccountFactory.open(agentId, salt, owner) transaction for that wallet. Without a salt Mercatura makes one, returns it once and keeps nothing: keep it until the open transaction succeeds. Never send money to the address before then. Name another wallet as owner so owner() does not point back at the agent. One account per agent: the factory refuses a second. The identity checks still run. Input parameters: - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `owner` (string): Optional: the wallet that will own the account; the sending wallet when left out. - `salt` (string): Optional: 32 random bytes from a secure source. Left out, Mercatura makes one and returns it once. - `wallet` (string, required): The agent's wallet that sends the open transaction. ### `verify_account` (~146 tokens) Factor accounts: which agent opened an account AccountFactory.openedWith(account, agentId, salt): whether this account was opened by that agent with that salt. Both are public in the opening transaction once it ran, so this proves nothing about who controls the account; control is the owner's signed request. The salt goes to Mercatura's RPC provider inside the call. Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `agentId` (string|integer, required): The ERC-8004 agentId on Robinhood Chain, as a decimal string or integer. - `salt` (string, required): The salt the account was opened with. ### `balance_sheet` (~193 tokens) Factor accounts: read your account The factor account at this address, for its owner only: the factor and its terms, the mandate's limits, approved desks and payees, the balance sheet by desk in dollars (FactorAccount.balanceSheet()), fees owed and recent moves. Needs the owner's signed request (auth) for request "read"; any other wallet gets the same refusal whether or not the address is an account. On chain the account's balances and moves are public anyway. Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… ### `deposit` (~292 tokens) Factor accounts: deposit The unsigned transaction that puts money into the account once it is open: a plain transfer of the token (ETH as value) from the owner's wallet, booked by the account as money put in. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "deposit". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `amount` (string|number, required): A decimal amount in the token's own units, like "25" or "0.5". - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `token` (string, required): USDG, ETH, WETH, or a stock token symbol (SPY, QQQ, NVDA, TSLA, AAPL, GOOGL, MSFT, SPCX, PLTR, COIN, MSTR, GME). ### `choose_factor` (~449 tokens) Factor accounts: hire a factor The unsigned chooseFactor(factorId, version) transaction: the account copies the factor's current terms (version shown in the answer); a change the factor publishes later applies only after the owner chooses it again. Switching from another factor charges that factor's fee due at that moment: A fee is charged at fire, exit or switch on the gain over the mark, using the lowest daily sample so far, or today's value if no day has passed. A factor chosen again starts at the higher of its old mark and today's value. A switch carries a gas limit of 13,000,000; a lower one reverts with NeedGas. Refused for a factor that is not listed or has stopped. A client's $MERCA tier lowers what it is charged: Lock $MERCA and pay less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "choose-factor". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `factorId` (string|integer, required): The factor's ERC-8004 agentId, from list_factors. ### `set_mandate` (~416 tokens) Factor accounts: set the limits Unsigned transactions that set what the factor may use: desks (treasury, runway, portfolio or sweep, or a catalog adapter address) with ceilings per move and per UTC day, or approved: false to stop it; payees with a cap in dollars per UTC day (0 removes one), each a 0x address or a stealth recipient (a fresh one-time address, approved, then announced last); the exact claim calls that bring creator fees in (Pons claim(), Bankr collectFees(poolId)), at most 1,024 bytes of calldata each; and pausing the factor. The factor's own mandate limits come with it when it is chosen. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "limits". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `claims` (array) - `desks` (array) - `paused` (boolean): true pauses the factor: it cannot act until unpaused. Owner actions are never paused. - `payees` (array) - `weekLossPct` (string|number): The owner's own limit on what the factor's moves may lose together over 7 UTC days, as a percent of the account's value (0.01 to 10); the factor is held to the lower of it and its mandate's. 0 remove… ### `pay` (~430 tokens) Factor accounts: pay from the account The unsigned pay(payee, token, amount) transaction for the owner, to a payee the owner approved. With stealth instead of payee: approve a fresh one-time address (dailyCapUsd is its cap per UTC day for the factor), pay it, then announce it. The owner pays in counted tokens only; the factor pays only in USDG, within each payee's cap. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "pay". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `amount` (string|number, required): A decimal amount in the token's own units, like "25" or "0.5". - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `dailyCapUsd` (string|number): Dollars, like "500". - `payee` (string): A 0x address. - `stealth` (string): Instead of an address: a stealth meta-address (st:eth:0x) or the 0x address that registered one in the ERC-6538 registry. The money goes to a fresh one-time address and an… - `token` (string, required): USDG, ETH, WETH, or a stock token symbol (SPY, QQQ, NVDA, TSLA, AAPL, GOOGL, MSFT, SPCX, PLTR, COIN, MSTR, GME). ### `withdraw` (~377 tokens) Factor accounts: withdraw The unsigned withdraw(token, amount, to) transaction for the owner: any asset, any amount, no delay. amount "all" takes the whole balance of that token. With stealth instead of to: withdraw to a fresh one-time address, then announce it. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "withdraw". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `amount` (string|number, required): A decimal amount, or "all". - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `stealth` (string): Instead of an address: a stealth meta-address (st:eth:0x) or the 0x address that registered one in the ERC-6538 registry. The money goes to a fresh one-time address and an… - `to` (string): Where the money goes (or give stealth). - `token` (string, required): USDG, ETH, WETH, or a stock token symbol (SPY, QQQ, NVDA, TSLA, AAPL, GOOGL, MSFT, SPCX, PLTR, COIN, MSTR, GME). ### `fire_factor` (~360 tokens) Factor accounts: fire the factor The unsigned fire() transaction for the owner. With withdrawAllTo it is exitAll(to) instead: everything withdrawn and the factor fired, in one transaction (sign the request as "fire-factor"). Either way the fee due at that moment is charged first: A fee is charged at fire, exit or switch on the gain over the mark, using the lowest daily sample so far, or today's value if no day has passed. A factor chosen again starts at the higher of its old mark and today's value. fire() carries a gas limit of 10,000,000 and exitAll(to) 30,000,000; a lower one reverts with NeedGas, and a wallet must not estimate exitAll's gas: with less, a loaded account's exit stops unwinding and sends desk shares home instead of USDG. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "fire-factor". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `withdrawAllTo` (string): Optional: also withdraw everything to this address, in the same transaction. ### `stealth_address` (~273 tokens) Stealth payouts: a one-time address Live. A fresh ERC-5564 (scheme 1) stealth address for a stealth meta-address or for the 0x address that registered one in the ERC-6538 registry, with its ephemeral public key, view tag and the unsigned Announcer.announce transaction to send after paying. Optional token and amount go into the announcement's metadata. Mercatura sees which meta-address the address belongs to and keeps neither that nor the ephemeral key; the payment, its amount and time, the payer and the announcement's sender stay public on chain. Input parameters: - `amount` (string|number): A decimal amount in the token's own units, like "25" or "0.5". - `from` (string): Optional: the wallet that will pay and announce. - `metaAddress` (string): st:eth:0x (compressed secp256k1 keys). - `registrant` (string): Or: the address that registered a meta-address in the ERC-6538 registry. - `token` (string): USDG, ETH, WETH, or a stock token symbol (SPY, QQQ, NVDA, TSLA, AAPL, GOOGL, MSFT, SPCX, PLTR, COIN, MSTR, GME). ### `merca_lock_status` (~325 tokens) $MERCA: what a wallet has locked The $MERCA a wallet has locked in the factor registry, how much counts for its tier (locked, no unlock requested), when a requested unlock is ready, and its Mercatura Pay tier (pay: its daily caps as a payer and a merchant). A wallet balance never counts. Lock $MERCA and pay less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. The same lock raises Mercatura Pay's daily limits: per payer 200 settles with none, 500 / 1,000 / 2,500 at 100,000 / 1,000,000 / 10,000,000 locked; per merchant 400, then 1,000 / 2,500 / 10,000; once the free settles are used up for the day, a locker's settles go on from their own budget. A pay account counts its current owner's lock. Half of the factor fees Mercatura earns buys $MERCA once it reaches $5 and burns it to 0x000000000000000000000000000000000000dEaD. Input parameters: - `wallet` (string, required): A 0x address. ### `merca_lock` (~319 tokens) $MERCA: lock it for lower factor fees and higher Pay limits Unsigned transactions for `wallet`: approve the factor registry, then lock(amount). It counts at once for the accounts this wallet owns. Lock $MERCA and pay less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. The same lock raises Mercatura Pay's daily limits: per payer 200 settles with none, 500 / 1,000 / 2,500 at 100,000 / 1,000,000 / 10,000,000 locked; per merchant 400, then 1,000 / 2,500 / 10,000; once the free settles are used up for the day, a locker's settles go on from their own budget. A pay account counts its current owner's lock. Half of the factor fees Mercatura earns buys $MERCA once it reaches $5 and burns it to 0x000000000000000000000000000000000000dEaD. Listing a factor needs no $MERCA. Input parameters: - `amount` (string|number, required): $MERCA, like "100000". - `wallet` (string, required): A 0x address. ### `merca_request_unlock` (~68 tokens) $MERCA: request an unlock The unsigned requestUnlock() transaction for `wallet`: all its locked $MERCA stops counting at once, for factor fees and Mercatura Pay's limits alike, and can be taken back with merca_unlock 7 days later. Input parameters: - `wallet` (string, required): A 0x address. ### `merca_unlock` (~48 tokens) $MERCA: take it back The unsigned unlock() transaction for `wallet`, once 7 days have passed since its requestUnlock; says when it is ready otherwise. Input parameters: - `wallet` (string, required): A 0x address. ### `delivery_key_typed_data` (~196 tokens) House factor reviews: the typed data to sign The EIP-712 typed data the account's owner signs (eth_signTypedData_v4, from the wallet owner() returns) to register an X25519 delivery key: domain Mercatura delivery, version 1, chain 4663, verifyingContract the account; DeliveryKey(address account, bytes32 pub, uint64 issuedAt). Make the key pair on your own machine; only the public half (pub) is sent anywhere. pub of all zeros revokes. Each registration needs a newer issuedAt than the last. Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `issuedAt` (integer|string): Optional unix seconds; now when left out. Sign and register the same value. - `pub` (string, required): The 32-byte X25519 public key, hex (all zeros revokes). ### `register_delivery_key` (~179 tokens) House factor reviews: register the delivery key Registers (or, with pub all zeros, revokes) the owner's X25519 delivery key: signature is the account owner's EIP-712 signature over the typed data delivery_key_typed_data returns, checked against owner() on chain; issuedAt must be newer than the registered key's and at most 5 minutes ahead; a low-order key is refused; at most 5 keys a UTC day per account (a revoke is always taken). The house factor checks it again, then seals each review and record for this account to that key. Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `issuedAt` (integer|string, required): Unix seconds: the value signed. - `pub` (string, required) - `signature` (string, required) ### `read_outbox` (~192 tokens) House factor reviews: read the outbox The house factor's envelopes for this account, newest first, for the owner's signed request (request "outbox"). Each is v2: { v, account, kind, at, sealed, sig }, sig by the factor key. On your own machine, check sig against account.factor() on chain, then decrypt sealed with the X25519 secret key (scripts/open-envelope.mjs, or the snippet at /developers#delivery). Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… ### `delete_outbox_item` (~141 tokens) House factor reviews: delete one envelope Removes one envelope from the outbox, for the owner's signed request (request "outbox-delete", with item = the envelope's name). Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `name` (string, required) ### `shielded_status` (~159 tokens) Shielded payments: status Mercatura's shielded ETH pool on Robinhood Chain (0xbow's Privacy Pools v1 plus Mercatura's deposit gate; it uses an association set): whether it is live and, if not, what is not yet; whether deposits are open; the approved deposits in the association set, which is what a payment hides among; the minimum and per-deposit cap; the relayer (online, fee); the contracts; the screening rules; and what the chain shows and hides. The same answer as GET /v1/shielded. Deposits, proofs and payments run in the agent's own client, mercatura-shielded (install with client.install), never on Mercatura's servers: the note secret is the money. ### `pay_account` (~181 tokens) Mercatura Pay: read a pay account One pay account: whether the address is one, its USDG, its owner, its top-up target and, with spender, that key's limits (per payment, per UTC day, expiry), what it spent today, what it has left and whether it is retired for good. Give account, or owner (and salt, zero when left out) to find the account open(owner, salt) gives. One read, kept 120 seconds. Input parameters: - `account` (string): The pay account's 0x address. - `owner` (string): Instead of account: the owner's wallet; the account is found from it and salt. - `salt` (string): Optional, with owner: 32 bytes; zero when left out. - `spender` (string): Optional: a spender key's address, to read its limits and what it has left today. ### `pay_account_open_transaction` (~225 tokens) Mercatura Pay: open a pay account The account's address and the unsigned PayAccountFactory.open(owner, salt) transaction, or with eth, openWithETH: the ETH is swapped to USDG on the way in (WETH/USDG pool), at least minUsdg or it reverts (minUsdg defaults to Chainlink's ETH price less 1%; the factory itself refuses below Chainlink less 2%, and while that price is older than 48 hours). Anyone can send it; the account is the owner's. salt is zero when left out: one account per owner. Input parameters: - `eth` (string|number): Optional: ETH to put in, swapped to USDG, like "0.01". - `from` (string): Optional: the wallet that sends it; the owner when left out. - `minUsdg` (string|number): Optional with eth: the least USDG the swap may give. - `owner` (string, required): The agent's wallet that will own the pay account. - `salt` (string): Optional: 32 bytes; zero when left out. ### `pay_account_fund_eth_transaction` (~178 tokens) Mercatura Pay: fund a pay account with ETH The unsigned PayAccountFactory.fundWithETH(account, minUsdg) transaction with the ETH as value: swapped to USDG on the way in and sent to the account, at least minUsdg or it reverts (default: Chainlink's ETH price less 1%; the factory itself refuses below Chainlink less 2%, and while that price is older than 48 hours). Any wallet can fund any pay account. Sending USDG straight to the account works too. Input parameters: - `account` (string, required): The pay account's 0x address. - `eth` (string|number, required): ETH to put in, like "0.01". - `from` (string): Optional: the wallet that sends it. - `minUsdg` (string|number): Optional: the least USDG the swap may give. ### `pay_account_spender_transaction` (~262 tokens) Mercatura Pay: set or remove a spender key For the account's owner: the unsigned setSpender(key, perPayment, perDay, expiry) transaction, so a separate key on the agent's machine can pay x402 APIs from the account within those limits (setting a key again replaces its limits), or with remove: true, removeSpender(key). A stolen spender key can spend at most its daily limit per UTC day (up to twice that across a midnight) until it is removed or expires; it can never withdraw. A removed key is retired for good: it can never be set again, so make a new key instead. Make the key on your own machine and send only its address. Input parameters: - `account` (string, required): The pay account's 0x address. - `days` (integer|number|string): Days until the key expires, 1 to 3650; 30 when left out. - `perDayUsdg` (string|number): Most USDG per UTC day, like "5". - `perPaymentUsdg` (string|number): Most USDG per payment, like "0.10". - `remove` (boolean): true removes the key instead: it is retired for good. - `spender` (string, required): The spender key's address. ### `pay_account_withdraw_transaction` (~91 tokens) Mercatura Pay: withdraw from a pay account For the account's owner: the unsigned withdraw(amount, to) transaction. Any amount, or "all", at any time; no one else can withdraw. Input parameters: - `account` (string, required): The pay account's 0x address. - `amount` (string|number, required): USDG, like "12.5", or "all". - `to` (string, required): Where the USDG goes. ### `x402_payment_typed_data` (~252 tokens) x402: the typed data that pays a 402 From an x402 402 response (its PAYMENT-REQUIRED header, base64, or the decoded JSON; a v1 body works too) and the payer: the EIP-712 TransferWithAuthorization to sign and the payment to send back (PAYMENT-SIGNATURE for v2, X-PAYMENT for v1), for USDG on Robinhood Chain. A wallet signs under USDG's domain (any facilitator settles it); a pay account's owner or spender key signs under the domain Mercatura Pay, version 1, chain 4663, verifyingContract the pay account (Mercatura's facilitator settles it). kind says which; left out, the factory is asked. Sign on your own machine: this tool never sees a key. Input parameters: - `accept` (integer): Optional: the index in accepts to pay; the first USDG option on Robinhood Chain when left out. - `kind` (string): Optional: which the payer is. - `payer` (string, required): The address that pays: the wallet, or the pay account. - `paymentRequired` (string|object, required): The 402's PAYMENT-REQUIRED header (base64) or its decoded JSON. ### `activity` (~263 tokens) Activity: what an agent's money did Newest first: a Vlad account's claim, money added, gains out, withdrawals, moves, standing-order runs and its fund's trades (Lapo's), and its wallet's pay accounts' payments (with the key that signed), USDG in, withdrawals and key or owner changes. Each row has its time, transaction and one plain sentence. ref: an agentId, a wallet or a pay account. A factor account instead: account and the owner's signed request (auth, request "activity"). Read from Mercatura's index of Robinhood Chain, every 5 minutes: no chain read. Input parameters: - `account` (string): Instead of ref: a factor account, for its owner (with auth). - `auth` (object): With account: the owner's signed request for request "activity". - `before` (string): Optional: a previous answer's next, for older rows. - `kinds` (string): Optional, comma-separated: payments, in, out, trades, changes. - `limit` (integer) - `ref` (string|integer): An agentId (a whole number), a wallet, or a pay account (a 0x address). - `since` (integer): Optional: only rows at or after this unix time (seconds). ### `alerts_subscribe_webhook` (~544 tokens) Alerts: send events to a webhook Subscribes an https webhook to a subject's events: ref, an agentId (a claimed Vlad account), a pay account, or a wallet that holds one. Mercatura POSTs { "type": "mercatura.webhook.verify", "nonce" } and the endpoint must answer 2xx with JSON { "verify": }. The answer is pending and shows the signing secret once: set it on the endpoint, then call alerts_verify_webhook (Mercatura also tries every 5 minutes; unverified, it is deleted after 10). Each alert is a JSON POST with X-Mercatura-Timestamp and X-Mercatura-Signature: sha256=; 3 tries with backoff; turned off after 20 straight failures; at most one alert per rule per 10 minutes (more go together). The answer's unsubscribe.token stops it (alerts_unsubscribe). URL: https, standard port, a host name (no IP address). A factor account instead: account, auth for request "alerts" signed over this destination, these rules and nonce (account_request_message builds the text), and nonce. Input parameters: - `account` (string): Instead of ref: a factor account, for its owner (with auth and nonce). - `auth` (object): With account: the owner's signed request for request "alerts". - `balanceUnderUsd` (number): With balanceUnder: dollars. - `dailySpendUsd` (number): With dailySpend: dollars. - `nonce` (string): With account: the nonce in the signed text; it works once. - `ref` (string|integer): An agentId (a whole number), a wallet, or a pay account (a 0x address). - `rules` (array, required): What to be told about. Public subjects: payments (every payment from a pay account), dailySpend (with dailySpendUsd: a pay account's UTC-day spending passes it), spenderLimit (a spender key at 80% of… - `url` (string, required): The https URL to POST alerts to. ### `alerts_verify_webhook` (~93 tokens) Alerts: verify a pending webhook now For a webhook subscription that is still pending: Mercatura POSTs its check now ({ "type": "mercatura.webhook.verify", "nonce" }) and the subscription is active once the endpoint answers { "verify": }. token: the unsubscribe token the subscription was given. Input parameters: - `token` (string, required): The subscription's unsubscribe token. ### `factor_alerts_list` (~151 tokens) Factor accounts: the account's alert subscriptions For a factor account's owner: every alert subscription on the account (id, channel, the host it goes to, rules, created, active, pending or off). Needs the owner's signed request for request "alerts-list". Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… ### `factor_alerts_revoke` (~200 tokens) Factor accounts: stop alert subscriptions For a factor account's owner: stops one alert subscription (id) or every one ("all"); each is deleted with its URL or push keys. Needs the owner's signed request for request "alerts-revoke", signed over this id and nonce (account_request_message builds the text); the nonce works once. Input parameters: - `account` (string, required): The factor account's 0x address (open_account returns it). Accounts are found by address, never by agentId. - `auth` (object, required): The account owner's signed request: sign the text account_request_message returns (EIP-191 personal_sign) with the owner's own key; it must recover to owner(), so a contract-wallet owner cannot use t… - `id` (string, required): A subscription's id (factor_alerts_list), or all. - `nonce` (string, required): The nonce in the signed text. ### `alerts_unsubscribe` (~51 tokens) Alerts: stop a subscription Stops a push or webhook subscription with the unsubscribe token it was given (every alert body carries it too). The subscription and its URL or push keys are deleted. Input parameters: - `token` (string, required): The unsubscribe token. ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/network-mercatura-mercatura/mercatura#diagnostics ## Score history - 2026-11-03: 0 - 2026-11-02: 12 - 2026-11-01: 25 - 2026-10-31: 37 - 2026-10-30: 50 - 2026-10-29: 62 - 2026-10-28: 62 - 2026-10-27: 62 - 2026-10-26: 62 - 2026-10-25: 61 - 2026-10-24: 61 ## Common questions ### What is the Mercatura MCP server? Mercatura is an MCP server listed in the public MCP registry as network.mercatura/mercatura. Claim a $10 Vlad account for an AI agent and open factor accounts on Robinhood Chain. This page covers its hosted endpoint (https://mercatura.network/mcp). ### Is the Mercatura MCP server safe to use? Mercatura scores 0 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Mercatura MCP server expose? Mercatura exposes 44 tools: vlad_program, vlad_check_eligibility, vlad_claim_transaction, vlad_account, vlad_withdraw_gains_transaction, and 39 more. Their descriptions and schemas cost roughly 9,303 tokens of context every time the server is loaded. ### Does the Mercatura MCP server require authentication? Its publisher declares no required credentials for Mercatura. We have not been able to confirm that against the live endpoint, and a server can require authorisation without declaring it here. ### Is the Mercatura MCP server still maintained? Mercatura is marked deprecated in the MCP registry. We last reached this channel on 27 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ## Links - Remote endpoint: https://mercatura.network/mcp - Website: https://mercatura.network/developers - Changelog RSS feed: https://verifymcp.io/servers/network-mercatura-mercatura/mercatura.xml - Changelog JSON feed: https://verifymcp.io/servers/network-mercatura-mercatura/mercatura.json - HTML version of this page: https://verifymcp.io/servers/network-mercatura-mercatura/mercatura