Carpe Diem — Documentation

1. Introduction

1.1 What is Carpe Diem?

Carpe Diem is an open marketplace for AI inference. You call state-of-the-art language, image, audio, and video models through a single OpenAI- and Anthropic-compatible API — and you pay only for what you use, with no account, no subscription, and no KYC.

Every request is served by Venice.ai, the privacy-first AI provider. Carpe Diem doesn't replace Venice — it builds on its ecosystem and opens its inference capacity to anyone.

For developers, that means drop-in compatibility with the tools you already use (OpenAI SDK, Anthropic SDK, Claude Code, Cursor, Cline) and usage-based pricing often well below direct rates. You pay with USDC on Base — fund a self-custodial prepaid account you own, buy credits, or (for agents) pay per request straight from a wallet (Ways to pay) — then spend per request. No subscription, no signup, your wallet is your account.

1.2 Who is it for?

Developers and AI agents who need reliable access to top AI models without managing a provider account. If you can call the OpenAI or Anthropic API, you can call Carpe Diem — point your existing SDK at our endpoint and pay with USDC: fund a self-custodial prepaid account you own, buy credits, or (for autonomous agents) pay per request straight from a wallet (Ways to pay).

DIEM holders who want to put their daily Venice allowance to work. Staking DIEM on Venice grants $1/day of inference per token; most of it goes unused. By provisioning a key to Carpe Diem, you turn that idle allowance into revenue — serving real inference demand and earning on every request.

Privacy-conscious users who want state-of-the-art AI without surrendering their identity. No email, no KYC, no usage profile tied to a name — your wallet is the only identifier, and requests run inside a hardware-sealed environment that operators cannot inspect.

1.3 Our place in the Venice ecosystem

Carpe Diem is not a competitor to Venice — it's an extension of it. Venice already offers private, no-KYC inference; Carpe Diem's role is to make the network's unused capacity productive.

Here's the mechanic. Staking DIEM on Venice grants a daily inference allowance — roughly $1 of credits per DIEM, refreshed every day. Most holders never consume their full allowance, and whatever isn't spent by the daily reset is simply lost.

Carpe Diem turns that idle allowance into a marketplace. A DIEM holder provisions a key, becomes a real inference provider, and earns on demand they would otherwise have wasted. A developer gets the same Venice models at a lower, market-driven price. And Venice's network sees more of its capacity actually used — which is exactly what DIEM was designed for: inference credit that circulates instead of sitting idle.

In short: Carpe Diem doesn't compete with Venice — it puts the ecosystem's idle capacity to work.

2. How it works

2.1 The big picture

A Carpe Diem request makes a round trip through the operator, which acts as a private proxy in front of Venice:

The operator sits on both legs of the trip: it forwards your request to Venice, then relays Venice's response back to you — debiting your credits along the way. Venice never talks to you directly, and you never hold a Venice key.

Three pieces make this work, and the next sections cover each:

• the escrow — an on-chain contract that holds funds and tracks balances,
• the operator — the routing engine that runs privately inside sealed hardware,
• Venice — the AI provider that performs the actual inference.

2.2 The three building blocks

The escrow — payments and balances, on-chain. The escrow is a single smart contract on Base. When you buy credits, your USDC is paid into it and an on-chain entry records your credit balance — the amount of inference you're entitled to spend. Credits are a usage entitlement, not a deposit: there is no withdrawal, and the incoming USDC becomes protocol funds that pay providers and run the network. (The other two rails — Prepaid and Wallet/x402, see Ways to pay — work differently: there the funds stay in an account you own and can withdraw from; the escrow only pulls the exact cost per request.) Because the contract is public, anyone can verify total balances and on-chain settlement at any time.

The operator — the private brain. The operator authenticates your API key, picks an available provider, forwards your request to Venice, and relays the response back. It runs inside a TEE (Trusted Execution Environment) — sealed hardware where even the host machine and the Carpe Diem team cannot read what's inside. This is what keeps your prompts and the providers' Venice keys confidential.

