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 buy credits once with USDC on Base, then spend them 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, buy credits with USDC, and spend them per request.

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 credit 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 user withdrawal, and the incoming USDC becomes protocol funds that pay providers and run the network. 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 Buy credits

From the dashboard, pay USDC to buy credits. 1 credit = $0.01, so $10 of USDC gives you 1,000 credits. If you hold a different token, the deposit widget can swap it to USDC in the same transaction. Credits are spent as you make requests and are non-refundable.

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 Credits & billing

Carpe Diem is pay-per-use. No subscription, no minimum — you spend credits only when you make a request.

• 1 credit = $0.01. Buying $10 of credits gives you 1,000 credits.
• Each request costs the model's price for what you actually used (tokens for text, images generated, seconds of video…), converted to credits and deducted from your live balance the moment the response returns.
• Every response reports the cost. Inference responses include headers showing what the request cost and how many credits remain — so agents can budget precisely.
• Credits are non-refundable. They're a usage entitlement, not a deposit: there is no withdrawal back to USDC.

The price you pay tracks Venice's underlying rates but is usually lower, because pricing is dynamic (next section). Check your 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": 5 }

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",
}).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
    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 terminal errors: 404 (job not found / expired), 403 (queue_id belongs to another account), 410 (upstream provider key revoked mid-job — re-queue).

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 (the protocol keeps 35%). 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 earnings 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 APR on utilization (last 24h) and on deployed capital (last 7d).
• 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? Buy credits with USDC on Base. 1 credit = $0.01. Spent per request, non-refundable.

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