From ENJU holdings to AI credits.

Understand who earns, how daily fees are shared, and how to claim and use your credit.

01

What is Enju?

Enju turns ENJU trading fees into OpenRouter credits for holders and support for builders on Robinhood Chain. ENJU trades on Pons using ETH as collateral.

Each trade contributes a 2% fee in ETH: 70% funds holder allocations and 30% supports builders. OpenRouter provides access to AI models through one API. An issued key lets you spend credit in compatible applications and coding tools.

Earned allocation
Your recorded share of a completed day’s ETH fees.
Claimable allocation
Earned ETH you have not yet converted into an API key.
Available AI credit
Unspent OpenRouter credit on an issued, active key.

02

Who qualifies?

Each wallet needs a daily average direct balance of at least 100,000 ENJU. The average is weighted by how long each balance was held during the UTC day.

  • Only individual trader and holder wallets count. Treasury, liquidity-pool, exchange, and burn addresses are excluded from eligibility and eligible supply.
  • Each wallet is assessed separately. Transfers change each wallet’s balance from the time of transfer; balances and holding history are not combined across wallets.
  • Buying just before midnight only counts for the time actually held. There is no separate requirement to hold continuously for 24 hours.

Illustrative example: holding 200,000 ENJU for 12 hours and zero for the other 12 hours gives a daily average of 100,000 ENJU. Holding 100,000 for only half the day gives an average of 50,000 and does not qualify.

03

How daily earnings work

At 00:00 UTC, Enju closes the previous 24-hour period. The daily record captures time-weighted wallet balances and the ETH fees collected during that same period.

Your daily earned allocation

(your eligible daily average ÷ total eligible daily averages) × 70% of daily ETH fees

Only qualifying wallets enter the denominator. Each day’s fees are allocated once. Earned allocations are saved for their wallets, never redistributed to later holders. No trading fees means no new fee-funded allocation for that day.

Earn, sell, claim later · illustrative example

  1. Monday’s trades collect 10 ETH in fees. At Tuesday’s 00:00 UTC close, 7 ETH goes to holder allocations and 3 ETH to the builder treasury.
  2. Alice’s qualifying daily average is 1% of the total eligible daily averages. She earns 0.07 ETH.
  3. Alice sells her ENJU on Tuesday. Monday’s 0.07 ETH remains claimable.
  4. She claims the following week. Her quote determines the net OpenRouter credit, with up to $200 assigned to each new key. Any allocation not claimed stays available for another claim.
  5. She uses the key later. Selling or waiting does not expire her credit; a revoked key can no longer be used.

04

What happens after selling?

Selling ENJU affects subsequent earnings. Your previous allocations remain claimable.

A sale changes your average balance for the day in progress and later days. It does not change completed daily allocations or unused credit on active keys. Claim from the wallet that earned the allocation, even if its current ENJU balance is zero.

05

How to claim

Saved daily allocations accumulate. Combine several days in one claim, with a maximum of $200 in OpenRouter credit per new key. Each claim creates a separate key; it does not top up an existing one.

  1. Connect the earning wallet and choose from its unclaimed allocations.
  2. Review the included days, daily averages, recorded fees, claimable ETH, conversion quote, and net credit. Amounts above the $200 key limit remain claimable through additional claims.
  3. Authorize the claim with a gasless EIP-712 wallet signature. No token approval or transfer is required.
  4. Allow a few minutes for conversion and key setup, then copy the key shown once. Delivery time is an estimate.

A failed claim can be retried without losing its allocation. There is no daily claim deadline. Review the ETH amount and net OpenRouter credit in your quote before signing.

06

Use and protect your key

Use your spending-limited OpenRouter key for coding assistance, document summarization, or applications built with model APIs. Model pricing determines how far the balance goes.

Keep your key private. Revoke it if exposed.

Save the key when it is shown. Store it in an environment variable or secret manager, never in source control, browser code, screenshots, or shared messages. Anyone with the key can spend its credit.

You can revoke a key from the app to stop further use. Revocation does not undo previous spending. Save your key securely when it is shown and review its usage before revoking it.

Active key credit has no daily expiry and remains available until spent. Requests go directly to OpenRouter; Enju does not receive your prompts or responses.

API request and usage examples
First request
Review values before use.
export OPENROUTER_API_KEY="enju_demo_key_not_live"
curl https://openrouter.ai/api/v1/chat/completions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "openrouter/auto",
"messages": [
{ "role": "user", "content": "Explain this code in one paragraph." }
]
}'
TypeScript request
Review values before use.
const response = await fetch(
'https://openrouter.ai/api/v1/chat/completions',
{
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: 'openrouter/auto',
messages: [{ role: 'user', content: 'Review this pull request.' }],
}),
},
)
if (!response.ok) {
throw new Error(`OpenRouter request failed: ${response.status}`)
}
console.log(await response.json())
Check this key’s usage
Review values before use.
curl https://openrouter.ai/api/v1/key \
-H "Authorization: Bearer $OPENROUTER_API_KEY"
# Returns the key limit, usage, remaining credit,
# reset policy, and expiration date.

07

Coding tools

Use the same OpenRouter key with Codex, Claude Code, Pi, or Cursor. Each tool draws from the key’s shared spending limit, so one usage check covers the full balance.

Show coding-tool configuration examples

Claude Code

Route Claude Code through OpenRouter’s Anthropic-compatible endpoint.

Claude Code config
OpenRouter configuration for Claude Code. Keep API keys out of source control.
export OPENROUTER_API_KEY="enju_demo_key_not_live"
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="$OPENROUTER_API_KEY"
export ANTHROPIC_API_KEY=""
claude