Venice — the inference. Venice.ai performs the actual model execution. The operator holds providers' Venice keys and uses them to serve your request; you never see or handle a Venice key yourself.

On-chain balance vs. live credit balance

Your credit balance is tracked in two places, and it's worth knowing why:

When you make a request, your live balance is debited instantly inside the operator. The on-chain entry only changes when you buy more credits, or when the operator periodically settles a batch of usage on-chain. Between settlements the two can differ: the on-chain figure reflects purchases, while the live figure reflects purchases minus everything you've already spent.

Think of it like a prepaid card: buying credits loads the card (recorded on-chain); each request is a tap that draws down the live balance instantly. The operator reconciles its books with the chain periodically — that's settlement.

2.3 The life of a request

From the moment you call the API to the moment providers get paid:

1. You send a request with your API key (cdm_…) to a standard endpoint like /v1/chat/completions.
2. The operator authenticates the key and resolves it to your wallet.
3. It runs a pre-flight check — do you have enough live credits, and does a provider have enough Venice capacity to serve this? If not, the request is refused cleanly, before any inference happens.
4. It picks a provider based on real-time health, available capacity, and the current dynamic price.
5. It forwards the request to Venice, which runs the model and returns the response to the operator.
6. It prices and debits — the operator computes the cost (Venice's raw cost × the current price multiplier), debits your live credit balance instantly, and records the usage.
7. It relays the response back to you, including headers that report your remaining credits.

Up to here nothing has touched the blockchain — it's all instant, inside the TEE. Paying providers happens separately:

8. Settlement. As usage accumulates, the operator periodically settles a batch on-chain in a single transaction: it converts the owed USDC into DIEM, distributes it to the providers who served the requests, and takes the protocol fee. This is the only on-chain write in the normal flow — batching it keeps the gas cost per request negligible.

3. Quick start

Four steps from zero to your first response. The whole setup lives in the dashboard.

3.1 Connect your wallet

Open the dashboard and connect any EVM wallet (MetaMask, Rabby, WalletConnect, …). Carpe Diem runs on Base, so your wallet should be able to switch to the Base network — the dashboard prompts you if needed. There's no email and no password: your wallet is your identity.

3.2 Add funds

From the dashboard, deposit USDC — pick how your balance is held:

• Prepaid (recommended). Deposit onto a dedicated account that's auto-created for you and that you own — one gas-free step. Same effort as credits, but self-custodial and withdrawable anytime.
• Credits. Or just buy credits (1 credit = $0.01, so $10 → 1,000 credits) — a non-refundable balance you top up and burn down, with no withdrawal.

Either way, funds are spent per request. Hold a different token? The deposit widget swaps it to USDC in the same transaction. Autonomous agents can skip this step and pay per request from a wallet. See Ways to pay.

3.3 Create an API key

Sign in once with your wallet (a free signature, no gas) to open your account area, then create an API key. It looks like cdm_… and is shown only once — copy it somewhere safe. You can create several keys and revoke any of them at any time.

3.4 Your first call

Point any OpenAI-compatible client at https://carpe-diem.xyz/api/operator/v1 and use your cdm_… key.

cURL

curl https://carpe-diem.xyz/api/operator/v1/chat/completions \
  -H "Authorization: Bearer cdm_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.3-70b",
    "messages": [{"role": "user", "content": "Hello in one sentence."}]
  }'

Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(
    base_url="https://carpe-diem.xyz/api/operator/v1",
    api_key="cdm_your_key_here",
)

resp = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Hello in one sentence."}],
)
print(resp.choices[0].message.content)

That's it — you're calling Venice models through Carpe Diem. From here, see the API Reference for every endpoint, or the guides below for streaming, images, video, and more.

4. Core concepts

4.1 Ways to pay

Carpe Diem is pay-per-use — no subscription, no minimum. There are three ways to pay, and the right one depends on who you are. All three settle in USDC on Base and pay the same dynamic price (next section); they differ only in how the money is held.

