# datasieve [Health: Active]

**Category:** 📊 Monitoring  
**Repository:** https://github.com/gitwormq/datasieve-mcp  
**GitHub Stars:** 0  
**npm Downloads (last month):** 217  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/datasieve

## Description
On-chain watches, web-page monitors, dead-man switches, cron, and agent coordination, paid via x402.

## Tools
Capabilities this server exposes over MCP:

- **create_watch** — Buy a standing watch from DataSieve (https://api.datasieve.xyz). standard = $0.10/7d, 1 condition, 50 triggers; composite = $0.25/7d, up to 5 any-match conditions (e.g. 5 heartbeat dead-man switches), 200 triggers; standard30 = $0.35/30d and composite30 = $0.85/30d — one payment covers the month, for agents that will not be awake to renew weekly. Payment is a gasless USDC transfer signed locally. Events go to your webhookUrl (HMAC-signed) if set, and always to a server-side mailbox drained with drain_events; every event carries a signed Ed25519 observation receipt you can replay to third parties. Failed calls are never billed. The watch id + secret are remembered locally so later calls need only the id.
- **watch_status** — State, heartbeat lastCheckedAt, triggersUsed/cap, expiry, delivery stats, and for dead-man switches: up/down, lastPingAt, nextDeadline, pingUrl. Secret is looked up from local state if omitted.
- **drain_events** — Collect everything the watch caught — works with zero infrastructure (the mailbox pattern). Pass `since` = last seen event id for incremental drains.
- **renew_watch** — Extends the watch one more period (7 days, or 30 on the *30 tiers) at its tier price and resets the trigger budget. Renewing a paused watch also reactivates it.
- **delete_watch**
- **pause_watch** — Stop a watch firing (chain, web, heartbeat, schedule) without deleting it. The expiry clock keeps running. Use before a planned agent shutdown so your dead-man switch does not cry wolf.
- **resume_watch** — Backlog-free resume: heartbeat deadlines restart from now and schedules jump to their next FUTURE slot — nothing that elapsed during the pause replays.
- **cron_next** — Next N run times for a cron expression in any IANA timezone, plus seconds-until-next. If the goal is for something to HAPPEN at those times, create_watch with a schedule condition instead — DataSieve fires the cron as signed webhooks for the life of the watch.
- **x402_ping** — The cheapest possible real x402 purchase: proves this wallet + client can pay a production seller before you point it at anything expensive. Returns payer + network; failed calls are never billed.
- **verify_receipt** — Every DataSieve event carries receipt {alg, keyId, statement, sig} — an Ed25519 attestation that DataSieve observed the event. This checks it against the service key, so an agent can validate evidence handed to it by ANOTHER agent without trusting that agent.
- **ping_heartbeat** — Keep a dead-man switch alive. Pass the pingUrl from create_watch (or a watchId whose ping URLs are in local state). Call this at least once per intervalSeconds.
- **service_health** — Scanner cursor lag vs chain head — verify the watcher is alive before you buy.
- **payment_status** — Check whether a buying key is configured and whether it can afford a watch. Reports the wallet address, its USDC balance on the configured network, and what each tier costs. Call this before create_watch; it never spends anything.
- **coord_workspace** — Buy a coordination workspace ($0.25 / 7 days, 1000 ops) — the only x402 seller of multi-agent primitives. After this ONE payment, every barrier and lock operation is FREE and FAST (no per-op settlement). Use it to fan-in sub-agents (coord_barrier) and to stop two agents doing the same irreversible thing (coord_lock).
- **coord_barrier** — BARRIER: "wake me when all N of my sub-agents finish." Returns an arriveUrl — hand it to each sub-agent (it is a capability: they can arrive but cannot read or delete your workspace). When the N-th part arrives we fire ONE webhook carrying every part's collected context. If the TTL passes first you get a "partial" event naming exactly who never showed. Timeout is a feature, not an error.
- **coord_arrive** — Report that this part is done. Pass the arriveUrl from coord_barrier plus a part name and optional ctx (whatever you want handed to whoever consumes the released barrier). Idempotent per part: a retrying agent cannot inflate the count.
- **coord_lock** — LOCK: "only one agent does this irreversible thing." Returns a leaseId, or 409 with who holds it. The lease AUTO-EXPIRES after ttlSeconds, so a crashed agent can never deadlock your fleet. Call coord_release when done (or just let it expire).
- **coord_release**
- **coord_events** — Collect barrier releases/partials that happened while nothing of yours was running.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "datasieve": {
    "command": "npx",
    "args": ["-y","datasieve-mcp"]
  }
}
```

## Documentation & README

# datasieve-mcp

MCP server for [DataSieve](https://datasieve.xyz) — standing infrastructure for
AI agents, paid over x402. On-chain conditions on Base (wallet activity, whale
transfers, price crossings, new pools), **url-change web monitoring** (CSS
selector / regex scoped), **dead-man switches for your own agents** (your agent
pings a URL; silence fires the alert), **cron schedules** (fire a webhook every
N seconds, at a time, or on a cron expression), and **multi-agent coordination**
(barriers + locks). Every event carries a signed Ed25519 observation receipt.
No account, no API key: one gasless USDC payment per watch, signed locally —
your key never leaves your machine. Failed calls are never billed.

## Setup — no key required to start

```sh
claude mcp add datasieve -- npx -y datasieve-mcp
```

Most tools work with **no wallet at all** — check our scanner's health, read
watch status, drain events, ping dead-man switches, pause/resume, verify
receipts, cancel watches. Only the buying tools spend money.

### The Claude Code skill (recommended)

```sh
npx -y datasieve-mcp --install-skill
```

Installs a skill into `~/.claude/skills/datasieve/` that teaches Claude when to
reach for standing infrastructure proactively: arm a dead-man switch before
long autonomous work, schedule wake-ups, watch pages and wallets, coordinate
sub-agents.

### When you want to buy

x402 means paying is a signature, so purchases need a key. Two rules:

1. **Use a dedicated burner wallet** holding a few dollars of USDC on Base —
   never your main wallet. Payments are gasless (EIP-3009), so it needs no ETH.
2. **Keep the key out of config files** — point at a file instead:

```sh
echo '0xYOUR_BURNER_KEY' > ~/.datasieve/key.txt && chmod 600 ~/.datasieve/key.txt
claude mcp add datasieve -e DATASIEVE_PRIVATE_KEY_FILE=$HOME/.datasieve/key.txt -- npx -y datasieve-mcp
```

(`DATASIEVE_PRIVATE_KEY=0x...` inline also works if you prefer.)

The key never leaves the process: each payment is a signature authorizing
**exactly** the route price — one at a time, nothing standing. Run
`payment_status` to see the wallet, its balance, and prices before spending
anything.

### Rehearse for free

```sh
claude mcp add datasieve-sandbox -e DATASIEVE_API_URL=https://staging.datasieve.xyz \
  -e DATASIEVE_PRIVATE_KEY_FILE=$HOME/.datasieve/key.txt -- npx -y datasieve-mcp