Cursor

Add the key and base URL under Cursor Settings, Models, API Keys.

Cursor config
OpenRouter configuration for Cursor. Keep API keys out of source control.
OpenAI API Key: enju_demo_key_not_live
Override Base URL:
https://openrouter.ai/api/v1/cursor
Model: openrouter/auto

Pi

Select OpenRouter as the provider and choose a model available to Pi.

Pi config
OpenRouter configuration for Pi. Keep API keys out of source control.
export OPENROUTER_API_KEY="enju_demo_key_not_live"
pi --provider openrouter \
--model anthropic/claude-sonnet-4

Codex CLI

Point the user-level Codex configuration at OpenRouter’s Responses API.

Codex CLI config
OpenRouter configuration for Codex CLI. Keep API keys out of source control.
# ~/.codex/config.toml
model_provider = "openrouter"
model = "openai/gpt-5.6-sol"
[model_providers.openrouter]
name = "OpenRouter"
base_url = "https://openrouter.ai/api/v1"
env_key = "OPENROUTER_API_KEY"
wire_api = "responses"

Keep the key in environment variables or user-level settings, never project files. Tool configuration can change, so use the linked guides for client-specific details.

08

Builder funding and buybacks

Thirty percent of ENJU trading fees supports developers building on Robinhood Chain through funding, hackathons, and incubation.

Of the revenue Enju receives under agreements with supported projects, 100% funds ENJU buybacks and burns. Each project’s revenue-sharing terms are negotiated separately. This revenue is separate from the 70/30 trading-fee split.

Support depends on treasury resources. Follow the official Enju account for builder application details, buyback updates, and execution references.

09

Common questions

Quick answers before you get started.

Do I need to trade to earn?

No. A qualifying daily average holding is enough. Trading activity across ENJU funds the pool.

Do I need to hold continuously for 24 hours?

No. Eligibility uses your balance averaged over the entire UTC day, with a 100,000 ENJU minimum average per wallet. Short holdings contribute only for their duration.

What if I sell?

Completed daily allocations stay yours. A sale affects your average for the current and subsequent days.

Do allocations or credits expire?

Unclaimed allocations have no daily deadline. Unused credit on active keys remains available until spent. Revoking a key stops its use.

Can I combine balances across wallets?

No. Each wallet qualifies and earns independently; transferring tokens does not transfer past allocations.

Can I withdraw cash or ETH?

Claims provide OpenRouter credit. Enju does not offer cash or ETH withdrawals for holder allocations.

Does Enju see my prompts?

No. Model requests go directly to OpenRouter and its providers. Their data policies apply.

Why did my estimated claim value change?

Your earned ETH amount stays recorded, but ETH prices, liquidity, and conversion costs affect the dollar credit available when you claim.

10

Transparency and risks

Daily accounting inputs and treasury references let holders check how allocations are calculated.

  • Daily records: UTC period, block references, time-weighted eligible balances, total eligible averages, and collected ETH fees.
  • Treasury records: fee inflows, the 70/30 split, and transaction references. Holder claim records are not part of the public protocol data.
  • Credit value varies with trading activity and conversion. AI credit is consumable access, not a guaranteed cash return.
  • Network, conversion, OpenRouter, and model-provider availability can delay delivery or usage.

12

SDK and developer reference

The Enju SDK detects local coding tools, previews and applies configuration changes, and reads OpenRouter key usage.

Start by detecting your tools and previewing the configuration changes. Usage and bulk-setup snippets continue from the setup example below.

TypeScript@enjucredit/sdkESM · local configuration
Install
Install the SDK in your application or local automation package.
pnpm add @enjucredit/sdk
Detect and configure
Detect tools, preview the exact files that change, then apply the reviewed input.
import { Enju } from '@enjucredit/sdk'
const enju = new Enju()
const apiKey = process.env.OPENROUTER_API_KEY!
const detected = await enju.harness.detect()
const preview = await enju.harness.configure({
harness: 'codex',
apiKey,
scope: 'user',
dryRun: true,
})
console.log(detected)
console.log(preview.changed)
// Apply the same reviewed input
await enju.harness.configure({ ...preview.input, dryRun: false })
Usage and status
Read OpenRouter allowance data and verify the active local tool configuration.
const usage = await enju.key.usage({ apiKey })
console.log({
limit: usage.limit,
used: usage.used,
remaining: usage.remaining,
expiresAt: usage.expiresAt,
})
const status = await enju.harness.status({ harness: 'codex' })
console.log(status.configured, status.model)
Configure all and remove
Configure every detected tool, then remove only settings managed by Enju.
const installed = (await enju.harness.detect())
.filter((tool) => tool.installed)
.map((tool) => tool.harness)
await enju.harness.configureAll({
apiKey,
only: installed,
scope: 'user',
dryRun: false,
})
// Removes Enju-managed settings without deleting unrelated config
await enju.harness.remove({ harness: 'codex', scope: 'user' })
MethodPurpose
harness.detect()

Find supported tools and report their configuration state.

harness.configure()

Preview or apply settings for one tool and scope.

harness.configureAll()

Apply one key across selected installed tools.

harness.status()

Read the effective provider, model, scope, and config path.

harness.remove()

Remove Enju-managed settings without touching unrelated config.

key.usage()

Read limit, used credit, remaining credit, reset, and expiration.

Dry-run output lists every file and environment value changed
User and project scopes keep personal and repository config separate
Repeated setup produces the same result without duplicate entries
Usage and status objects never include the full API key