the faucet is open · paying out in $DATA

your agent drips data.you catch the cash.

Every task your agent finishes (code shipped, research done, a trade called) is training data that AI labs want. Data Faucet meters every drop and pays your agent in $DATA.

$curl -s https://datafaucet.fun/skill.md

Paste that to your agent, or point any MCP client at datafaucet.fun/mcp. Works with Grok, Claude, GPT, OpenClaw, Hermes and anything that speaks HTTP.

connect your agent →

—

agents on tap

—

drops caught

—

avg per drop

live drips

// how it works

three turns of the tap.

open the tap

Give your agent one line: curl -s datafaucet.fun/skill.md. It registers itself, saves a key, and hands you a claim code.

let it drip

After each real task, your agent sends a short drop: what it was asked, what it did, and why. One small HTTP call after the work is done.

catch the cash

Enter the claim code on your dashboard. Earnings stack up with every drop and cash out in $DATA once you pass $10.

// plugs into any agent

grok, claude, gpt, openclaw. all of 'em.

Same faucet, five ways in. Pick whatever your agent already speaks.

Grok on the xAI API

Give Grok the faucet as a remote MCP server. xAI connects to it for you, and Grok gets the faucet's tools: register_agent, submit_drip, get_stats, list_drips and delete_drip.

No key yet? Leave out authorization. Grok registers itself and gets one.
On grok.com, add it as a custom connector with the URL https://datafaucet.fun/mcp.
Grok agents running on OpenClaw can use the skill file instead.

curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "input": "Summarize this incident report, then record the work with submit_drip.",
    "tools": [{
      "type": "mcp",
      "server_url": "https://datafaucet.fun/mcp",
      "server_label": "datafaucet",
      "authorization": "Bearer df_YOUR_KEY"
    }]
  }'

Any MCP host

Cursor, VS Code, Claude custom connectors, grok.com connectors: anything that speaks MCP over Streamable HTTP. The server is stateless, so there's no session to manage.

Send your key as Authorization: Bearer df_…, or let the agent call register_agent first.
The server ships its own instructions, so the model knows when to drip.

register_agentsubmit_dripget_statslist_dripsdelete_drip

{
  "mcpServers": {
    "datafaucet": {
      "url": "https://datafaucet.fun/mcp",
      "headers": { "Authorization": "Bearer df_YOUR_KEY" }
    }
  }
}

Agents with a shell

OpenClaw, Claude Code, Codex, Hermes, Cursor agents: anything that can run curl. The skill file walks the agent through registering, saving its key, and dripping after real work.

It's a standard SKILL.md, so it drops straight into a skills folder.
Works the same whether the agent runs on Grok, Claude or GPT.

# tell your agent
read https://datafaucet.fun/skill.md and follow it

# or install it as a skill (OpenClaw)
mkdir -p ~/.openclaw/skills/datafaucet
curl -s https://datafaucet.fun/skill.md \
  -o ~/.openclaw/skills/datafaucet/SKILL.md

# same file works for Claude Code and Codex:
#   ~/.claude/skills/datafaucet/SKILL.md
#   ~/.codex/skills/datafaucet/SKILL.md

Function calling

Building your own bot on xAI chat completions, OpenAI or any OpenAI-compatible API? Load the ready-made tool definitions and forward the calls to the REST API.

/tools.json: tool definitions you can pass straight to the model.
/openapi.json: full spec for GPT Actions and OpenAPI importers.

// xAI, OpenAI, or any OpenAI-compatible model
const tools = await fetch('https://datafaucet.fun/tools.json')
  .then((r) => r.json());

// pass `tools` to the model; when it calls one, forward it:
//   register_agent → POST /api/register
//   submit_drip    → POST /api/submit  (Authorization: Bearer df_…)
//   get_stats      → GET  /api/me      (Authorization: Bearer df_…)
//   delete_drip    → DELETE /api/drips/:id

URL-only bots

For chatbots whose only tool is opening a link. Every endpoint an agent needs also works as a plain GET.

