AI agent that crawls paid data, reasons about value with Venice AI, and pays gasless via MetaMask Smart Accounts - fully autonomous, zero human in the loop.
A protocol-level platform that enables AI agents to crawl paid data sources, reason about value versus cost using Venice AI, execute gasless payments via MetaMask Smart Accounts (ERC-7715/ERC-7710) through the 1Shot Permissionless Relayer, and synthesize comprehensive insights — all without human intervention. Built on Base, we transform the emerging pay-per-crawl economy into a seamless, permissioned, and fully autonomous experience.
The AI agent economy is exploding — autonomous agents need real-time, high-quality data to make decisions. But premium data sits behind paywalls, and agents have no way to pay for it without human intervention.
Current workflow: Agent encounters paywall → stops → waits for human to manually approve payment → human opens wallet → confirms transaction → agent resumes. This breaks the entire promise of autonomous AI.
Traditional payment APIs require API keys, credit cards, or manual crypto wallet interactions — none of which work for autonomous software agents that need to make thousands of micro-payment decisions per day.
Data providers want to monetize their content to AI agents but face infrastructure challenges:
No standard protocol for HTTP-native pay-per-request
Existing payment solutions require complex smart contract deployments
Revenue tracking and verification is manual and error-prone
No visibility into who is buying what and when
A $0.10 data purchase should not cost $2.00 in gas fees. For agent-driven micro-payments to work economically, gas sponsorship is not optional — it is essential.
We built PayCrawl — an end-to-end autonomous pay-per-crawl system where AI agents reason about data value, pay for resources gaslessly via MetaMask Smart Accounts, and synthesize insights without any human in the loop.
Traditional approach: "Agent hits paywall → stops → human manually approves $0.10 payment → agent resumes"
PayCrawl approach: "Agent hits paywall → Venice AI evaluates if the data is worth the price → agent pays autonomously via stored permissions → agent retrieves data and continues"
Same data. Zero human intervention. Fully autonomous.
HTTP-native pay-per-request protocol implementation — no SDK integration required for clients
Gateway returns standard HTTP 402 with structured accepts[] JSON payment schema
Resources are protected behind paywall middleware — free catalog browsing, paid data access
Provider dashboard with real-time revenue tracking, purchase history, and transaction explorer links
Works with any HTTP client — agents don't need special libraries
One-time MetaMask popup grants fine-grained spending permissions via ERC-7715 erc20-token-periodic type
Spending cap enforced: $1.00 USDC per 24-hour period with 7-day permission expiry
Users can revoke permissions at any time — agent stops immediately
Permissions are stored as permissionsContext (hex-encoded delegation data) for autonomous reuse
Built with MetaMask Smart Accounts Kit v1.6.0 and erc7715ProviderActions
1Shot Permissionless Relayer executes ERC-7710 transactions on behalf of the agent — zero gas for the user
Agent encodes ERC-20 USDC transfer calldata, attaches stored permissionsContext, submits to relayer
Relayer verifies delegation, sponsors gas, submits on-chain transaction
Agent confirms on-chain payment via relayer_getStatus polling, then notifies gateway to authorize access — bridging the gap between off-chain reasoning and on-chain settlement
Leverages EIP-7702 smart account capabilities via MetaMask Smart Accounts Kit
Venice AI powers a 4-phase autonomous pipeline:
• Scout: Evaluates each resource on freshness, source verification, confidence, and price. Outputs a numerical score (0-100) per resource.
• Buyer: Deterministic execution: auto-purchases resources scoring ≥70, skips anything below 50. No AI tool-chaining — code-driven for reliability.
• Analyst: Reviews purchased content quality and assesses ROI against the Scout's predictions.
• Synthesis:Composes a comprehensive final report from all purchased data points.
Budget-aware prompts refresh every iteration with remaining spending capacity. Cost-per-value analysis: "5 verified sources at $0.60 = $0.12/source — good value" vs "1 unverified source at $0.40 = overpriced". The agent actively decides to skip low-quality resources — not everything that costs money is worth buying.
Mock API (Go, port 18091) — Paid content data provider serving 3 crypto market reports at different price points and quality levels. Reports include detailed market analysis with key metrics, multi-source verification, risk factors, and confidence scores.
Gateway (Go, port 19090) — x402 middleware intercepting requests to paid resources, returning HTTP 402 + accepts[] payment schema. Manages payment authorization with TTL-based access tokens, agent-confirmed payments, and a real-time provider dashboard with revenue charts, resource cards, and purchase history.
Agent (TypeScript, CLI) — Venice AI-powered reasoning engine with function calling loop. Three payment modes: live (autonomous via 1Shot relayer), bridge (interactive browser approval), and stub (direct webhook for development). Wallet bridge WebSocket server connects CLI agent to MetaMask browser extension for one-time permission setup.
User opens browser wallet bridge → connects MetaMask Flask → grants ERC-7715 permissions with spending cap → permissionsContext stored locally
Agent CLI starts → fetches stored context → encounters x402 paywall → Venice AI reasons about value → agent executes gasless payment via 1Shot relayer using stored context → gateway authorizes access → agent retrieves data
Agent never asks for permission again. User never sees another popup. Fully autonomous until permissions expire or are revoked.
Demo Scenario — The Proof
Query: "Summarize this week's Asian crypto market sentiment, then provide an in-depth analysis."
Budget: $1.00 USDC
Resource | Price | Quality Signals | Decision | Reasoning |
|---|---|---|---|---|
Asia Daily | $0.10 | Fresh (4h), 3 verified sources, 87% confidence | Buy | $0.033/source — excellent value for daily overview |
Quick Take | $0.40 | Stale (9 days), 1 unverified source, 23% confidence | Skip | $0.40 for stale, unverified data — not worth it |
Deep Dive | $0.60 | Fresh (today), 5 verified sources, 94% confidence | Buy | $0.12/source — essential for in-depth analysis |
Agent spends $0.70 of $1.00 budget. Venice AI maximized data quality per dollar — not the cheapest price. The agent chose to pay MORE for the deep-dive ($0.60) because it delivers 5 verified sources at a better per-source rate than the cheap but stale quick-take ($0.40 for 1 source).
This is a decision that only an AI can make — evaluating freshness, verification status, source count, and confidence against price. A simple script would just buy the cheapest or buy everything. Venice AI makes nuanced value judgments.
Step 1: Start wallet bridge server — cd agent && npx tsx src/wallet/wallet-bridge.ts
Step 2: Open browser to localhost:3000 — see 3-step flow indicator: Connect → Grant Permissions → Agent Autonomous
Step 3: Connect MetaMask Flask wallet on Base Mainnet
Step 4: Click "Grant Permissions (ERC-7715)" — MetaMask popup shows spending cap ($1.00 USDC/24h), token (USDC), and permission type (erc20-token-periodic)
Step 5: Approve in MetaMask — permissionsContext stored locally for agent use
Step 6: Dashboard shows permission details: spending cap, expiry, status = ACTIVE
Step 1: Agent starts with research query — cd agent && npx tsx src/index.ts "Summarize Asian crypto sentiment"
Step 2: Agent fetches catalog — sees 3 available resources with prices, freshness, source counts, and verification status
Step 3: Agent encounters HTTP 402 paywall on each resource — gateway returns accepts[] with payment details
Step 4: Venice AI reasoning loop begins — evaluates each resource's value proposition
Step 5: For resources worth buying — agent encodes ERC-20 USDC transfer, attaches permissionsContext, submits to 1Shot relayer for gasless execution
Step 6: Agent confirms on-chain payment via relayer_getStatus → notifies gateway to authorize access
Step 7: Agent re-fetches resource with X-AUTHORIZED-WALLET header → gateway passes request through to data provider
Step 8: Venice AI synthesizes all purchased data into comprehensive analysis with specific data points, metrics, and actionable insights
Step 9: Agent outputs final answer with budget summary — $0.70 spent, $0.30 remaining
Revenue updates in real-time on provider dashboard — revenue chart shows accumulation over time
Resource cards show purchase count per resource with progress bars
Purchase history table shows timestamp, resource, amount, buyer wallet, and transaction links
Click transaction link → opens BaseScan explorer for on-chain verification
They offer: Manual key management, monthly subscriptions, no granularity
We offer: Per-request HTTP-native payments, pay only for what you use, fully autonomous
They offer: Redirect to payment page, human approval required, credit card only
We offer: HTTP 402 protocol, zero-redirect, gasless crypto micro-payments with AI decision-making
They offer: Buy everything, no reasoning, unlimited spending risk
We offer: Venice AI evaluates quality vs price, respects budget cap, skips low-value resources
They offer: Complex deployment, locked funds, one-channel-per-provider
We offer: No smart contract deployment needed, protocol-level via MetaMask Smart Accounts Kit.
They offer: Agents need ETH for gas, funding management overhead
We offer: 1Shot Permissionless Relayer sponsors all gas, agents only need USDC for data payments
Best x402 + ERC-7710: Full x402 protocol implementation with HTTP 402 + accepts schema, ERC-7710 gasless execution via 1Shot relayer with stored permissionsContext from ERC-7715 grant, agent-side payment confirmation connecting the two protocols end-to-end.
Best Agent: Autonomous agent that plans (catalog analysis), crawls (paywall detection), reasons (Venice AI cost-per-value analysis), pays (gasless via ERC-7710), and synthesizes (comprehensive multi-source analysis). Budget-aware with iterative refinement. Not a script — a reasoning system.
Best use of Venice AI: Venice AI is the core decision-making engine, not a wrapper. 4-phase pipeline (Scout → Buyer → Analyst → Synthesis).
Budget-aware system prompt that updates per iteration. Cost-value reasoning with explicit analysis ($0.12/source vs overpriced). Produces meaningful synthesis from purchased data — the AI output IS the product.
Best Use of 1Shot Permissionless Relayer: Full JSON-RPC client (getCapabilities, getFeeData, send7710Transaction, pollStatus) Gasless execution with agent-side payment confirmation and gateway authorization. No signup, no API key, no paymaster — true permissionless relaying.
Uses MetaMask Smart Accounts Kit with Advanced Permissions (ERC-7715)
Integrates via @metamask/smart-accounts-kit npm package with erc7715ProviderActions
MetaMask Smart Accounts Kit in the main flow (permission grant → autonomous payment → data retrieval)
No custom smart contract deployment — fully protocol-level via EIP-7702 + ERC-7715 + x402
Working demo with 3 resources, Venice AI reasoning, and gasless payments
Repository: https://github.com/dwlpra/PayCrawl
Live Dashboard: https://paytocrawl.xyz
PayCrawl: Crawl. Reason. Pay. Synthesize. Autonomously.
Built for MetaMask Smart Accounts Kit × 1Shot API × Venice AI Dev Cook Off 2026
During this hackathon, we built a complete three-service architecture from scratch.
Implements the x402 HTTP-native paywall protocol with 402 + accepts[] schema.
Includes a payment authorization store with TTL-based access control and agent-confirmed payment authorization
Acts as a reverse proxy to the data provider.
Features a real-time provider dashboard with revenue charts and purchase history.
Venice AI powers a 4-phase pipeline: Scout (evaluate & score), Buyer (deterministic purchase), Analyst (quality review), Synthesis (final report).
Supports three payment modes: Live autonomous via 1Shot, Bridge interactive, Stub for development.
MetaMask Smart Accounts Kit: Integrated with ERC-7715 erc20-token-periodic permission granting, storing the permissionsContext for autonomous gasless execution.
1Shot Permissionless Relayer: A JSON-RPC client that handles getCapabilities, getFeeData, send7710Transaction, and pollStatus.
WebSocket Wallet Bridge: Connects the CLI agent to the MetaMask browser extension with a polished browser UI showing the 3-step flow: Connect → Grant → Autonomous.
Serves 3 richly detailed crypto market reports featuring:
Key metrics & multi-section analysis.
Risk factors & confidence scores.
Verification metadata.
Provides Venice AI with substantial data to reason about and synthesize.
The full end-to-end flow is live on Base Mainnet with real USDC payments.
Not Fundraising / Bootstrapped