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

# Units

I bill inference in units. Each unit is worth exactly $0.01, paid in USDG, so 1 USDG gets you 100 units. You top up with USDG, then spend units on requests. Heads up: my API and contracts call units "credits", so you'll see identifiers like `credits_remaining` and `credit.low`. They mean the same thing.

I use units to keep your everyday spending apart from on-chain settlement. Instead of approving a USDG transfer on every single message in a conversation, you top up once and I draw that balance down across as many jobs as you want. You never approve anything per message.

***

## The quick facts

| Property         | Value                                                                        |
| ---------------- | ---------------------------------------------------------------------------- |
| Value            | 1 unit = $0.01 USDG (1 USDG = 100 units)                                     |
| Purchased with   | USDG (ERC-20) on Robinhood Chain                                             |
| Transferable     | No; your units stay with you and can't be sent to anyone else                |
| Expiry           | Never                                                                        |
| Minimum purchase | 100 units ($1.00 USDG)                                                       |
| Refundable       | Yes; you can withdraw unspent units as USDG through my `job_escrow` contract |

I made units non-transferable on purpose, and I don't see it as a limitation. It means there's no secondary market for units, and my accounting stays dead simple: one balance per person.

***

## Topping up your balance

**In my web app:**

1. Sign in at `theacompute.com/app/login`, then open Settings
2. Under "Your units", pick "Add more units" to open "Top up your units"
3. Tell me how much USDG you want to convert (1 USDG = 100 units)
4. Send exactly that amount on Robinhood Chain to the escrow address I show you
5. Tap "I've sent my USDG" and I'll confirm the transfer on-chain

Your USDG lands in my `job_escrow` contract, which records your balance. I sponsor gas through ERC-4337, so you never need to hold ETH. Robinhood Chain confirms a block every \~100ms, so once I've confirmed your transfer, your balance updates quickly.

**Through my API:** I don't have a purchase endpoint. You top up units from Settings in the web app.

***

## What each request costs

| Tier     | Model range                 | Cost per request |
| -------- | --------------------------- | ---------------- |
| Lite     | 1B to 3B parameter models   | 2 units ($0.02)  |
| Standard | 7B to 8B parameter models   | 8 units ($0.08)  |
| Pro      | 13B to 27B parameter models | 18 units ($0.18) |
| Max      | 70B+ parameter models       | 40 units ($0.40) |

Those per-request prices cover completions up to about 500 output tokens. Past that, I switch to charging a rate per 1,000 output tokens:

| Tier     | Per 1,000 output tokens |
| -------- | ----------------------- |
| Lite     | 1 unit ($0.01)          |
| Standard | 4 units ($0.04)         |
| Pro      | 9 units ($0.09)         |
| Max      | 20 units ($0.20)        |

I lock whatever a request costs in escrow before it runs. If a job fails or times out, I put the locked units back in your balance without you having to do anything.

***

## Seeing your balance

**In the app:** I always show your balance in the top bar as "N units", and Settings shows it under "Your units" along with what it's worth in USDG.

**API:** Call `GET /v1/account` with your API key, and I'll send back `credits_remaining` (your units) and `usdg_value`.

```json
{
  "wallet": "0x7c41f9b8d2a6e3054cf18a9b62d47e0c93f5a1b8",
  "credits_remaining": 1420,
  "usdg_value": 14.20,
  "last_topup_at": "2026-06-15T09:43:00Z"
}
```

**On-chain:** Your actual balance sits in my `job_escrow` contract, keyed by wallet address. You don't need to trust my dashboard on this: query the Robinhood Chain JSON-RPC yourself (`https://rpc.mainnet.chain.robinhood.com`), or find it on Blockscout at `robinhoodchain.blockscout.com`.

***

## Warnings when you're running low

Pick a threshold and I'll fire a webhook any time your balance drops below it. The event is `credit.low`, and you'll find the details on my \[Webhooks page]\(

). You manage webhooks in Settings.

In Chat, if your balance can't cover the model you picked, I tell you what it costs per request and link you straight to "Add more units".

***

## Getting unused units back out

My web app doesn't have a withdraw button. Your unspent units can still come back out as USDG: call `withdraw` on my `job_escrow` contract with the number of units (the contract calls them credits) you want to redeem.

```solidity
function withdraw(uint256 creditsToWithdraw)
```

That single call turns the units back into USDG at the fixed rate and sends it out of my `job_escrow` contract to your wallet. I don't charge a withdrawal fee.

**Before you delete your account:** deleting it erases your account for good and forfeits any units you haven't used. If you want that USDG back, withdraw first.

***

## Units and $THEA are different things

These are two separate instruments, and they do two separate jobs for me.

|           | Units                                 | $THEA                                          |
| --------- | ------------------------------------- | ---------------------------------------------- |
| Purpose   | Paying me for inference jobs          | Staking, governance, and earning protocol fees |
| Value     | Always fixed at $0.01 USDG            | Whatever the market price is                   |
| Earned by | Buying them with USDG                 | Providing compute, or staking                  |
| Spent on  | Your inference requests               | Staking (locked up, never spent)               |
| On-chain  | A balance in my `job_escrow` contract | An ERC-20 token balance                        |

You don't need any $THEA to use me, and you don't need any units to provide compute for me. The two never cross paths.


---

# 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.theacompute.com/core-concepts/credits.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.