DOCS

LULL, resources to revenue.

Turn idle GPUs, agents, APIs, PCs, wallets, and datasets into paid endpoints. Add a resource, let AI configure the gateway, earn 85% of every call. The 15% fee splits into 10% $LULL burn and 5% development.

START HERE

What is Lull?

Turn idle resources into paid API endpoints. 2-minute overview of the gateway model.

Read

Quickstart — 90 seconds

Sign in, add a resource, deploy your gateway, start earning from API calls.

Read

Architecture

Gateway, resource registry, metering layer, and how payouts flow back to you.

Read
RESOURCE GUIDES

Add a GPU

Expose GPU compute as an inference endpoint. NVIDIA 8GB+ VRAM, auto-priced by Lull AI.

Read

Add an agent

Wrap any AI agent as a callable API. Lull AI configures rate limits and auth for you.

Read

Add an API

Proxy an existing REST or GraphQL service through the Lull gateway with metered billing.

Read

Add a PC

Share idle CPU cycles. Desktop app runs jobs in a sandbox, pays per compute-minute.

Read

Monetize a wallet

Let your wallet earn via on-chain strategies on Morpho. Non-custodial, you sign every transaction.

Read

Share data

Serve datasets or embeddings through a read-only API. Priced per query or per GB.

Read

Partner integration

Register agent endpoints via API key. One POST from your deploy flow — auto-gateway, instant earnings.

Read
PLATFORM

Pricing & metering

How API calls are metered, how pricing works, and what the 85/15 split (10% burn, 5% dev) means for you.

Read

Gateway specs

Latency SLAs, rate limits, authentication, and the edge network topology.

Read

$LULL buyback-burn

Platform fees fund hourly buybacks. What gets burned, recent on-chain burns.

Read

System status

Gateway health, resource uptime, metering pipeline status.

Read

Changelog

Every release shipped. Latest work in chronological order.

Read
RESOURCE TYPES

7 resource types. One gateway.

Add a resource
GPU
Inference-as-a-service

Expose your NVIDIA GPU as a managed inference endpoint. The gateway handles batching, queue management, and auto-scaling. You provide the hardware, Lull handles the API layer.

Requires: NVIDIA GPU, 8GB+ VRAM, Linux or Windows with Docker
Pricing: Per compute-minute, auto-priced based on GPU model and utilization
85% of every API call to your endpoint
Agent
Agent-as-a-service

Wrap any AI agent — custom, LangChain, CrewAI, AutoGen — as a callable API. Lull AI configures auth, rate limits, and input validation. Callers pay per invocation.

Requires: Agent with HTTP or WebSocket interface, any hosting
Pricing: Per invocation, priced by average latency and token usage
85% of every agent call
API
Metered API proxy

Already have a REST or GraphQL service? Proxy it through the Lull gateway to add metered billing, auth, and rate limiting without changing your backend.

Requires: Publicly reachable API endpoint (HTTPS)
Pricing: Per request or per response-byte, configurable
85% of metered usage fees
PC
Idle compute cycles

Install the Lull desktop agent and share unused CPU cycles. Jobs run in a sandboxed environment — your machine, your rules on when it runs.

Requires: Any desktop or laptop, 4GB+ RAM, macOS / Windows / Linux
Pricing: Per compute-minute, auto-priced based on CPU benchmark
85% of compute fees
Wallet
On-chain yield strategies

Connect your wallet and let Lull route funds into vetted Morpho vaults on Base. Non-custodial by construction — you sign every transaction, Lull never holds your keys.

Requires: Base wallet with USDC
Pricing: Performance fee on earned yield only
85% of generated yield after fees
Data
Datasets and embeddings

Serve proprietary datasets, embeddings, or knowledge bases through a read-only API. Consumers pay per query or per GB transferred. You control access and pricing.

Requires: Structured data, embeddings, or files hosted anywhere
Pricing: Per query or per GB, configurable
85% of data access fees
QUICKSTART

90 seconds from idle to earning.

01 — SIGN IN

Privy handles auth and provisions a Base wallet on first sign-in. Email or social — no seed phrase, no extension required.

$ visit earnlull.com/app -> sign in with email
02 — PICK A RESOURCE TYPE

Seven supported types: GPU, agent, API, PC, wallet, data, inference. Select the one that matches what you want to monetize.

$ earnlull.com/app -> Add Resource -> select type
03 — AI CONFIGURES YOUR GATEWAY

Lull AI analyzes your resource and suggests optimal pricing, rate limits, and metering. Review the config, adjust if you want, confirm.

$ LULL AI: "GPU A4000 -> $0.12/min inference, 50 req/s"
04 — DEPLOY AND START EARNING

Your resource goes live behind a Lull gateway endpoint. You earn 85% of every API call. Payouts settle in USDC on Base once your balance reaches $0.10.

$ endpoint live at gateway.earnlull.com/v1/your-resource
ARCHITECTURE

Three layers. That's it.

The gateway proxies API calls to your resource, meters usage, and settles payments to your wallet. Non-custodial by construction — you own the resource, you own the keys.

Gateway API reference
01
Gateway
Edge proxy network. Routes API calls to the nearest healthy resource, handles auth, TLS termination, and request validation.
02
Metering
Per-call usage tracking. Every request is logged with latency, tokens, compute-time. Bills the caller, credits the provider — real-time.
03
Settlement
Payouts settle in USDC to your Base wallet ($0.10 minimum). 85% to you, 15% platform fee. 10% buys and burns $LULL; 5% funds protocol development.
SYSTEM DIAGRAM 
Caller (API consumer)
    |
    |  HTTPS request + API key
    v
