Ecosystem

Voidnet Console is a marketplace for AI apps — tools, models, and agents — with everything around it: accounts, payments, and docs.

Voidnet Console

The home of the ecosystem. Buyers discover apps in the Marketplace, purchase free or paid access, manage API keys, and track usage and spend. Publishers verify and publish apps, set free and paid tiers, connect Stripe once, and track earnings and weekly payouts.

Everything a human does — buying, publishing, paying, reconciling — happens here. (openvoidnet.com/console)

Voidnet

The API that carries every call from buyer to publisher app. Each request is authenticated, checked for access, limited, metered, and billed before the answer returns. One endpoint, adapter in the path, per protocol.

Buyers never connect to publisher servers directly, and publishers never see buyer credentials. The gateway stands between them on every single call. (api.openvoidnet.com)

Void Accounts

One login for everything. Sign up, sign in, sessions, two-factor, and social login live here, and every other product redirects logins to it. A buyer or publisher identity created once works across Console, VoidAI, and Share without new passwords.

Accounts also mints the API keys developers use to call through the Voidnet. (accounts.openvoidnet.com)

VoidAI

Chat with AI that can reach into the marketplace. Assistants in VoidAI call published tools and models as part of answering, so a conversation can check data, run tools, and quote models without leaving the chat.

VoidAI is a buyer like any other: same access rules, same metering, same billing. (chat.openvoidnet.com)

Void Share

Public pages shared out of VoidAI — no login needed to view. A workspace result becomes a link anyone can open, with safe sandboxed rendering.

Sharing closes the loop: private work in VoidAI turns into public artifacts that bring new readers back into the ecosystem. (share.openvoidnet.com)

Docs

Guides and references for building on Voidnet Console — this site. Protocol overviews, buyer and publisher guides per adapter, billing rules, and the full error catalog.

Docs are written from the live system and versioned with it, so the contract you read is the contract you get.

How all work together

A new buyer signs up in Accounts, gets a key, finds an app in Console, gets access, and calls it through the Voidnet. A new publisher enrolls in Accounts, verifies and publishes in Console, and serves traffic through the Voidnet. Money flows the same way every time: buyer tops up the wallet, usage deducts per call, earnings accumulate, publishers get paid weekly.

No product duplicates another. Console never proxies app traffic; the Voidnet never renders a page; Accounts never touches money; VoidAI never publishes apps; Share never bills. Each request and each dollar crosses each boundary exactly once, in the same order, every time. That is the whole integration surface — learn it once and every product behaves the way you expect.

How the ecosystem forms

The ecosystem forms around a single loop: publishers list capabilities, buyers pay to use them, payouts fund more publishers. Console lowers publishing to a form plus a server URL. The wallet lowers buying to one top-up instead of one checkout per app. VoidAI lowers discovery to a sentence in a chat.

Each turn of the loop adds supply and demand at once — a published app is a reason to sign up, and every signup is an audience for the next app. Share extends the loop outward: artifacts made inside Voidnet travel the open web and return as new users.

Network effects

Every side strengthens the others. More apps make keys and top-ups worth having. More buyers make publishing worth doing. More usage makes payouts larger, which funds better apps. Shared pages and chat answers advertise the marketplace without anyone buying ads.

The moat is the loop itself: the purchase graph, the usage history, and the payout rails get more valuable with every participant, and none of them can be copied by copying code.

Identity

Publishers are @username — lowercase letters, numbers, and hyphens, 3–20 characters, chosen once at enrollment and never changeable. Every app belongs to exactly one publisher, and every app's public identity is username/appname:

POST /v1-beta/{adapter}/{username}/{appname}

App names are unique per publisher (a-z, 0-9, -, _, 3–50 chars). The same username/appname identity works identically across every app type — MCP tools, LLM models, and beyond: marketplace pages, purchase records, usage logs, API keys, and gateway routes all key off the same pair. Learn it once; it never varies.

Composability

Every Void app is callable through the same gateway with the same credentials, so one app can build on another. An assistant can answer with an LLM and reach for MCP tools mid-sentence — lookup, compute, act — without leaving the conversation. A product outside Voidnet can do the same: call a marketplace model for language and marketplace tools for everything else, composed into one experience.

Because the contract is uniform — username/appname, bearer key, usage-metered — composition needs no special integration. If an app can be called, it can be combined: MCP inside LLM answers, LLM inside tool workflows, any app inside any product, inside Voidnet or outside it. Each published capability multiplies the value of all the others.

Developer resources

• Void Apps — app types and how they are consumed and published.
• Voidnet — the API contract: one endpoint, errors, auth.
• Get Started — credentials and your first call.
• API Reference · Error Reference.
• Code: GitHub · npm · PyPI · Go.