For people — Prepaid (recommended) or Credits

Both take the same single step — deposit USDC — and cost exactly the same per request. The only difference is what happens to your money.

Prepaid account (recommended). You deposit USDC onto a dedicated account that's created automatically for you and that you fully own (an ERC-4337 account controlled by your wallet). It's one gas-free step from the Prepaid tab — fund it and you're set; the account is auto-created and authorized in the same action. Carpe only ever pulls the exact per-request cost, and you can withdraw the balance back to your wallet anytime (or revoke to stop spending). Self-custodial: your funds stay yours until you spend them.

Credits. If you'd rather just top up a balance and burn it down — no account to withdraw from — buy credits instead. Same deposit, same per-request billing, but the balance is a non-refundable usage entitlement: your USDC becomes protocol funds and there is no withdrawal. (1 credit = $0.01, so $10 → 1,000 credits.)

You choose which rail backs a cdm_ key when you create the key, so applications using your key never have to think about payment again. Already on credits and want the withdrawable version? You can migrate your credit balance into your prepaid account (one signature, gas-free); migration only ever targets your own prepaid account, never a raw wallet payout.

For AI agents — Wallet (x402)

An autonomous agent that holds a private key and some USDC on Base can pay Carpe per request, straight from its wallet — no signup, no API key, no deposit. This is the x402 flow: the agent gets a 402 challenge, signs the payment locally (once as a reusable session, or per request), and Carpe settles the exact cost on-chain. See the API reference for the full x402 flow, the two payment schemes, and the agent SDK.

Billing — common to all three

• Every response reports the cost. Inference responses include headers showing what the request cost and how much balance remains — so agents can budget precisely.
• The price tracks Venice's underlying rate but is usually lower, because pricing is dynamic (next section).
• Check a cdm_-backed balance anytime with GET /v1/credits.

4.2 Dynamic pricing

Carpe Diem's price floats with how much of the day's shared inference capacity is still available — the more of the daily DIEM pool is left, the less you pay. The key guarantee: your total price, protocol fee included, never exceeds Venice's direct rate.

• A floor and a hard ceiling. Your all-in price ranges from a floor of about 15% of Venice's rate up to a maximum of 100% of Venice's rate — never more.
• The 5% fee is inside that ceiling, not on top of it. The demand-based part is capped so that, even at peak, demand + fee land exactly at Venice's rate. The fee never pushes you above it.
• Driven by daily pool usage. Each day, providers' staked DIEM refreshes a shared pool. When little of it has been used, prices sit near the floor; as it's consumed, they rise toward the ceiling.
• Your request's size matters too. The price is the higher of two things: how depleted the daily pool is, and how big your request is relative to the capacity that can serve it. A small request (a chat turn, an image) stays near the pool price; a large one (a video that eats a big share of remaining capacity) pays a premium for its footprint — you pay for your own demand, not just the time of day.
• Resets daily at 00:00 UTC.

Example. Say a request costs $0.10 at Venice's direct rate.

• Early in the day, pool mostly free → you pay about $0.015 (~15%).
• Late in the day, pool nearly used up → the same request rises toward $0.10 — Venice's rate, fee included, and never above.

Same request, same model — the price just reflects how much shared capacity is left.

See the live state (remaining pool, current price) on the dashboard or via GET /v1/capacity.

4.3 Authentication

Carpe Diem has two ways to authenticate, for two different jobs.

API keys (cdm_…) — for calling the API. This is what you use from your code, scripts, and agents. An API key is a long-lived bearer token: pass it as Authorization: Bearer cdm_… on any inference endpoint (/v1/chat/completions, /v1/image/generate, …). Keys don't expire, you can hold several, and you can revoke any of them instantly. Create and manage them from the dashboard.

