NeuralRing
EU-sovereign · attested · OpenAI-compatible

AI that can prove where it ran.

One OpenAI-compatible API in front of Europe's sovereign AI endpoints. Every answer arrives with a signed record of where it was computed and under whose jurisdiction — one you can check yourself.

Get started free Try the playgroundVerify a real attestation
requestsovereignty pinEU endpointsigned attestat…
self-attested

What NeuralRing is

One API, many sovereign models

If your code speaks OpenAI, it already speaks NeuralRing — change the base URL and key, nothing else.

A rule that cannot be bent

Say “Germany only”, “EU only”, or “no US-owned parents” — and no price or speed option can ever override it.

Proof with every answer

A signed, tamper-evident receipt of where the computation ran. Anyone can check it on a public page.

7 models from 6 sovereign providers, across 3 jurisdictions — each showing its tier and its proof level. Browse all models →

Live from the catalog
Mistral Large 2411
mistralai/mistral-large-2411
Tier 0 · self-attested
2 endpointsjurisdictions: FR
Mistral Small 3 (2501)
mistralai/mistral-small-2501
Tier 1 · self-attested
2 endpointsjurisdictions: FR
Mixtral 8x7B Instruct
mistralai/mixtral-8x7b-instruct
Tier 0 · self-attested
4 endpointsjurisdictions: FR, DE
Llama 3.3 70B Instruct
meta/llama-3.3-70b-instruct
Tier 0 · self-attested
3 endpointsjurisdictions: FR, DE
Browse all models

Where do you fit?

Developers

Ship on sovereign AI without changing your stack.

How you start
  1. Create a key — free signup, no card.
  2. Point your OpenAI or Anthropic SDK at https://neuralring.eu/api/v1.
  3. Add one line — sovereignty: { jurisdiction: ["DE"] } — and every response arrives attested.
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://neuralring.eu/api/v1",           // NeuralRing — https://neuralring.eu/api/v1
  apiKey: process.env.NEURALRING_API_KEY, // org-scoped key (Bearer)
});

const res = await client.chat.completions.create({
  model: "mistralai/mistral-small-2501",
  messages: [{ role: "user", content: "Hello, sovereign world" }],
  // NeuralRing extension: the sovereignty pin is applied FIRST and never loosened.
  // @ts-expect-error NeuralRing routing extension
  sovereignty: { jurisdiction: ["DE"], min_assurance: "self_attested" },
});
console.log(res.choices[0].message.content);
Read the quickstart Browse models

Individual users

Chat with Europe's AI models — and see the proof under every answer.

How you start
  1. Sign up in a minute.
  2. Open the playground and pick a model — or let the Auto Router pick.
  3. Click the attestation chip beside any answer to see where it ran — and share the public link with anyone.
Open the playground What's an attestation?

Infrastructure & endpoint providers

You built sovereign capacity. We bring it the developers.

How you start
  1. Submit your endpoint in the partner portal — it is probed and evidence-checked automatically.
  2. A human reviews the evidence and approves you into the catalog.
  3. Earn from federated demand with transparent settlement statements — or run the whole gateway under your own brand.

Your endpoint enters at the assurance level we can substantiate — self-attested until verified. That honesty is why buyers trust the catalog you're joining.

verification earns the seal
Open the partner portal

How it works

The platform in one picture

One API in front of many sovereign endpoints. You set the rule once — a jurisdiction, a minimum tier, a minimum assurance. Routing, failover and load-balancing all happen inside that rule. If nothing qualifies you get an honest error, never a silent fallback to somewhere you didn't allow.

The rule filters first. Price and speed only ever compete among endpoints that already passed it.

The proof, end to end

  1. Every request writes a record.

    Endpoint, jurisdiction, tier, assurance, hops and token counts — metadata only, never the prompt or the answer.

  2. Each record is chained to the one before.

    The record embeds a hash of the previous record, and its own hash covers that link — one continuous chain.

  3. Why it can't be quietly altered.

    Change one byte anywhere in history and every later fingerprint stops matching. Each record is also Ed25519-signed against a published key, so records can't be re-forged wholesale.

    The chain proves the record wasn't altered after the fact; the assurance level states how strongly the underlying claim was substantiated. We never let one imply the other.

  4. Check it yourself, without trusting us.

    Three independent ways to verify — none of which require taking our word for it:

Verify a real attestation

Every signal states exactly how substantiated it is:

  • self-attested the provider says so
  • verified we checked, and kept the evidence
  • certified a live third-party certification backs it
verified certifiedverified infrastructure carries the NeuralRing seal
Sovereign stack, enforced in CI — 0 banned dependencies on the data pathPrompts are never stored by defaultOpen verification — public key + standalone script

Questions, answered honestly

Is this a reseller of OpenAI?
No. NeuralRing federates only EU-sovereign inference — sovereign supply by construction, never US-hosted APIs on a customer request path.
What happens if no endpoint matches my rule?
You get an honest error — never a silent fallback to something outside your rule.
Do you read my prompts?
No. Prompts and completions are not stored by default; the attestation records metadata only — token counts and routing, never your text.
What does an attestation actually prove — and not prove?
It proves the route NeuralRing took and the policy it satisfied, signed and chained. It does not by itself prove an endpoint's self-declared facts — that strength equals its assurance level. We document exactly this. /docs · Verify a real attestation
Can I bring my own provider contract?
Yes — bring your own provider key (BYOK). It is encrypted at rest and used to route to that provider under your terms.
Product
Developers
Providers
NeuralRing
Sovereign Inference Gateway

sovereign inference, provable by design