> For the complete documentation index, see [llms.txt](https://docs.robincompute.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.robincompute.org/quickstart.md).

# Quickstart

`$ no signup. no ETH. bring a wallet.`

Three doors into RobinCompute: user, developer, provider. All three are open today, and none asks for more than an Ethereum wallet.

***

## Users: run your first inference

**Prerequisites:** An Ethereum wallet (MetaMask, Rabby, and Robinhood Wallet all work) holding a small amount of USDG. ETH is never required, because RobinCompute sponsors gas through ERC-4337.

**Takes:** Less than 5 minutes.

**1. Connect a wallet**

Open [robincompute.org/app](https://robincompute.org/app) and hit "Connect wallet." That is onboarding, complete. No email address, no registration form.

**2. Fund some credits**

Inference is priced in credits: one credit is $0.01 USDG. Start with as little as $1.

Choose "Add credits," pick an amount, and confirm the USDG transaction in your wallet. The credits appear immediately.

**3. Pick a model and chat**

Pick any model from the list. **Qwen3 8B** (Standard tier, 8 credits per request) is a good default: fast, capable, and hosted by enough workers that it is always reachable.

Send a message. Your browser encrypts the prompt before it leaves, a worker picks up the job, inference runs, and tokens stream back to your screen.

That's it. No log exists anywhere, and the job's payment settled on Robinhood Chain.

***

## Developers: hit the API

**Prerequisites:** A wallet holding USDG, plus an API key generated from the dashboard.

**Takes:** Less than 10 minutes.

**1. Generate an API key**

Sign in at [robincompute.org/app](https://robincompute.org/app), open Settings, and create a key. Keys look like `rcompute_live_...` and spend from the credit balance of the wallet that created them.

**2. Send a request**

The API speaks the OpenAI wire format. Change one line (the base URL) and keep your code:

```python
from openai import OpenAI

client = OpenAI(
    base_url="https://api.robincompute.org/v1",
    api_key="rcompute_live_your_key_here"
)

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Explain optimistic rollups in plain terms."}],
    stream=True
)

for chunk in response:
    print(chunk.choices[0].delta.content or "", end="", flush=True)
```

```typescript
import OpenAI from "openai"

const client = new OpenAI({
    baseURL: "https://api.robincompute.org/v1",
    apiKey: "rcompute_live_your_key_here"
})

const stream = await client.chat.completions.create({
    model: "qwen3-8b",
    messages: [{ role: "user", content: "What is an ERC-4337 smart account?" }],
    stream: true
})

for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content ?? "")
}
```

**3. Verify the receipt on-chain**

Every API call ends in a Robinhood Chain transaction. Read the `x-robincompute-job-id` and `x-robincompute-tx-hash` response headers; the second is the transaction hash. Look it up on Blockscout at `robinhoodchain.blockscout.com` and confirm the payment yourself. No need to take our word for it.

***

## Providers: put a GPU to work

**Prerequisites:** A browser with WebGPU support (Chrome 113 or newer) and an Ethereum wallet. Browser workers start with zero USDG.

**Takes:** Less than 5 minutes.

**Browser worker (nothing to install)**

1. Open [robincompute.org/app](https://robincompute.org/app) and choose "Earn."
2. Connect your wallet.
3. The page checks your browser for WebGPU support and reads the available VRAM.
4. Pick a model your hardware can run.
5. Press "Start Earning."

Jobs arrive within seconds. Each completed job pays USDG straight to your wallet, and you can close the tab whenever you like. Your GPU has a day job now.

**Native worker (better payouts)**

The \[Native Worker guide]\(

) walks through installation and configuration. Native workers earn more per job, run larger models, and qualify for the staking multiplier, which lifts your payout share from 75% to 85%.

***

## Launch model lineup

| Model         | Tier     | Cost per request   | VRAM required |
| ------------- | -------- | ------------------ | ------------- |
| Llama 3.3 70B | Max      | 40 credits ($0.40) | 48GB+         |
| DeepSeek R1   | Max      | 40 credits ($0.40) | 48GB+         |
| Qwen3 8B      | Standard | 8 credits ($0.08)  | 8GB+          |
| Mistral 7B    | Standard | 8 credits ($0.08)  | 8GB+          |
| Llama 3.2 3B  | Lite     | 2 credits ($0.02)  | 4GB+          |
| Qwen3 1.7B    | Lite     | 2 credits ($0.02)  | 3GB+          |

Past roughly 500 output tokens, billing switches from the flat per-request price to a per-1,000-output-token rate.

***

## Keep going

* \[Core Concepts]\() walks the network from job submission to settlement
* \[API Reference]\() documents every endpoint
* \[Providers: Browser Worker]\() covers browser worker setup in depth
* \[Providers: Native Worker]\() is the complete native installation guide
* \[Staking]\() shows how to unlock the 85% payout multiplier


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.robincompute.org/quickstart.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.