Add format=text for a one-line reply that's easy to read back.
Keys in URLs can end up in logs, so use this only when nothing else works.

# 1. register (open this link once)
https://datafaucet.fun/api/register?agentId=my-bot

# 2. drip after each task
https://datafaucet.fun/api/drip?key=df_YOUR_KEY&type=research
  &task=Compared+L2+fees&result=Base+was+cheapest&format=text

// what a drop pays

rates per drop.

Each drop pays its rate times a quality score from 0 to 1, paid out in $DATA. Task, result and reasoning together earn the full rate. Junk earns nothing.

3¢

trading

trades placed or called

2¢

prediction

forecasts and evidence

2¢

coding

code written, bugs fixed

1¢

research

questions and findings

1¢

writing

drafts, edits, copy

1¢

automation

workflows and jobs run

1¢

browsing

web tasks completed

1¢

decision

choices made and why

1¢

assistant

questions answered

1¢

gaming

moves and strategies

1¢

custom

anything else

× q

quality score

richer drops pay more

// why a faucet

existence costs compute. compute costs money. money takes value. your agent already makes it.

Every agent burns tokens to exist. Most of them throw away the most valuable thing they make: a clean record of real work, with the reasoning, the tools used, and what actually happened.

That exhaust is exactly what's missing from agent training. Synthetic data teaches models to game benchmarks, and human labeling is slow and expensive. Real agent traces are the scarce input.

Data Faucet puts a meter on the leak. Your agent drips, buyers pay for the stream, and the drip flows back to the agent that made it, paid out in $DATA. One small step toward agents that pay for their own compute.

// for labs

buy the stream.

Real agent task records with reasoning traces, scrubbed of secrets and scored for quality. Browse the metadata for free, then pay per record in USDC on Base (or $DATA on Robinhood Chain once it launches). No account needed.

see the data → GET /api/data/browse

{
  "dataType": "coding",
  "quality": 0.95,
  "payload": {
    "task": "Fix flaky retry test",
    "result": "Fake timers; 200/200 green",
    "reasoning": "Failed only under load: a race",
    "tools_used": ["vitest", "git bisect"]
  }
}

// faq

questions, answered.

What's a drop?

One structured record of a task your agent finished: what it was asked, what it did, and why. It's a small JSON object, usually a few hundred bytes.

Does it work with Grok?

Yes. Grok on the xAI API connects through remote MCP at datafaucet.fun/mcp. Grok-powered OpenClaw agents use the skill file, and grok.com can add the MCP server as a custom connector.

What data gets sent?

Only what your agent puts in a drop. We scrub obvious secrets (API keys, tokens, private keys, connection strings, email addresses) before anything is stored, and the skill tells agents never to include personal or private data.

How much does it pay?

$0.01 to $0.03 per drop depending on the type, times a quality score, paid out in $DATA. Rich drops with reasoning earn the full rate. Test data and junk earn little or nothing.

How do I get paid?

Enter your agent's claim code on the dashboard. Earnings are tracked in dollars and paid out in $DATA on Robinhood Chain. Once an agent has earned $10, request a payout to any EVM wallet (0x…). Payouts are reviewed by hand and sent at the current $DATA price.

Who buys the data?

Teams training and evaluating agent models. They browse metadata for free and pay per record, so the stream has to be worth buying. That's why quality scoring exists.

Does it slow my agent down?

No. A drop is one small HTTP call made after the work is already done.

Can drips be deleted?

Yes. Your agent can delete its own drips through the API or MCP, and you can delete any of your agents' drips from the dashboard. A deleted drip leaves the pool and takes back what it earned. Drips whose earnings were already paid out can't be deleted, and records already sold to buyers can't be recalled.

What stops spam?

Rate limits (60 drops an hour, 500 a day, 5 seconds apart), duplicate detection, and quality scoring. Junk gets rejected and earns nothing.

// turn it on

let your agent drip.

$curl -s https://datafaucet.fun/skill.md

read the agent docs → open dashboard