+-----------+        +-----------+        +-------------+
|  Gateway  | ----> |  Metering  | ----> |  Settlement |
|   (edge)  |        |   (usage)  |        |   (payout)  |
+-----------+        +-----------+        +-------------+
    |                                            |
    |  proxied request                           |  85% to provider
    v                                            v
+-----------------+                  +-----------------+
|  Your Resource  |                  |   Your Wallet   |
|  GPU / Agent /  |                  |     (Base)      |
|  API / PC / Data|                  |                 |
+-----------------+                  +-----------------+

One API call. Agent starts earning.

Register your AI agent endpoints on Lull programmatically. Every time your deploy pipeline creates a new agent, hit our registration API with the endpoint URL and wallet. We auto-generate an x402 gateway — your agent earns 85% of every API call through it.

STEP 1 — REGISTER YOUR AGENT
curl -X POST https://api.earnlull.com/v1/partner/register \ -H "Content-Type: application/json" \ -H "x-api-key: YOUR_PARTNER_KEY" \ -d '{ "name": "My Content Agent", "endpoint_url": "https://my-agent.example.com/api", "wallet_address": "YOUR_BASE_WALLET", "capabilities": ["content-generation", "token-data"], "price_per_request": 0.003, "framework": "custom" }'
RESPONSE — GATEWAY IS LIVE
{ "resource_id": "1cb0e0d4-...", "gateway_url": "https://gateway.earnlull.com/v1/resources/1cb0e0d4-...", "name": "My Content Agent", "capabilities": ["content-generation", "token-data"], "price_per_request": 0.003, "status": "active", "dashboard_url": "https://earnlull.com/app/resources/1cb0e0d4-..." }

Authentication

x-api-key header with your partner key. Contact devs@earnlull.com to get one.

Payout split

85% to your wallet, 15% protocol fee (10% $LULL burn, 5% dev fund). USDC on Base. Partner wallets have no minimum — paid every cycle.

Multiple agents

Call /register for each agent. Same key, different endpoints. Each gets its own gateway URL.

STEP 2 — LIST YOUR AGENTS
curl https://api.earnlull.com/v1/partner/agents \ -H "x-api-key: YOUR_PARTNER_KEY" # Returns: { "agents": [{ id, name, status, total_earned_usd, total_requests, gateway_url }] }
STEP 3 — TEST YOUR GATEWAY (EXPECT 402)
# Hit your gateway URL — you should get a 402 with payment instructions. # This confirms your agent is registered and the gateway is routing to it. curl -s -w "\nHTTP_CODE: %{http_code}" -X POST \ https://gateway.earnlull.com/v1/resources/YOUR_RESOURCE_ID/query \ -H "Content-Type: application/json" \ -d '{ "task": "ping" }' # Expected 402 response: # { "x402Version": 1, "accepts": [{ "scheme": "exact", "network": "base", # "maxAmountRequired": "3000", "asset": "USDC_BASE_ADDRESS", # "payTo": "YOUR_TREASURY" }] } # maxAmountRequired is in USDC micro-units (3000 = $0.003)
HOW CONSUMERS CALL YOUR AGENT (X402 PAYMENT FLOW)
# 1. Consumer signs an ERC-3009 transferWithAuthorization for USDC on Base # 2. Consumer includes the signature in the request header: curl -X POST https://gateway.earnlull.com/v1/resources/RESOURCE_ID/query \ -H "Content-Type: application/json" \ -H "X-Payment: BASE_SIGNATURE_PAYLOAD" \ -d '{ "prompt": "Generate a blog post about Base" }' # Gateway verifies payment on-chain via Alchemy, proxies to your endpoint, # returns the response to the consumer. # Your wallet receives 85% via the next pay-cycle (every 5 min).
STEP 4 — CHECK YOUR EARNINGS
# List your agents: curl https://api.earnlull.com/v1/partner/agents \ -H "x-api-key: YOUR_PARTNER_KEY" # Full earnings breakdown (total earned, paid, pending, per-wallet, per-agent): curl https://api.earnlull.com/v1/partner/earnings \ -H "x-api-key: YOUR_PARTNER_KEY" # Returns: total_earned_usd, total_paid_usd, total_pending_usd, # per-agent breakdown (paid_usd, pending_usd, paid_jobs, pending_jobs), # per-wallet breakdown (total_earned, total_paid, total_pending). # Partner payouts run every ~5 min with no minimum threshold. # Dashboard: https://earnlull.com/app/resources/YOUR_RESOURCE_ID
QUICK-START TEST AGENT (COPY-PASTE)
# Minimal agent server (Node.js, zero deps) — save as agent.mjs, run with: node agent.mjs import http from 'node:http'; const server = http.createServer((req, res) => { if (req.method === 'POST') { let body = ''; req.on('data', c => body += c); req.on('end', () => { const parsed = JSON.parse(body || '{}'); res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ result: 'pong', task: parsed.task || 'unknown', ts: Date.now() })); }); } else { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ status: 'ok', uptime: process.uptime() })); } }); server.listen(process.env.PORT || 4000, () => console.log('Agent ready')); # Deploy anywhere (Railway, Render, Fly.io, VPS), then register: # POST /v1/partner/register with endpoint_url = your deployed URL