Settle Watch

io.github.benmcalillycreative由 GitHub 账号 benmcalillycreative 发布v1.0.0更新于 Nov 22, 2026

Check an x402 or MPP API before your agent pays it: uptime, price and a proven payout address.

发布方自己的服务:watch.diy – DIY Store Finder

已验证Streamable HTTP可网页运行金融开发者工具安全与监控

概览

AI 生成的概览

在代理付款前检查 x402 或 MPP 接口,就可用性、价格条款和收款地址给出结论,并为卖家检查上架情况。

可以做什么
  • 付款前检查接口:是否稳定应答、条款是否与上架信息一致、收款地址是否已证明属于卖家,返回 ok、caution 或 avoid 及原因
  • 检查卖家的 x402 上架:是否出现在 Coinbase 的 Bazaar 中,若没有则说明原因,依据 Coinbase 的公开校验器、商户查询和 30 天可用率
适用场景
当代理即将向某个 x402 或 MPP 接口付款,需要判断该接口是否安全、付款条款是否可信时使用。卖家也可用它排查接口为何未出现在 Coinbase 的 Bazaar 中。
运行要求
远程 streamable HTTP 端点;未声明任何软件包、账号、密钥或请求头。检查为只读查询,基于该服务自身的数据。
安装前请注意
结论仅供参考,来自第三方的抽样检查,avoid 可视为停止信号,但 ok 并不构成保证。该服务声明从不付款,也不持有钱包。README 中提到的卖家付费方案和付费检查接口与这两个工具是分开的。

安装

在 SourceWeft 中

  1. 打开 控制台中的 Settle Watch,将其添加到工作区。
  2. 为需要使用其工具的对话启用该服务。

Web executable,通过 Streamable HTTP。 远程服务在工作区中配置后即可从网页运行时运行。

交给智能体安装

把这段提示词粘贴到 Claude Code、Codex、Cursor 等智能体,或 SourceWeft 对话中。智能体会读取该服务器的安装指南,先向你展示发布者、端点和登录方式,经你同意后再把它添加到你的客户端。密钥不会写进任何命令。

阅读 https://sourceweft.com/mcp/io.github.benmcalillycreative%2Fsettle-watch/install.md,并按其中说明把这个 MCP 服务器接入我的客户端。修改任何配置之前,先告诉我它的发布者、端点和登录方式,等我确认。不要把 API 密钥写进命令或我会提交的文件;问我密钥应从哪里获取。

查看智能体所依据的安装指南

其他 MCP 客户端

把它添加到你客户端的 mcpServers 配置中。

{
  "mcpServers": {
    "settle-watch": {
      "type": "http",
      "url": "https://api.settlewatch.com/mcp"
    }
  }
}

README

Settle Watch

