# nRouter — Enterprise LLM Gateway & Smart Routing Platform

> One key, one bill, zero provider configuration. The managed LLM gateway for teams.

Last updated: 2026-10-22 — this file is generated from the live router catalog and regenerated hourly.

nRouter is a managed LLM gateway: customers get a single OpenAI-compatible API key plus credits, and we handle every provider key, routing, cost tracking, and safety guardrail. 285 models are live now across 7 provider clouds — OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI. There is no BYOK: you never see or configure a provider key.

Pricing is pay as you go — every feature is unlocked. We charge 0% markup (zero per-token markup) on model tokens, and settle inference spend at the exact provider list price of the served model. The platform fee is 0%. A credit purchase charges exactly the credits bought: $5 of credits costs $5.00, $100 costs $100.00. There is no fee on top. Credits never go negative, and minimum credit purchase is $5. nrouter/auto is available to pay-as-you-go customers and is paid from credits at the served model's list price. Rate limits for pay as you go are 200 RPM / 200k TPM / 5 concurrent. Existing subscribers keep their plan and its allowance. Enterprise is custom deployment via sales.

## How It Works

- Sign up at https://nrouter.ai/signup and create a nRouter API key
- Buy credits pay-as-you-go ($5 minimum, 0% platform fee)
- Call any model through the OpenAI-compatible endpoint at https://api.nrouter.ai/v1
- nRouter routes the request, applies guardrails, tracks spend in real time, and returns the response
- Set the `NROUTER_API_KEY` environment variable so SDKs pick it up automatically

## Key Features

- 285 models live now across 7 provider clouds (OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI) — see the per-cloud breakdown under "Model Coverage" below, or https://nrouter.ai/models for what's live in your region right now.
- OpenAI-compatible SDK — drop-in replacement, change two lines (base URL + key), no migration code
- 0% markup (zero per-token markup) on model tokens; inference spend is settled at the exact provider list price
- Built-in guardrails on every tier: content filtering, PII detection, prompt-injection protection
- Prompt template management with versioning, deterministic A/B testing across variants, and RBAC (owner / org_admin / member / viewer, plus team_admin / team_member)
- Real-time spend tracking, per-key and per-team budgets, exportable CSV analytics, latency percentiles
- Programmatic cost read-back: GET /api/nrouter-proxy/spend/by-key?request_id=<x-nr-request-id> with your own nRouter key returns that one request's settled cost, tokens and latency (an unpriced request returns spend: null, never 0)
- SSO/SAML, immutable audit logs, custom branding, GDPR consent tracking — included on every tier
- 99.9% uptime SLA on production traffic

## Model Coverage

285 distinct models live now. Deployments by provider cloud, largest catalog first (generated 2026-10-22 from the live router):

- OpenAI: 110 models — e.g. gpt-4.1, gpt-3.5-turbo-16k, gpt-4o-2024-08-06
- Alibaba US: 78 models — e.g. glm-5.3-prime, qwen-plus-latest, qwen3.7-max-2026-05-17
- AWS Bedrock: 49 models — e.g. qwen3-235b-a22b-2507, llama4-maverick-17b-instruct, glm-5
- Google Vertex AI: 22 models — e.g. gpt-oss-120b-maas, glm-4.7-maas, qwen3-next-80b-a3b-instruct-maas
- Anthropic: 13 models — e.g. claude-opus-5-5, claude-fable-5-1, claude-opus-5
- Azure Foundry: 12 models — e.g. Phi-4-multimodal-instruct, mistral-small-2503, Phi-4
- TypeSafe AI: 1 model — e.g. typesafe/jev

Every model above is reachable with the same nRouter API key. New flagship models are added within days of general availability. Provider availability varies by region — the complete machine-readable catalog with per-token pricing, context windows and capabilities is at https://nrouter.ai/api/public/models (JSON, no key required).

## Pricing

| Tier | Commitment | Platform fee | Notes |
|------|------------|--------------|-------|
| Pay as you go (No commitment. Buy credits and pay only for what you use.) | None, no minimum | 0% | All features unlocked; 200 RPM / 200,000 TPM / 5 concurrent |
| Enterprise (Custom deployment, limits and terms.) | Custom | Custom | Dedicated capacity, named support |

All features unlocked — guardrails, prompts, A/B tests, RBAC, SSO, audit logs, observability. Pay as you go includes 200 RPM / 200k TPM / 5 concurrent with 0% platform fee. Existing subscribers keep their plan and its allowance. Enterprise is custom deployment via sales.