Wallet sessions (SIWE) — for managing your account. Account actions — creating or revoking API keys, viewing your usage and balance in the dashboard — are authenticated by signing a message with your wallet (Sign-In with Ethereum). This produces a short-lived session token (JWT) the dashboard uses for you automatically. It's free (no gas) and refreshes while you stay active.

Which to use?

Inference endpoints accept either auth, which is why the in-browser playground can run on your wallet session — no API key needed just to try a model. From your own code, use an API key.

One rule worth noting: an API key cannot manage other API keys — creating or revoking keys always requires a wallet session. This keeps a leaked inference key from being able to mint more keys.

4.4 Models & tiers

Carpe Diem mirrors Venice's full model catalog — text, code, image, audio, video, and embeddings — through one API. The catalog is synced from Venice, so new models appear automatically.

Categories

Tiers — every model sits in one of three price tiers reflecting its underlying cost:

• Standard — everyday models, lowest cost (e.g. llama-3.3-70b).
• Premium — larger or specialized models.
• Frontier — the most capable (and most expensive) models.

The tier sets the base rate; the dynamic multiplier (§4.2) then applies on top, within the floor-to-Venice ceiling.

Discovering models — both read the same catalog with live per-model pricing:

GET /v1/models    # OpenAI-compatible flat list — works with client.models.list()
GET /models       # native: same catalog grouped by category (handy for a model picker)

Use /v1/models for drop-in SDK compatibility; use /models when you want models pre-grouped by type.

4.5 Privacy & security

Carpe Diem is built so that using AI doesn't mean exposing who you are or what you ask.

No identity. No email, no password, no KYC. Your wallet is the only identifier — nothing ties your requests to a real-world name.

Sealed execution (TEE). The operator runs inside a Trusted Execution Environment (Intel TDX on Phala Cloud) — hardware that even the host machine and the Carpe Diem team cannot read into. Your prompts and responses, the providers' Venice keys, and the live credit ledger all live inside this sealed environment.

Verifiable, not "trust us". The TEE can produce a hardware attestation proving exactly which code is running. Check it via GET /attestation or on Phala's public trust explorer — you don't have to take our word for what the operator does.

Transparent money. Everything touching funds is public and auditable on Base: deposits, settlements, fees, and total balances are all on-chain. Anyone can verify the protocol's solvency at any time.

In short: the sensitive parts (your data, the keys) stay sealed in hardware; the financial parts stay open on-chain. Privacy where it matters, transparency where it counts.

5. Guides

5.1 OpenAI SDK

Carpe Diem implements the OpenAI Chat Completions API, so the official OpenAI SDKs work unchanged — point them at our base URL and use your cdm_… key.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://carpe-diem.xyz/api/operator/v1",
    api_key="cdm_your_key_here",
)

resp = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain TEEs in one paragraph."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://carpe-diem.xyz/api/operator/v1",
  apiKey: "cdm_your_key_here",
});

const resp = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [{ role: "user", content: "Explain TEEs in one paragraph." }],
});
console.log(resp.choices[0].message.content);

Standard parameters work as expected: temperature, max_tokens, top_p, stop, stream (§5.3), and tool/function calling where the model supports it.

5.2 Anthropic SDK (Claude Code, Cursor, Cline)

Carpe Diem also implements the Anthropic Messages API at /v1/messages, so Anthropic SDKs and any tool speaking the Anthropic protocol — Claude Code, Cursor, Cline — work by changing two settings: the base URL and the API key.

Note the base URL differs from the OpenAI one — the Anthropic SDK appends /v1/messages itself, so point it at .../api/operator (no /v1).

Python (Anthropic SDK)

import anthropic

client = anthropic.Anthropic(
    base_url="https://carpe-diem.xyz/api/operator",
    api_key="cdm_your_key_here",
)

msg = client.messages.create(
    model="llama-3.3-70b",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain TEEs in one paragraph."}],
)
print(msg.content[0].text)

Claude Code / Cursor / Cline — set two environment variables and the tool routes through Carpe Diem:

export ANTHROPIC_BASE_URL=https://carpe-diem.xyz/api/operator
export ANTHROPIC_API_KEY=cdm_your_key_here

The model field takes a Venice model id (see /v1/models), not a Claude model name — set your tool's model accordingly.

5.3 Streaming

Set stream=true to receive tokens as they're generated, over Server-Sent Events (SSE). Both the OpenAI and Anthropic APIs support it.

Python

stream = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Write a haiku about the sea."}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

JavaScript / TypeScript

const stream = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [{ role: "user", content: "Write a haiku about the sea." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

The stream follows the standard OpenAI SSE format: data: lines carrying JSON deltas, terminated by data: [DONE]. Billing is identical to non-streaming — you're charged for the tokens actually generated.

5.4 Images

Three image endpoints, all called with your cdm_… key, all synchronous (one request → result).

Generate — POST /v1/image/generate

import requests

r = requests.post(
    "https://carpe-diem.xyz/api/operator/v1/image/generate",
    headers={"Authorization": "Bearer cdm_your_key_here"},
    json={
        "model": "venice-sd35",     # any image model from GET /v1/models
        "prompt": "a lighthouse at dawn, watercolor",
        "variants": 1,               # 1–4 images
    },
)
data = r.json()   # Venice image payload (base64-encoded image(s))

Edit — POST /v1/image/edit — transform an existing image from a prompt:

{
  "model": "<image-edit model>",
  "prompt": "make the sky stormy",
  "image": "<base64 source image>",
  "aspect_ratio": "1:1"
}

Upscale — POST /v1/image/upscale — increase resolution:

{
  "model": "upscaler",
  "image": "<base64 source image>",
  "scale": 2
}

Pricing is a fixed cost per image by model (then the dynamic multiplier applies). Discover image models and their cost via GET /v1/models.

5.5 Video (async)

Video generation takes minutes, so it uses an asynchronous flow: queue the job, then poll until it's ready.

Step 1 — Quote (optional but recommended). You can skip straight to queueing — the queue step runs its own balance check and refuses if you can't afford it. But because video is expensive and priced per model and duration, POST /v1/video/quote lets you see the exact cost before spending:

{ "model": "<video-model>", "prompt": "a drone shot over a forest", "duration": "5s" }

Step 2 — Queue — POST /v1/video/queue starts the job and returns a queue_id:

import requests
H = {"Authorization": "Bearer cdm_your_key_here"}
BASE = "https://carpe-diem.xyz/api/operator/v1"

job = requests.post(f"{BASE}/video/queue", headers=H, json={
    "model": "<video-model>",   # see GET /v1/models
    "prompt": "a drone shot over a forest at sunrise",
    "duration": "5s",           # a string with an "s"; read the set off constraints
}).json()
queue_id = job["queue_id"]

Step 3 — Retrieve — poll POST /v1/video/retrieve with queue_id + model until status is completed:

import time

while True:
    r = requests.post(f"{BASE}/video/retrieve", headers=H,
                      json={"queue_id": queue_id, "model": "<video-model>"}).json()
    if r["status"] == "completed":
        video_url = r["video_url"]   # e.g. /v1/video/file/<id>
        break
    if r["status"] == "failed":      # the render died upstream — terminal, with the reason
        raise RuntimeError(r["error"])
    time.sleep(5)

mp4 = requests.get(f"https://carpe-diem.xyz/api/operator{video_url}", headers=H).content
open("out.mp4", "wb").write(mp4)

Important:

• Retrieve with a key from the same account that queued. Every cdm_ key belongs to the wallet that created it, so the operator knows your account from the key alone — no wallet connection needed. Any key on that account can poll the job; a key from another account gets 403. In practice, just reuse the same cdm_ key.
• Carpe Diem handles the Venice-key routing for you. Venice scopes a video job to the provider key that created it; the operator remembers which provider served your /queue and routes every /retrieve back to it automatically — you only ever deal with your cdm_ key.
• A finished job returns a video_url (cached, not base64) — fetch it via GET /v1/video/file/:id.
• Stop polling on status: "failed" (the render died upstream — error carries the reason) and on terminal errors: 404 (job not found / expired), 403 (queue_id belongs to another account), 410 (upstream provider key revoked mid-job — re-queue).
• Reference-to-video takes a set, not a first frame. A *-reference-to-video model conditions on reference_image_urls / reference_video_urls / reference_audio_urls — a cast to keep consistent, a clip to edit, a voice to imitate. On the Seedance family the prompt itself selects the job: Refer to … generates, Strictly edit <Video 1>, … edits, Extend <Video 1>, … continues, and <Video 1> + … + followed by <Video 2> stitches. There is no task field. See the API reference for the syntax, the per-family limits, and the media policy.

5.6 Audio

Three capabilities: text-to-speech, transcription, and music.

Text-to-speech — POST /v1/audio/speech (OpenAI-compatible):

r = requests.post(f"{BASE}/audio/speech", headers=H, json={
    "model": "<tts-model>",       # see GET /v1/models
    "input": "Hello from Carpe Diem.",
    "voice": "<voice-id>",
    "response_format": "mp3",
})
open("speech.mp3", "wb").write(r.content)

Input is capped at 50,000 characters; billed per character.

Transcription — POST /v1/audio/transcriptions (OpenAI Whisper-compatible). Takes multipart/form-data with an audio file:

with open("clip.mp3", "rb") as f:
    r = requests.post(f"{BASE}/audio/transcriptions", headers=H,
                      files={"file": f}, data={"model": "<asr-model>"})
print(r.json()["text"])

Music — generated asynchronously, like video:

POST /v1/audio/music/queue      → returns a queue_id
POST /v1/audio/music/retrieve   → poll with queue_id until ready

Same queue/poll pattern and account/key rules as video (§5.5).

5.7 Embeddings

POST /v1/embeddings — OpenAI-compatible vector embeddings.

resp = client.embeddings.create(
    model="<embedding-model>",     # see GET /v1/models
    input="Carpe Diem makes Venice inference accessible.",
)
vector = resp.data[0].embedding

Batch several inputs in one call:

r = requests.post(f"{BASE}/embeddings", headers=H, json={
    "model": "<embedding-model>",
    "input": ["first text", "second text"],   # string or array
})
vectors = [d["embedding"] for d in r.json()["data"]]

Billed per input token. Both the OpenAI SDK's embeddings.create and a direct call return the standard { "data": [{ "embedding": [...] }] } shape.

5.8 Tracking balance & usage

OP = "https://carpe-diem.xyz/api/operator"
H = {"Authorization": "Bearer cdm_your_key_here"}

Live balance — GET /v1/credits, designed for agents to check before a call:

bal = requests.get(f"{OP}/v1/credits", headers=H).json()
print(bal["availableCredits"])   # credits you can spend right now

The response breaks your balance into escrow (purchased), pending (spent, not yet settled), holds (reserved for in-flight requests), and available (actually spendable) — each in both USDC and credits. Inference responses also carry your remaining balance in headers, so you rarely need a separate call.

Usage history — GET /buyer/usage, paginated:

hist = requests.get(f"{OP}/buyer/usage?limit=20&offset=0", headers=H).json()
for e in hist["events"]:
    print(e["created_at"], e["model"], e["cost_usdc"])

Usage summary — GET /buyer/usage/summary aggregates by day and model, for dashboards and reporting. For per-key breakdowns, use GET /buyer/api-keys/usage.

6. Becoming a provider

6.1 The idea

If you stake DIEM on Venice, you have a daily inference allowance you probably don't fully use. As a provider, you lend that allowance to the marketplace: Carpe Diem routes paid requests to your Venice key, and you earn DIEM on every request you serve — turning idle capacity into revenue.

You earn 65% of the value of every request your key serves, after a protocol surcharge (5% of the Venice base cost, skimmed first; the protocol keeps the surcharge plus 35% of the rest). Measured against what the buyer actually paid, your share works out to roughly 43–62% depending on the dynamic price — the Revenue tab's Where every dollar goes panel shows your window's real figures. Earnings accrue in DIEM, yours to withdraw on-chain anytime.

6.2 Provisioning your key

1. Create a Venice inference-only API key in your Venice account, ideally with a consumption limit and an expiry. An inference key is all Carpe Diem needs — there's no reason to provision an admin key.
2. Open the provider page and connect the wallet that stakes your DIEM.
3. Sign a message (free, no gas) to prove you own the wallet, and submit your Venice key.
4. Choose persistence: persisted (encrypted at rest, survives reboots) or RAM-only (re-provision after each restart — maximum secrecy).

Your Venice key is encrypted inside the TEE the moment it arrives — never visible to the host or the Carpe Diem team. You can register up to 5 keys per wallet to multiply your capacity.

Key hygiene. The TEE protects your key in use — it's never written to disk, logged, or exposed, and cannot be extracted from the enclave (even an admin key could not be read out). Scoping the key to inference-only, with a limit and expiry is simply defense-in-depth that stays entirely under your control, and you can revoke it anytime — from Venice, or from the provider page, which removes it from the TEE immediately.

6.3 Earning & withdrawing

As your key serves requests, your DIEM earnings accrue on-chain, credited at each settlement. Withdraw them anytime with the escrow's withdrawDiem — they go straight to your wallet. Track pending and lifetime earnings via GET /provider/stats and the Revenue tab of the provider dashboard.

6.4 Monitoring & control

• Per-request log — GET /provider/usage returns every request your key served, newest first, each with a timestamp, model, and cost. It's the definitive record of exactly what Carpe Diem routed through your key and when — including very recent requests not yet settled on-chain.
• Stats & yield — GET /provider/stats for request counts and earnings; GET /providers/:wallet/yield for your APRs: on capacity actually used (24h and 7d) and on deployed capital (7d, idle counted against you). The two 7-day rates obey apr7d = aprOnUsed7d × utilization exactly — the gap between them is your idle capacity, not fees.
• Revoke anytime — remove one key or your whole provider registration with DELETE /tee/providers/:address (or per key with …/keys/:keyId). The key stops receiving traffic immediately.

7. FAQ & support

Do I need an account or KYC? No. Your wallet is your identity — no email, no signup, no KYC.

How do I pay? Three ways, all in USDC on Base: a Prepaid account (recommended — deposit onto an auto-created account you own; self-custodial and withdrawable), Credits (deposit for a non-refundable balance you top up and burn down), or Wallet/x402 (agents pay per request straight from a wallet, no account). Prepaid and credits are the same single deposit step — the difference is only custody. See Ways to pay.

Is it cheaper than using Venice directly? Usually yes — dynamic pricing starts as low as ~15% of Venice's rate and is capped at Venice's rate (fee included), so you never pay more than going direct.

Which models can I use? Venice's full catalog — text, code, image, audio, video, embeddings. List them with GET /v1/models.

Can anyone see my prompts? No. Requests are processed inside a hardware-sealed TEE; neither the host, the Carpe Diem team, nor anyone else can read your prompts, responses, or the provider keys.

What if there isn't enough capacity for my request? A pre-flight check refuses cleanly before any inference runs (and before you're charged), and routing always picks a healthy provider with headroom.

Are there rate limits? Yes — they mirror Venice's own per-model rate limits (RPM / TPM), aggregated across the provider keys available for each model. Check the live numbers with GET /v1/rate_limits (account-wide) or GET /v1/limits/:model (per model), and pace traffic using GET /v1/capacity.

What network does it run on? Base (Ethereum L2) — escrow, settlement, and USDC are all on Base.

Support

• This guide and the API Reference
• Protocol details: the Whitepaper
• Community & support: Telegram