Live on NEAR testnet

The Unified Payment Layer for the AI Ecosystem.

One balance. One network. One interface.

Kredo pools AI companies into one network.

Apps on the network share billing, settlement and a pool of funded users. Each app that joins brings paying users to every other one, and each is paid for exactly what its users spend.

Explore the network

Your app

List it in minutes

Apps on the network
Funded users
Credits settled across apps

The whole billing stack, run for you.

No card processor, no ledger to build, no payout schedule to chase. The rules that matter live in a contract, not in our database.

Usage billing.

Charge per action, or hold and capture for long jobs. Your prices, your units, your margins.

How charging works

Settlement in USDT.

Every charge splits into your earnings and the network fee onchain. Withdraw whenever you like. The network pays the gas.

How payouts work

Limits users sign.

Each user approves a spending limit for your app, and the contract enforces it. No overcharges, no disputes.

How connect works

Light mode.

Already sell your own credits? Keep them. Accept the network balance as a top-up at a rate you set.

Read the SDK

Keys, test mode, webhooks.

Live and test keys, a sandbox with nothing onchain, and signed webhooks for every event.

See the webhooks

Provable reserves.

Every balance on the network is backed 1:1 by USDT in the vault, and anyone can check it live.

See the reserves

Built on NEAR

Kredo can't charge your users. Only your app can.

NEAR's account model lets every app hold a key that can do exactly one job. So a leak, a bug or Kredo itself can't move anyone's money.

Apps sign their own charges.

Each app gets a NEAR sub-account of apps.kredo-network.testnet with one function-call key. It can call charge, hold, capture, release and refund on the vault, and nothing else.

Sub-accounts · function-call keys

Kredo's keys are refused.

The vault takes a charge only from that app's signer. Our operator can pay gas and pause, but a charge from it fails. A leaked app key reaches only that app's users, within their limits.

Enforced in the contract

No gas, for anyone.

Users and apps sign delegate actions. The relayer wraps them and pays the gas, and can't change what was signed. The vault still sees the signer as the caller.

NEP-366 meta transactions

Storage paid by whoever adds it.

Accounts register with a storage deposit. Each write charges the bytes it adds to the account that caused them, so no one can make the vault pay for their data.

NEP-145

On chain, on testnet.

From the smoke test after deploying vault-v2.kredo-network.testnet. The refusals matter as much as the successes.

Until mainnet, Kredo still holds the vault account's full-access key, so it could deploy new code. Removing that key, or putting it behind a multisig, is the mainnet step.

20 lines, and you're live.

Come for usage billing. Stay for the users the network sends you.

1Register your app, get its signer key, and price each action.
2Users connect once and approve a limit.
3Charge per use and withdraw USDT.

Read the docs

server.ts

$ npm i kredo

│ network NEAR · USDT settled

│ gas paid by the relayer, never by users

│ limit enforced onchain, per app

│ signer your app's own NEAR key, nothing else

◆ ready

import { Credits } from "kredo";

const credits = new Credits({
  apiKey: process.env.CREDITS_API_KEY,
  signerKey: process.env.CREDITS_SIGNER_KEY, // only this key can charge for your app
});

// One-off actions: charge right away.
await credits.charge({ user, action: "chat.message" });

// Long jobs: hold first, then charge what was used.
const hold = await credits.hold({ user, action: "video.render", quantity: 12 });
try {
  await render(job);
  await credits.capture(hold.holdId);
} catch {
  await credits.release(hold.holdId);
}

// Out of credits, or not connected yet?
const url = await credits.connectUrl({ credits: 200, returnTo });

Every app that joins makes the network stronger.

List your app Read the docs