## Docs

- [LLM Gateway](https://nrouter.ai/llm-gateway): Managed LLM gateway for routing, guardrails, budgets, failover, and cost control
- [Enterprise LLM Gateway Architecture](https://nrouter.ai/product/enterprise-llm-gateway): 5-phase request lifecycle, air-gapped Cortex mTLS 1.3 sidecar, atomic credit reservation, and exact list-price settlement
- [AI Governance](https://nrouter.ai/ai-governance): Enforce AI governance on every LLM request — guardrails, RBAC, audit logs, budgets, and SSO
- [OpenAI-Compatible API](https://nrouter.ai/openai-compatible-api): Use your OpenAI SDK with one API for multiple providers, models, routing, guardrails, budgets, and observability
- [LLM Cost Optimization](https://nrouter.ai/llm-cost-optimization): Reduce LLM spend with cost-aware routing, caching, exact provider pricing, and hard budgets
- [Automatic routing](https://nrouter.ai/product/auto): Send nrouter/auto as the model and the platform chooses a model for each request, charged at the list price of the model that served it
- [Smart Routing & Failover](https://nrouter.ai/product/routing): Two ways to ask for a model (a model you name, never swapped, or nrouter/auto), fallback lists you configure, circuit breakers, and request routing headers
- [AI Guardrails](https://nrouter.ai/product/guardrails): Pre-call and post-call PII redaction, prompt injection defense, and content moderation
- [Virtual Keys](https://nrouter.ai/product/virtual-keys): Scoped sk-nrouter-* API keys with model ACLs, rate limits, spend ceilings, and instant revocation
- [Response Cache](https://nrouter.ai/product/cache): Tenant-isolated response caching with single-flight deduplication and configurable TTLs
- [MCP Gateway](https://nrouter.ai/product/mcp): Model Context Protocol reverse proxy and tool catalog governance
- [Observability](https://nrouter.ai/product/observability): Request-level trace waterfalls, token breakdowns, cost attribution, and OTLP log export
- [Budget Controls](https://nrouter.ai/product/budgets): Pre-call credit reservation envelopes and hard spend ceilings per key, team, and organization
- [Enterprise](https://nrouter.ai/enterprise): Enterprise governance, SAML/OIDC SSO, SCIM provisioning, custom SLAs, and dedicated deployment options
- [Documentation](https://nrouter.ai/docs): Full API reference and integration guides
- [Quick Start](https://nrouter.ai/docs/getting-started/quick-start): Create an API key and send a first chat completions request in minutes, with TypeScript, Python, or cURL
- [Why nRouter](https://nrouter.ai/docs/why-nrouter): One API key for every provider, with budget controls, audit logging, guardrails, and multi-tenancy
- [Docs FAQ](https://nrouter.ai/docs/faq): Answers to the questions users ask first — getting a key, models, streaming, fallbacks, rate limits, and request costs
- [Authentication](https://nrouter.ai/docs/getting-started/authentication): Virtual API keys, Bearer authorization, tenant isolation, and key security
- [Migration Guide](https://nrouter.ai/docs/getting-started/migration-guide): Move from OpenRouter or a direct provider integration by changing the base URL and the API key
- [Set up routing](https://nrouter.ai/docs/guides/set-up-routing): Name a model with your own fallbacks, or send nrouter/auto and read which model served the request
- [Router Settings](https://nrouter.ai/docs/guides/router-settings): Direct and nrouter/auto modes, fallbacks, retries, timeouts, and response caching
- [Errors & Rate Limits](https://nrouter.ai/docs/guides/errors): One JSON error shape with machine-readable codes — status codes, error codes, and the rate-limit headers
- [API Reference](https://nrouter.ai/docs/api-reference): OpenAI- and Anthropic-compatible endpoints for chat completions, embeddings, audio, and more, with parameters and examples
- [Chat Completions](https://nrouter.ai/docs/api-reference/chat-completions): The chat completions endpoint in full — request parameters, streaming, tools, and response shape
- [SDKs](https://nrouter.ai/docs/sdks): Published SDKs for Python and TypeScript, preview SDKs, and framework integration guides
- [Webhooks](https://nrouter.ai/docs/webhooks): Subscribe HTTPS endpoints to virtual-key lifecycle events and verify HMAC signatures
- [Playground](https://nrouter.ai/product/playground): Browser-based interactive API testing (uses the visitor's own virtual key)
- [Models](https://nrouter.ai/models): Browse all live models with pricing and capabilities
- [Leaderboard & Benchmarks](https://nrouter.ai/leaderboard): Live LLM leaderboard with Pareto frontier, ELO ranks, latency, and empirical benchmarks (MMLU, HumanEval, GPQA)
- [Pricing](https://nrouter.ai/pricing): Plan comparison and platform-fee math
- [Blog](https://nrouter.ai/blog): Engineering deep-dives and product announcements
- [Changelog](https://nrouter.ai/changelog): Product update timeline
- [Status](https://nrouter.ai/status): Live uptime and incident history
- [nRouter vs OpenRouter](https://nrouter.ai/vs/openrouter): Feature and pricing comparison
- [nRouter vs Portkey](https://nrouter.ai/vs/portkey): Feature and pricing comparison
- [nRouter vs Helicone](https://nrouter.ai/vs/helicone): Feature and pricing comparison
- [nRouter vs Vercel AI Gateway](https://nrouter.ai/vs/vercel-ai-gateway): Feature and pricing comparison
- [Compare all gateways](https://nrouter.ai/vs): Side-by-side comparison hub

## Answers

Pages that answer specific buyer questions directly (each carries structured FAQ data; FE-POLISH-062 removed /compliance):

- [Help Center](https://nrouter.ai/help): Common questions about keys, credits, billing, limits, and errors
- [Trust Center](https://nrouter.ai/trust): Security posture, subprocessors, data handling, and uptime commitments
- [Security](https://nrouter.ai/security): Encryption, key isolation, access control, and vulnerability reporting
- [Migrate to nRouter](https://nrouter.ai/migrate): Step-by-step migration from OpenAI, OpenRouter, Portkey, and other gateways
- [Cost Calculator](https://nrouter.ai/cost-calculator): Compare real per-model spend against a public-gateway markup
- [Use Cases](https://nrouter.ai/use-cases): [RAG](https://nrouter.ai/use-cases/rag) · [Agents](https://nrouter.ai/use-cases/agents) · [Customer Support](https://nrouter.ai/use-cases/customer-support) · [Code](https://nrouter.ai/use-cases/code) · [Document Processing](https://nrouter.ai/use-cases/document-processing) · [Voice](https://nrouter.ai/use-cases/voice)
- [Solutions by Industry](https://nrouter.ai/solutions): [Finance](https://nrouter.ai/solutions/finance) · [Healthcare](https://nrouter.ai/solutions/healthcare) · [Legal](https://nrouter.ai/solutions/legal) · [Retail](https://nrouter.ai/solutions/retail) · [Government](https://nrouter.ai/solutions/government) · [Education](https://nrouter.ai/solutions/education)

## API

- Base URL: `https://api.nrouter.ai/v1`
- Auth: `Authorization: Bearer <NROUTER_API_KEY>`
- Format: JSON (OpenAI-compatible request/response shape)
- Env var: `NROUTER_API_KEY`
- OpenAPI spec: https://nrouter.ai/.well-known/openapi.json
- Live model catalog (JSON, no key required): https://nrouter.ai/api/public/models — every live model with per-token pricing, context window and capabilities. Also /api/public/models/featured and /api/public/models/latest.
- AI plugin manifest: https://nrouter.ai/.well-known/ai-plugin.json
- Response metadata uses `x-nr-*`: `x-nr-request-id`, `x-nr-model`, `x-nr-request-cost` with `x-nr-cost-status`, token headers, and `x-nr-response-cache` / `x-nr-response-cache-age` for executable-cache status

## Quick Start

```python
from openai import OpenAI

client = OpenAI(
    api_key="your-nrouter-api-key",
    base_url="https://api.nrouter.ai/v1",
)

# with_raw_response for headers
raw_response = client.chat.completions.with_raw_response.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": "Hello!"}],
)

response = raw_response.parse()
print(response.choices[0].message.content)
print("Cost USD:", raw_response.headers.get("x-nr-request-cost"))
```

## SDKs

Official, open source (MIT), and the only packages nRouter publishes:

- Repository: https://github.com/nRouterGateway/nrouter-sdk
- Python: pip install nrouter-sdk - https://pypi.org/project/nrouter-sdk/ (imports as nroutersdk)
- JavaScript / TypeScript: npm install @nrouter_ai/sdk - https://www.npmjs.com/package/@nrouter_ai/sdk

Any OpenAI-format client also works unchanged by setting the base URL and key;
the SDK is a convenience wrapper, not a requirement. The gateway additionally
serves Anthropic's Messages API natively at https://api.nrouter.ai/v1/messages.

## Published Writing

Articles, release notes and announcements, newest first. The complete list is at https://nrouter.ai/blog, https://nrouter.ai/changelog and https://nrouter.ai/press; RSS at https://nrouter.ai/feed.xml.

### Blog

- [Measure TTFT and Trace an LLM Request Step by Step in Python](https://nrouter.ai/blog/guides/measure-ttft-trace-llm-request-python) (2026-10-15): Send an nrouter/auto request with the Python SDK, read routing, guardrails and cost from its headers, fetch the request back by id, print every gateway step with its start, end and duration, then measure TTFT and latency over N runs.
- [Two Ways to Ask for a Model: Direct, or nrouter/auto](https://nrouter.ai/blog/product/llm-model-routing-direct-or-auto) (2026-10-15): nRouter gives you two ways to ask for a model. Name one and it is never swapped, except through a fallback you configured. Send nrouter/auto and nRouter chooses, by Best for the task or Lowest cost.
- [Warm Connection Pools in an LLM Gateway, and What They Do Not Fix](https://nrouter.ai/blog/engineering/sub-2ms-llm-gateway-routing-warm-http2-pools) (2026-09-27): What a reused provider connection saves an LLM request, what it cannot save, and how to measure the gateway's share of your latency instead of trusting a headline number.
- [LLM Observability: Traces, Spend Logs, and Request Debugging](https://nrouter.ai/blog/product/llm-observability) (2026-09-25): Inspect end-to-end inference traces, exact-cent spend rows, and multi-provider routing decisions under one request ID, with response headers on every call.
- [How to Benchmark an LLM Gateway in Production: Cost, Latency, Reliability, and Quality](https://nrouter.ai/blog/engineering/llm-gateway-benchmark) (2026-09-10): Follow a repeatable LLM gateway benchmark methodology for cost, latency, reliability, failover, and output quality before publishing measured results.
- [LLM Streaming Failures: Why Mid-Stream Retry Duplicates Output](https://nrouter.ai/blog/engineering/llm-streaming-failure-recovery) (2026-08-26): Understand where LLM streaming failover stops being safe, why partial output cannot be replayed silently, and how clients recover without duplicated text.
- [Four Outcomes That Get an LLM Gateway Funded](https://nrouter.ai/blog/company/business-case-llm-gateway) (2026-06-24): Build the internal business case for an LLM gateway on four quantifiable outcomes: total spend reduction, cost per call, tail latency, and developer speed.
- [Budget Ceilings That Turn AI Spend Into a Forecast](https://nrouter.ai/blog/product/predictable-ai-spend) (2026-06-24): A forecast is only a forecast if the worst case is bounded. Set hard dollar ceilings at the org, team, user and key scope, decompose next month's number into them, and know exactly which code your client gets when one bites.
- [Ship Your First AI Feature: Signup to Production in an Afternoon](https://nrouter.ai/blog/guides/ship-ai-features-faster) (2026-06-24): A step-by-step path from a funded nRouter account to a production LLM call with a spend ceiling on it — create a scoped key, point your existing OpenAI client at one base URL, cap the key, and verify the cost header came back.
- [Latency Routing and Automatic Failover Without Retry Code](https://nrouter.ai/blog/guides/route-requests-for-performance) (2026-06-24): Point a router alias at a candidate set with the Latency strategy, keep the automatic cross-provider failover, tune the two settings that decide how fast a bad provider is abandoned, and prove the effect on your own p95.
- [Cut LLM Costs by Routing, Not by Rewriting Your App](https://nrouter.ai/blog/product/reduce-ai-costs-smart-routing) (2026-06-24): Routing is the one cost lever you can pull from a dashboard. Point an alias at a set of models, choose cost or latency or weighted, and change what a request costs without touching a line of application code.
- [One API Key Across Providers: The Integration You Stop Writing](https://nrouter.ai/blog/product/one-api-key-llm-providers) (2026-06-24): Provider breadth behind a single OpenAI-compatible key. What the swap changes in your codebase, what the model string buys you, which providers are live today, and the integration work that stops being yours to maintain.
- [5% of Requests, 60% of the Bill: Reading Cost Against Usage](https://nrouter.ai/blog/engineering/cost-vs-usage-analytics) (2026-06-15): Request count and dollar cost tell different stories, and the gap between them is where the savings are. Here are the four shapes an overlay of cost and usage produces, which one to chase first, and what makes the numbers trustworthy enough to act on.
- [LLM Logs in Datadog and Langfuse: What Works Today](https://nrouter.ai/blog/guides/datadog-langfuse-llm-callbacks) (2026-06-15): nRouter does not deliver request logs to Datadog or Langfuse yet. Here is what works today: response headers, request tags, CSV export and alert channels.
- [Write-Time PII Redaction in LLM Logs, Without Losing Debug Detail](https://nrouter.ai/blog/engineering/pii-redaction-in-logs) (2026-06-15): Learn how write-time redaction, typed placeholders, and metadata scrubbing keep LLM request logs fully debuggable without storing sensitive customer PII.
- [Read an LLM Credit Ledger: Top-Ups, Holds, Settlements](https://nrouter.ai/blog/guides/reading-a-spend-ledger) (2026-06-15): Your balance is not a stored number, it is the sum of a ledger. Here is how to read the four numbers on the balance card, the entry types behind them, and the two identities that prove your balance is doing what it should.
- [Budgets vs Rate Limits: Pick the Control, Then Set Both](https://nrouter.ai/blog/guides/budgets-vs-rate-limits) (2026-06-15): A budget caps dollars over a window and answers 402; a rate limit caps RPM/TPM right now and answers 429. Here is how to classify the risk, set each control in the dashboard, and write client code that tells the three rejections apart.
- [What an LLM Request Log Should Contain — and What to Leave Out](https://nrouter.ai/blog/guides/llm-observability-request-logs) (2026-06-15): The fields that make an LLM request log worth keeping, the content that turns it into a liability, and how a gateway's built-in logs compare with running your own self-hosted trace store.
- [LLM Latency: p50, p95, p99, and Time-to-First-Token](https://nrouter.ai/blog/engineering/latency-percentiles-p50-p95-p99) (2026-06-15): Why average LLM latency misleads, how to analyze p50/p95/p99 distributions and time-to-first-token, and how to isolate tail delays across model providers.
- [Gateway Credits vs Prepaid Tokens: How the Balance Works](https://nrouter.ai/blog/guides/credits-vs-prepaid-tokens) (2026-06-15): Prepaid tokens are one provider's currency, priced against one rate card. Gateway credits are dollars that fund any model behind one key. Here is how to consolidate, read the balance card, and prove each call settled at real cost.

### Changelog

- [v1.0.1 — Capability discovery + honest 501s](https://nrouter.ai/changelog/v1-0-1-capability-discovery) (2026-05-16): Endpoints that aren't yet wired now return a clear HTTP 501 with a roadmap pointer instead of a confusing upstream error. New /capabilities endpoint lets SDKs introspect what's live.
- [v1.0 — Public Launch](https://nrouter.ai/changelog/v1-0-launch) (2026-05-05): nRouter v1.0 is live — managed LLM gateway with the full Google Vertex AI lineup, full dashboard, credit-based billing, AI guardrails, prompt management, A/B testing, team-scoped budgets, and observability — every feature on every tier.
- [v0.8 — Observability: logs, callbacks, alerts, data policy](https://nrouter.ai/changelog/v0-8-observability) (2026-04-25): Request-log search, budget and spend alerts, and a data policy page. Corrected 2026-10-07: request logs are not delivered to external tools, and prompt and response text are never stored.
- [v0.7 — Model catalog with leaderboard rankings](https://nrouter.ai/changelog/v0-7-model-catalog) (2026-04-20): Browse every registered model on one page. Sort by latency, cost, or quality. Switch models with a one-line env var change — your code stays exactly the same.
- [v0.6 — GDPR data subject requests](https://nrouter.ai/changelog/v0-6-gdpr-compliance) (2026-04-15): Self-service GDPR access, erasure, withdraw-consent, and consent records. Every administrative action lands in the audit trail. SOC 2 controls are active. HIPAA-eligible with a BAA on Enterprise.
- [v0.5 — Credit safety: reserve + settle](https://nrouter.ai/changelog/v0-5-credit-safety-reserve-settle) (2026-04-10): Every LLM request now reserves credits before the call, settles against the real cost after, and releases the hold on every failure path. Negative balances are blocked at the database — not by application logic.
- [v0.4 — Team management](https://nrouter.ai/changelog/v0-4-team-management) (2026-04-05): Invite teammates, assign roles (owner / org_admin / member / viewer), and see per-key spend by member. Single-org-per-user enforced at the database; one team per user within that org, by design.
- [v0.3 — Usage analytics dashboard](https://nrouter.ai/changelog/v0-3-usage-analytics) (2026-04-01): Per-model, per-key, per-team spend charts on a single page. Filter by date range, export CSV, drill into outliers. Numbers render in Geist Mono — easy on the eyes during the monthly close.
- [v0.2 — Prompt management with A/B testing](https://nrouter.ai/changelog/v0-2-prompt-management-ab-testing) (2026-03-25): Server-side prompt templates with versioning and Jinja2 variables, plus deterministic traffic-split A/B tests. Same hash, same variant — every single time.
- [v0.1 — Guardrails: pre/post-call enforcement](https://nrouter.ai/changelog/v0-1-guardrails) (2026-03-20): Guardrails in the request path on every plan — PII redaction, prompt-injection detection, keyword blocklists, and post-call response scanning — scoped at org, team, and key level.

### Press releases

- [Enterprise Adoption Surges as nRouter Reaches SOC 2 Type II In-Progress Milestone and Launches Dedicated VPC Deployments](https://nrouter.ai/press/enterprise-adoption-soc2) (2026-10-01): Accelerating enterprise adoption across fintech and digital health with institutional security, Postgres Row-Level Security isolation, and private VPC deployment options.
- [nRouter Expands Gateway to 100+ Multimodal Models](https://nrouter.ai/press/multimodal-fleet-expansion) (2026-09-16): Unified enterprise inference across Google Vertex AI, Anthropic Claude, OpenAI, AWS Bedrock, Meta Llama, and DeepSeek with sub-millisecond provider failover and multimodal support.
- [nRouter Abolishes Broker Markups with Flat List-Price Settlement and FinOps FOCUS 1.4 Tokenomics](https://nrouter.ai/press/zero-markup-finops-revolution) (2026-08-19): Eliminating the 15% broker markup tax: nRouter establishes 0% per-token markup, settling at exact upstream provider list prices with automated 3-way FinOps FOCUS 1.4 reconciliation.
- [nRouter Sets New AI Gateway Speed Benchmark with Sub-Millisecond p99 Overhead Powered by Pure Rust Engine](https://nrouter.ai/press/rust-sub-millisecond-engine) (2026-07-24): Independent stress testing confirms nRouter's asynchronous Rust gateway streams tokens at wire speed with sub-millisecond p99 latency overhead, outperforming legacy Python and Node.js proxies.
- [nRouter Unveils Isolated Content Inspection for Zero-Leakage LLM Defense](https://nrouter.ai/press/cortex-air-gapped-security) (2026-06-18): nRouter introduces isolated content inspection — model-scored prompt-injection and moderation checks with no database access and no network egress — that refuses unsafe prompts with zero token spend on blocked requests.
- [nRouter Launches Managed LLM Gateway with Every Enterprise Feature on Every Tier](https://nrouter.ai/press/nrouter-launch) (2026-05-05): nRouter is publicly available — a managed LLM gateway providing one API key, one bill, and every governance feature (guardrails, audit logs, budgets, A/B testing) unlocked on every tier. A 0% platform fee undercuts public-gateway norms.

## Company

- Website: https://nrouter.ai
- Legal entity: CloudAct Inc., 100 S Murphy Ave STE 200 PMB4013, Sunnyvale, CA 94086, USA
- GitHub: https://github.com/nRouterGateway
- X / Twitter: https://x.com/NRouterAI
- LinkedIn: https://www.linkedin.com/company/nrouterai/
- Facebook: https://www.facebook.com/nRouterLLMGateway
- Discord: https://nrouter.ai/discord
- Product Hunt: https://www.producthunt.com/products/nrouter
- Slack community: https://nrouter.ai/community
- Support: support@nrouter.ai
- Sales: sales@nrouter.ai
- Security: security@nrouter.ai

## Extended Context

For comprehensive product information, every endpoint, and detailed feature documentation, see [llms-full.txt](https://nrouter.ai/llms-full.txt).