An independent referee for agent-payable endpoints: everything in Coinbase's x402 Bazaar, Circle's Agent Marketplace and the MPP (Machine Payments Protocol) service directory. Every 6 hours it:

  1. Crawls the x402 Bazaar catalog (Coinbase's public discovery API) and records every listed endpoint. This happens once a day; the catalog is 66K+ listings and takes about 10 minutes to pull.
  2. Probes the 15,000 endpoints that have gone longest without a check (at most 100 per host), without paying. It asks for the resource, expects an HTTP 402 with payment terms, and records whether it answered, how fast, and whether the terms match the listing. At four cycles a day, real services get about two checks a day.
  3. Scores each endpoint 0–100 with a letter grade and plain-English flags.
  4. Writes a leaderboard page (the top 500 plus every red flag) and a scores.json export with everything.

No wallet, no keys, no dependencies. It never pays anyone.

The live board: https://settlewatch.com/

Source available, all rights reserved. This code is public so that anyone, sellers included, can see exactly how the board grades endpoints. It is not open source: no license is granted to copy, modify or redistribute it. © 2026 Ben McAlilly.

Get it running (5 minutes)

You need Python 3.9 or newer. On a Mac, python3 --version will tell you. If it offers to install the developer tools, say yes.

bash
# 1. Put the folder in your home directory, then:cd ~/x402-trust
# 2. Add your contact email (or a web page) to settings.env, so endpoint owners know who's checking them.open -e settings.env
# 3. Test run on a small samplepython3 -m x402trust crawlpython3 -m x402trust probe --limit 50python3 -m x402trust scorepython3 -m x402trust reportopen ~/x402-trust-data/reports/leaderboard.html
# 4. Happy? Schedule it: runs now, then every 6 hourschmod +x install-schedule.sh && ./install-schedule.sh

To check on it at any time: python3 -m x402trust status. Logs live in ~/x402-trust-data/logs/. To stop the schedule: ./install-schedule.sh --remove.

Run it on a machine that stays on. Uptime numbers are only as good as how often you check.

How scoring works

WeightSignalWhat it measures
50%UptimeShare of checks where the server answered: a 402 with terms, a free response, or a 400 asking for input first. Failures caused by our own Python's TLS don't count against anyone
15%SpeedMedian response time. Half a second or less gets full marks; 5 seconds or more gets zero
20%ConsistencyWhether it asks to be paid where, and roughly what, its listing says
15%AdoptionUnique paying customers in the last 30 days, from the catalog

What the first week of real data taught, now built in:

  • Fresh payment addresses are normal. Many honest services (Browserbase, Tavily and others) generate a new address for every payment, or pay into another wallet the same service lists. Neither is penalized.
  • Prices often depend on the request. Cheaper than listed, or up to 2×, is information only. 2–10× and over 10× are warnings (a stale listing explains a big gap as often as a bad seller does, and the payer sees the real price before signing). Red flags are kept for money going somewhere it shouldn't.
  • The real hijack signature is a wallet that used to match the listing and then switched to an address no listing anywhere mentions. That's an automatic F, capped at 30.

Caps, because good uptime shouldn't hide terms an agent would regret paying:

ProblemEffect
Wallet switched to an unknown addressCapped at 30, always F
Asks over 10× its listed priceCapped at 45
Asks 2–10× listed, pays a wallet not in its listing, or listed as paid but freeCapped at 69
Points at a private network address0

Chips on the leaderboard are red (would regret paying), amber (warning), or grey (information only). An endpoint needs 3 checks before it gets a grade.

Big hosts are sampled. Each cycle checks at most 100 endpoints from any one host, so one host with 66,000 templated listings can't crowd out everyone else. Real services get about two checks a day; most of a giant host's listings stay ungraded.

Owner notes

When a seller tells you something about their own endpoints, record it so the board reflects it:

bash
# Routes they took down on purpose (only the ones answering HTTP 410):python3 -m x402trust note api.example.com retired "Retired on purpose (owner, Oct 29)" --when-http 410# Terms they confirmed are deliberate, e.g. a price that depends on the request:python3 -m x402trust note https://api.example.com/v1/search intended "Price depends on query size (owner)"python3 -m x402trust notes          # listpython3 -m x402trust unnote api.example.com

Retired endpoints stop counting as dead or flaky and show as "Retired by owner." Intended drops the price and wallet warnings and shows "Owner confirmed." Notes live in ~/x402-trust-data/owner-notes.json, so upgrades never touch them.

Sellers don't always need a note. If a bare URL can only return an illustration (it needs order details before it can price anything), the seller can mark that offer with "extra": {"example": true} in the 402 requirement. A zero-address quote marked that way shows as "example offer" (information) instead of the red burn-address flag.

MPP (Machine Payments Protocol)

Once a day, alongside the Bazaar crawl, the board reads the MPP service directory (X402T_MPP_CATALOG_URL, default https://mpp.dev/api/services; set it to empty to turn MPP off). Every paid endpoint there is probed the same way: MPP answers an unpaid request with HTTP 402 and one WWW-Authenticate: Payment challenge per payment method (stablecoin on Tempo, card through Stripe, ...). The board records the option that names a recipient address, so the wallet can be tracked.

Differences from x402, built into the scoring:

  • No wallet in the listing. The MPP directory doesn't say who gets paid, so there's nothing to compare against. Instead the board compares an endpoint with its own history: if it asked for the same address several times and then switches, it shows "Started asking for payment to a new address" (a warning). A payout proof settles it either way.
  • No usage numbers. The directory doesn't publish paid calls or payers, so adoption is left out of MPP scores rather than counted as zero.
  • Card-only endpoints (Stripe) have no address at all; they're checked for uptime and price only.

MPP endpoints carry an "MPP" label on the board, and the table can be filtered by protocol.

Circle Agent Marketplace

Once a day, after the Bazaar and MPP crawls, the board reads Circle's public x402 discovery API (X402T_CIRCLE_CATALOG_URL, default https://api.circle.com/v2/x402/discovery/resources; set it to empty to turn it off). Listings are ordinary x402, so they're probed and graded the same way.

  • A resource the Bazaar also lists stays a Bazaar row (with Bazaar usage numbers); the board only notes that Circle lists it too (listed_on in scores.json).
  • A resource only Circle lists gets a "Circle" label. Circle doesn't publish usage, so, as with MPP, the customers part of the score is left out rather than counted as zero.
  • Only the Circle crawl can delist a Circle-only row, after the same 36-hour grace period.

Verified payout addresses

A listing can name any wallet, and nothing in x402 proves the wallet getting paid belongs to whoever runs the endpoint. Sellers can prove it, free, with two things published together:

  1. Their site or DNS names the address: a file at https://<host>/.well-known/x402-payto.json, or a TXT record at _x402-payto.<domain>.
  2. The wallet signs a short message naming the domain (an ordinary wallet signature, no transaction).

The board checks every host that quoted a pay-to address, once a day, and shows:

ChipMeaning
Payout address verified (domain DNS + wallet signature)strongest: DNS is hard to change even if the web server is breached
Payout address verified (its site + wallet signature)the site and the wallet belong to the same party
Payout address listed by its own site (not signed)information only
Asks for payment to an address its own site doesn't listred flag, capped at 30, always F

Sellers make their proof on verify.html (published next to the board): it builds the message, signs it with their browser wallet, and gives them the file and the DNS record. The exact format is at the bottom of that page.

When a seller tells you they've published one, check it right away instead of waiting a day:

bash
python3 -m x402trust payout api.example.compython3 -m x402trust score && python3 -m x402trust report && ./publish.sh

Signatures are checked with the standard library (x402trust/ethsig.py); smart-contract wallets go through an ERC-1271 call to Base (X402T_BASE_RPC_URL, default https://mainnet.base.org). DNS is looked up over HTTPS (X402T_DOH_URL, default Cloudflare).

Payout proofs for buyers' clients (payouts.json)

Next to scores.json, the board publishes payouts.json: every payout proof it has found, when it last re-read the proofs (proofs_checked_at) and when an endpoint on that host last asked to be paid to each proven address (last_seen_asking). A client can use those timestamps to enforce its own staleness limit. Better still, it can verify at call time without trusting the board: read the seller's _x402-payto.<domain> TXT record (or /.well-known/x402-payto.json), check the signature, and compare the address with the payTo in the live 402. The DNS method doesn't depend on the API server, so a compromised server alone can't forge it.

Real payments on Base

The catalog's call and payer counts come from the seller side, and some of them are padded by sellers paying themselves. So the board also counts payments straight from the blockchain: every USDC transfer on Base to an address an endpoint asks to be paid to, over the last 30 days.

For each host the board shows payments, distinct paying wallets, USDC received, and how much of it came from the service's own wallets (the receiving address itself, or any other address the same host asks to be paid to). Two flags come out of it:

FlagWhen
Most payments come from the seller's own wallets (warning)20+ payments and at least half from its own wallets
Almost all payments come from one wallet (info)one outside wallet sent 80%+ of payments

Sellers buying from other sellers is normal (agents pay agents), so that is never counted against anyone. The numbers are also written to onchain.json next to scores.json.

bash
python3 -m x402trust chain    # also runs inside each cycle

The first run backfills 30 days for every address. Each run is capped at 15 minutes (X402T_CHAIN_MAX_SECONDS) and picks up where it stopped, so on free public RPCs the backfill can take a few cycles. Free RPCs rate-limit hard, so requests are paced and spread across several (mainnet.base.org, PublicNode, dRPC and 1RPC by default; set your own list with X402T_BASE_RPC_URLS). When all of them are refusing, the run stops cleanly and the next cycle carries on from the same block. Addresses still backfilling are left off the board until they're caught up, so partial counts are never shown. After that, each run only reads new blocks and takes seconds. A free Alchemy or QuickNode Base URL in X402T_BASE_RPC_URL makes the backfill much faster. Set X402T_CHAIN=0 to turn it off.

Solana USDC is counted too (chain_sol.py): for each Solana pay-to address, its USDC token accounts' transactions are read back 30 days through public Solana RPCs (X402T_SOLANA_RPC_URLS), at most X402T_SOLANA_MAX_SECONDS per run. Accounts with more than X402T_SOLANA_MAX_TX transactions in the window are left out rather than shown partly counted. X402T_SOLANA=0 turns it off. Tempo (MPP) and other tokens show no on-chain numbers yet.

Check-before-you-pay API (worker/)

seller/<host>.json on the board holds each seller's grade, payout proofs and up to 1,000 endpoint records with their flags. The Cloudflare Worker in worker/ turns that into a paid x402 endpoint, GET /v1/check?url=...&payTo=... at $0.01, that answers ok / caution / avoid / unknown with reasons. See worker/README.md to deploy it. The same Worker serves a free remote MCP server at /mcp (tools check_payment and check_listing).

For sellers, free: GET /v1/listing?url=... (and listing.html on the board) answers "why isn't my endpoint in the Bazaar?". It runs Coinbase's public validator (POST /platform/v2/x402/validate, the indexer's own checks), looks the payout address up in Coinbase's merchant list (/platform/v2/x402/discovery/merchant), adds the board's 30-day availability, and returns findings with a fix for each. 30 checks a day per IP, cached 10 minutes per URL.

Seller plan, paid in USDC: pro.html posts to POST /v1/plan/start, which sends the seller to GET /v1/plan/pay?p=<plan id>&months=1|3|12, an x402 route at $11.99 a month paid to the same PAY_TO (browsers get a wallet page). USDC can't be pulled from a wallet, so the plan is prepaid: each settled payment moves the plan's end date forward and is queued for the board's computer, where x402trust/plans.py records it in plans.json, sends the receipt with the transaction link, adds the domain to the payer's alerts, tells the owner, emails one pay link five days before the end date and one note when it has ended. No invoices; nothing charges by itself. A new plan also gets its listing review on the next run (the Worker's listing check across every route on the domain, authenticated with ALERTS_TOKEN so it isn't held to the public limit, grouped into what to fix, plus a drafted Agentic.Market card request), and every active plan gets a 30-day availability report per endpoint, with each failed check, on the first run of the month. The owner gets a copy of each review.

30-day availability: every score run also computes, per endpoint, the share of counted checks that answered over the last 30 days (uptime_30d, probes_30d, history_days). Seller pages and seller/<host>.json show it against Coinbase's bar for featured listings (99% over 30 days), and watchers get an alert when an endpoint crosses that bar.

packages/x402-trust-guard/ is a one-line add-on for x402 clients (withTrustGuard(client)) that runs that check before every payment and refuses red flags. It is MIT-licensed (unlike the rest of this repo) so anyone can ship it; publish it with cd packages/x402-trust-guard && npm publish.

State of agent payments (monthly)

python3 -m x402trust monthly [YYYY-MM] writes a market snapshot to reports/state/: numbers (.json), a draft to edit and post (.md) and a page published with the board (.html). Each issue compares itself with the previous one. run writes last month's issue by itself in the first three days of each month.

Automatic updates

When this folder is a git checkout of the main branch, run.sh checks GitHub for new code before every cycle (update.sh). New code is kept only if the full test suite passes on this machine; otherwise the previous code is restored and the cycle runs on it. Every update and rollback is written to the day's log. Your settings.env and data folder are never touched. Set X402T_AUTO_UPDATE=0 in settings.env to turn it off.

Owner notes can ship with the code in managed/owner-notes.json. A note you add locally (python3 -m x402trust note ...) for the same endpoint takes precedence.

Alerts

Sellers can ask to be told when their endpoints change. Watched endpoints are checked every cycle, and after each cycle a watcher gets at most one email covering what changed: an endpoint stopped answering (two failed checks in a row) or came back, started asking a different price or wallet, or left or rejoined the catalog. Their first email says "monitoring is on" and gives the current status. No change, no email.

bash
python3 -m x402trust watch [email protected] api.example.com --name "Example"python3 -m x402trust watcherspython3 -m x402trust unwatch [email protected]python3 -m x402trust alerts --dry-run   # preview what would go out, without sending

Email setup (Gmail): turn on 2-Step Verification for the account, create an app password at https://myaccount.google.com/apppasswords, then add these to settings.env:

[email protected]X402T_SMTP_PASS=your-16-character-app-passwordX402T_ALERT_FROM_NAME=Your Name

Run chmod 600 settings.env so only your account can read it, and python3 -m x402trust test-email [email protected] to check it works. Until email is set up, alerts are saved to ~/x402-trust-data/outbox/ and nothing is sent.

Self-serve sign-ups (optional). With the Worker in worker/ deployed, every seller page gets a "Get alerts" form. Sign-ups are double opt-in: the Worker only stores the request; this computer sends the confirmation email (from the same address as the alerts) and adds the watcher once the link is clicked. Every alert then carries a one-click unsubscribe link. Add to settings.env:

X402T_API_URL=https://x402-trust-check.<your-subdomain>.workers.devX402T_ALERTS_TOKEN=<the same long random string you gave the Worker as ALERTS_TOKEN>

python3 -m x402trust signups processes the queue on demand; run does it every cycle.

Publishing the board (optional)

The board can publish itself to GitHub Pages after every cycle. It's free, and there's no server to run.

  1. On GitHub, create a new public repository, for example x402-trust-board, with no files.
  2. On the mini: ./setup-publish.sh your-github-name/x402-trust-board. This makes a key that can only push to that one repo and prints it.
  3. Add that key in the repo under Settings → Deploy keys → Add deploy key, and tick Allow write access.
  4. Run ./publish.sh once. Then go to Settings → Pages, choose Deploy from a branch, select gh-pages and / (root), and click Save.

From then on, every cycle republishes the board automatically. Each publish replaces the branch with one fresh commit, so the repo never grows. To use your own domain, set X402T_PUBLISH_DOMAIN=trust.example.com in settings.env and add a CNAME record pointing to your-github-name.github.io. To stop publishing, remove the X402T_PUBLISH_REPO line from settings.env.

Before going public, set X402T_CONTACT to an address you're happy to show the world. The board shows it under "Is this your endpoint?"

Safety

  • It never pays. There's no wallet in the code.
  • It won't touch your home network. Listings are written by strangers, so it refuses any URL that resolves to a private address (your router, your other machines) and never follows redirects.
  • It's polite. At most 2 simultaneous requests to any one host. It identifies itself honestly in every request. If a host fails 5 times in a row, it's marked down for the rest of that cycle instead of being hammered.
  • Cycles never overlap. If one is still running when the next is due, the next one skips.

Files

x402trust/crawl.py    catalog crawler (pagination, retries, delisting)x402trust/probe.py    unpaid probes (v1 body and v2 PAYMENT-REQUIRED header)x402trust/parse.py    reading payment terms, USDC → dollars, network namesx402trust/netguard.py private-address blockingx402trust/score.py    trust scores and flags (tune the weights here)x402trust/report.py   leaderboard HTML + scores.jsonx402trust/crawl_mpp.py MPP directory crawlerx402trust/crawl_circle.py Circle Agent Marketplace crawlerx402trust/payout.py   verified payout addresses (DNS, site file, wallet signature)x402trust/chain.py    real USDC payments on Base, counted from the chainupdate.sh             self-update from GitHub (kept only if tests pass)managed/              owner notes that ship with the codetests/test_e2e.py     full test against a fake Bazaar: python3 -m unittest discover -s tests

Everything is stored in one SQLite file, ~/x402-trust-data/trust.db. Raw catalog entries and every probe are kept, so you can re-score history later with new rules.

What's next

  • Paid test calls on a small rotating sample, with a capped budget. These check that the endpoint delivers what it promises after you pay. That's the signal nobody else has.

来源:README.md,提交 68206f3

工具

2

check_payment

Check before paying an x402 / MPP endpoint

Before paying an agent-payable API (x402 or MPP), check whether it is safe: does it answer reliably, do its payment terms match its listing (no switched or burn wallets, no overcharges), and is the address it asks you to pay one the seller has proven is theirs. Returns verdict ok | caution | avoid | unknown with reasons. Pass the payTo address from the 402 response when you have it.

输入参数url必填payTo

check_listing

Why isn't my x402 endpoint in the Bazaar?

For sellers: check whether an x402 endpoint is listed in Coinbase's Bazaar and, if not, why. Runs Coinbase's public validator (the indexer's own checks), looks the payout address up in Coinbase's merchant list, and adds the Settle Watch's 30-day availability against Coinbase's 99% bar for featured listings. Returns findings with a fix for each.

输入参数url必填method

版本历史

1
  1. v1.0.0最新Nov 22, 2026

评分

已满足适用检查项的 90%

该评分衡量此收录条目的完整程度,依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价,也不表示服务器安全或当前可用:可连通性是带日期的检查结果,评分也不包含安装量或用户评价。

  • 近 30 天内可连通必需25 分
  • 已声明认证方式必需10 分
  • 已列出工具必需15 分
  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分

    请在仓库或注册中心条目中声明许可证。

其他 Watch 集成