Full-strength models, from machines we own.
NexAIX serves Kimi K3, GLM-5.2 and DeepSeek from GPU clusters we own and operate. No account pools, no reverse-engineered endpoints, no quiet downgrades — one OpenAI-compatible endpoint delivering the reasoning strength the weights were built for. And we never store your conversations.
Trial credit on signup · No sales call · One line to change base_url
Your request
Summarise this contract in 5 bullets.
OpenAI SDK
NexAIX gateway
200 OKhttps://api.nexaix.net/v1
Streaming back
Five points: the term runs 24 months; either side may exit on 60 days’ written notice; the vendor carries operations; disputes go to arbitration; pricing lives in Schedule 3.
Request closed — payload released from memory
Our own GPU cluster
Weights deployed locally · precision published
Account pools / reversed endpoints·Never used
Three things we refuse to do
- No account pools
- Your traffic never rides on farmed consumer accounts, so nothing dies at 3 a.m. when a batch of them gets banned.
- No reverse engineering
- We do not hijack official client protocols or forge client signatures. There is a company here, with contracts and invoices.
- No silent downgrades
- Weight version and serving precision are published per model. Nothing gets swapped for a smaller or lower-precision variant at peak hours.
Compute
Which machine your tokens actually came out of
Almost every difference between relays lives at this layer. We buy the cards, load the weights and run the inference servers ourselves, so every layer reconciles.
- GPU clusters we own
- Weights run in facilities we build out and lease directly, operated by us. We resell nobody else’s quota, so nobody else’s ban takes you down.
- Published weights and precision
- Every model lists its weight version, context window and serving precision. Re-run the same prompts next week under different load and the results should hold. If they don’t, that’s on us.
- Every request is traceable
- Each call returns a request ID. Quotas, rate limits and availability are written down in the docs. When something breaks you have evidence, not just a retry button.
Compute record
- Topology
- Owned build-out + direct lease
- Weight source
- Official released weights, deployed locally
- Serving precision
- BF16 / FP8 (published per model)
- Upstream consumer accounts
- Not used · not resold
- Client reverse engineering
- Not used
- Conversation retention
- None
Kept in sync with every deployment change; previous revisions live in the changelog.
Models
Models on the fleet
Specs as deployed. Need something that isn’t listed? Ask — we’ll size the capacity and come back with a date.
Kimi K3
Moonshot AIkimi-k3
2.8T mixture-of-experts, a 1M-token window, and vision built into the base.
On our own GPUs
- Context
- 1M
- Precision
- BF16
- Max output
- 1M
GLM-5.2
Z.ai (Zhipu AI)glm-5.2
750B sparse MoE, a 1M window, MIT licensed — tuned hard for software engineering.
On our own GPUs
- Context
- 1M
- Precision
- BF16 / FP8
- Max output
- 131K
DeepSeek V4 Pro
DeepSeekdeepseek-v4-pro
1.6 trillion parameters, thinking and non-thinking modes, MIT licensed.
On our own GPUs
- Context
- 1M
- Precision
- BF16
- Max output
- 384K
DeepSeek V4 Flash
DeepSeekdeepseek-v4-flash
284B total, 13B active per token — the lowest unit cost in the V4 generation.
On our own GPUs
- Context
- 1M
- Precision
- BF16
- Max output
- 384K
MiniMax M3
MiniMaxminimax-m3
229.9B MoE that puts frontier coding, a 1M window and native multimodality in one model.
On our own GPUs
- Context
- 1M
- Precision
- BF16
- Max output
- 128K
Claude Opus 5
Anthropicclaude-opus-5
A million tokens that never degrade, five-level effort control, zero data retention.
Official commercial channel
- Context
- 1M
- Precision
- Vendor-managed
- Max output
- 128K
GPT-5.6 Sol
OpenAIgpt-5.6-sol
The frontier tier of the GPT-5.6 family: 1.05M context, built for long-horizon agents.
Official commercial channel
- Context
- 1.05M
- Precision
- Vendor-managed
- Max output
- 128K
Grok 4.5
xAIgrok-4.5
xAI’s "Opus-class but faster and cheaper" pitch — and the list price backs it up.
Official commercial channel
- Context
- 500K
- Precision
- Vendor-managed
- Max output
- 64K
Need a different model?
If it ships open weights, we can almost certainly host it. Send the model and your expected volume; we’ll size the capacity and reply with a date.
How we compare
NexAIX vs. account pools and reversed relays
This isn’t a price difference, it’s a supply difference. These are the questions worth asking any relay before you send it production traffic.
| Dimension | NexAIX | Account pools / reversed relays |
|---|---|---|
| Source of capacity | GPU clusters we own + licensed channels | Farmed consumer accounts, reverse-engineered client protocols |
| Model integrity | Weight version and precision published | Unknown; smaller or lower-precision substitutions are common |
| Availability | Stated rate limits and availability commitments | Dies the moment accounts are banned; recovery time unknowable |
| Conversation content | Never written to disk, never trained on | Unknown; retention and resale are real risks |
| Compliance | Contracts, invoices, auditable | Violates upstream terms of service |
| Debuggability | Request IDs, status page, documented error codes | A black box — retry and hope |
| Billing | Metered at published unit prices | Random throttling, random price changes |
Privacy
We don’t keep your conversations
Not a disclaimer at the end of a privacy policy — it’s how the servers behave. Request and response bodies exist in memory and nowhere else, and they’re gone when the connection closes.
- 01Request in
- 02In-memory relay
- 03Inference
- 04Response out
- 05Payload released
prompt / completion held in memory only
released when the request ends — never written to disk
All we keep (for billing and debugging)
- Request ID
- Token counts
- Timestamp
- Status code
- Model name
- Prompts and completions never hit disk
- Relayed in memory and released when the connection closes. There is no conversation body in the logs, so our own engineers cannot pull one.
- Your data is not training data
- We don’t train models, and we don’t hand traffic to any third party that does. Your data does not become someone else’s capability.
- TLS 1.3 end to end
- Encrypted from your client to the inference node, and between our internal services too.
- Scoped per key
- Every key gets its own quota, permissions and usage ledger. Leak one and you revoke it instantly, without touching the others.
Integration
Three steps. One line of code.
NexAIX speaks the OpenAI API. If you already use the OpenAI SDK, point base_url at us — the rest of your code stays exactly as it is.
- 1
Get a key
Sign up with an email. Trial credit included.
- 2
Change base_url
Point your client at https://api.nexaix.net/v1.
- 3
Call as usual
Request bodies, streaming, function calling and multimodal all work the way you already write them.
curl https://api.nexaix.net/v1/chat/completions \
-H "Authorization: Bearer $NEXAIX_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k3",
"stream": true,
"messages": [
{ "role": "user", "content": "Summarise this contract." }
]
}'import os
from openai import OpenAI
client = OpenAI(
# the only new line
base_url="https://api.nexaix.net/v1",
api_key=os.environ["NEXAIX_API_KEY"],
)
# everything below is your existing code
stream = client.chat.completions.create(
model="glm-5.2",
stream=True,
messages=[
{"role": "user", "content": "Summarise this contract."}
],
)
for chunk in stream:
print(chunk.choices[0].delta.content or "", end="")import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.nexaix.net/v1", // the only new line
apiKey: process.env.NEXAIX_API_KEY,
});
// everything below is your existing code
const stream = await client.chat.completions.create({
model: "deepseek-v4-flash",
stream: true,
messages: [
{ role: "user", content: "Summarise this contract." }
],
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}Works out of the box with
Anything that lets you set a custom OpenAI base URL, including but not limited to:
- OpenAI SDK
- LangChain
- LlamaIndex
- Vercel AI SDK
- Dify
- Cherry Studio
- NextChat
- Cline
- OneAPI
FAQ
Questions people actually ask
Something not covered here? Write to us — an engineer answers.
Is NexAIX OpenAI-compatible? Do I have to change my code?
Yes. The API implements the OpenAI Chat Completions spec, including streaming, function/tool calling and multi-turn conversations. For nearly every project the change is setting base_url to https://api.nexaix.net/v1 and swapping in a NexAIX key. Nothing else moves.
What exactly do "no account pools, no reverse engineering" mean?
An account pool means mass-registering consumer accounts and reselling their free or discounted quota as an API. Reverse engineering means capturing an official client’s private protocol and forging client identity to call it. Both violate upstream terms, both can be banned in bulk overnight, and both route your conversations through layers nobody controls. NexAIX does neither: we buy the hardware and deploy open weights ourselves, and anything served through an official vendor runs on a commercial licence.
Do you really not log conversations? Then what do you keep?
Really. Prompts and completions are relayed in memory and released when the request ends; they are never written to persistent storage. What we keep is the metadata billing and debugging require: request ID, model name, token counts, timestamp, status code. None of those fields contain conversation text.
How do I verify you aren’t quietly quantizing or substituting a smaller model?
Three ways. First, every model page publishes its weight version and serving precision, and changes go through the changelog. Second, pin a prompt set and seeds and re-run them at different times and load levels — the distribution should hold. Third, the `model` field in the response always names the model that actually executed; we never report A and run B. If you find a mismatch, we treat it as non-delivery.
What happens when a model is at capacity? Will I be silently rerouted?
No. At capacity you get a standard 429 with retry guidance, and you decide whether to queue, back off or switch models. Quietly handing your request to a cheaper model is precisely the thing we refuse to do — that is what "silent downgrade" means.
Can you issue invoices, sign contracts, or run a private deployment?
Yes. There is a real legal entity here that signs service agreements and issues invoices. Teams and enterprises can add a data processing agreement; where compliance requires it we also run dedicated resource pools and private deployments. Get in touch and we’ll scope it.
Run your own eval first
Don’t trust any relay’s marketing page, this one included. Take the trial credit, run the evals you already have, and then decide whether we get your production traffic.