```

Same API, Base Sepolia, [faucet USDC](https://faucet.circle.com). Sandbox
watches last 1 hour.

## Tools

| tool | cost | what |
|---|---|---|
| `create_watch` | $0.10 (standard/7d) · $0.25 (composite/7d, ≤5 conditions) · $0.35 (standard30/30d) · $0.85 (composite30/30d) | buy a watch; returns id, secret, ping URLs |
| `renew_watch` | tier price | one more period, trigger budget reset |
| `coord_workspace` | $0.25 / 7d | multi-agent barriers + locks; every op after is free |
| `cron_next` | $0.001 | parse a cron expression: next N run times, any timezone |
| `x402_ping` | $0.001 | end-to-end payment stack self-test |
| `watch_status` | free | heartbeat, triggers, expiry, up/down per dead-man switch |
| `drain_events` | free | collect everything caught while you weren't running |
| `pause_watch` / `resume_watch` | free | stop firing without deleting; backlog-free resume |
| `ping_heartbeat` | free | keep your dead-man switch alive |
| `verify_receipt` | free | check the Ed25519 receipt on any delivered event |
| `coord_barrier` / `coord_arrive` / `coord_lock` / `coord_release` / `coord_events` | free | workspace ops |
| `delete_watch` | free | cancel |
| `service_health` | free | verify our scanner is alive before you pay |
| `payment_status` | free | wallet address, USDC balance, prices — "can I buy?" |

Watch ids and secrets are remembered in `~/.datasieve/watches.json` (mode 600),
so follow-up calls only need the watch id — the persistent memory your
ephemeral agent lacks.