# nRouter — Enterprise LLM Gateway & Smart Routing Platform > One key, one bill, zero provider configuration. The managed LLM gateway for teams. Last updated: 2026-10-24 — this file is generated from the live router catalog and regenerated hourly. For AI crawlers: the full catalogue as one text-only HTML page — https://nrouter.ai/for-ai ## What Is nRouter? nRouter is a managed LLM gateway that gives teams a single API key to access 285 AI models across 7 provider clouds — OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI. It is a fully hosted, OpenAI-compatible API service: users never configure provider keys, never manage infrastructure, and never worry about which provider is cheapest. They buy credits, call our API, and nRouter handles routing, cost tracking, guardrails, and safety. There is no BYOK (bring-your-own-key). nRouter manages every upstream provider account on the customer's behalf. The API endpoint is OpenAI-compatible, meaning any application that works with the OpenAI SDK works with nRouter by changing two lines of code (the API key and the base URL). nRouter is a product of CloudAct Inc. (Sunnyvale, CA). It competes with OpenRouter (a public LLM gateway that charges a 5.5% markup and has no built-in guardrails), Portkey (BYOK plus per-feature pricing), and Helicone (observability only, not a gateway). ## Key Facts - 285 models live now across 7 provider clouds — OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI. Coverage: Alibaba US (Qwen, DeepSeek — our largest catalog), OpenAI (GPT, o-series), Azure Foundry, Google Vertex AI (Gemini), and Anthropic (Claude) live today - OpenAI-compatible — drop-in replacement for any OpenAI SDK integration - No BYOK — nRouter manages every provider key; you only ever hold a nRouter key - Platform-fee pricing, not feature gating: Pay as you go carries a 0% platform fee (no fee on top of credits), with no minimum fee. - 0% markup (zero per-token markup) on model tokens; inference spend is settled at the exact provider list price - Every feature is unlocked on every tier — guardrails, prompts, A/B tests, RBAC, SSO, audit logs, observability - Price-match guaranteed on every model - 99.9% uptime SLA on production traffic ## Getting Started 1. Sign up at https://nrouter.ai/signup and add a card (Pay as you go starts with a $5 minimum credit purchase, 0% platform fee) 2. Get a nRouter API key — one key works for every model 3. Buy credits pay-as-you-go ($5 minimum, 0% platform fee) 4. Point your OpenAI SDK at https://api.nrouter.ai/v1 with your nRouter key 5. Call any model — nRouter routes the request, applies guardrails, and tracks spend in real time ## Pricing nRouter uses a platform-fee model. 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. Customers always receive 100% of the credits they purchase. 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. | Tier | Commitment | Platform fee | Guaranteed throughput | |------|------------|--------------|------------------------| | Pay as you go (No commitment. Buy credits and pay only for what you use.) | None | 0% | 200 RPM / 200,000 TPM / 5 concurrent requests | | Enterprise (Custom deployment, limits and terms.) | Custom | Custom | Custom RPM / TPM | - Price match guaranteed: Find a lower price on any model from another gateway? We'll match it. No questions asked. - Every feature included: Guardrails, prompt templates, team management, analytics, SSO, audit logs — all included on every tier. One key, one bill, every feature. - All features are included on pay as you go with 200 RPM / 200k TPM / 5 concurrent. Enterprise plans offer custom throughput and dedicated capacity. Existing subscribers keep their plan and allowance. ## Models nRouter serves 285 distinct models live today across OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI. By provider cloud, largest catalog first (generated 2026-10-24 from the live router): - OpenAI — 110 models: gpt-4.1, gpt-3.5-turbo-16k, gpt-4o-2024-08-06, gpt-4-turbo-2024-04-09 - Alibaba US — 78 models: glm-5.3-prime, qwen-plus-latest, qwen3.7-max-2026-05-17, qwen-plus-2025-01-25 - AWS Bedrock — 49 models: qwen3-235b-a22b-2507, llama4-maverick-17b-instruct, glm-5, ministral-3-8b-instruct - Google Vertex AI — 22 models: gpt-oss-120b-maas, glm-4.7-maas, qwen3-next-80b-a3b-instruct-maas, deepseek-v3.2-maas - Anthropic — 13 models: claude-opus-5-5, claude-fable-5-1, claude-opus-5, claude-opus-4-5-20251101 - Azure Foundry — 12 models: Phi-4-multimodal-instruct, mistral-small-2503, Phi-4, Llama-4-Maverick-17B-128E-Instruct-FP8 - TypeSafe AI — 1 model: typesafe/jev Every model above is reachable with the same nRouter API key — no per-cloud account, no per-cloud key. New flagship models are added within days of general availability. Provider availability varies by region. Browse the catalog with per-model pricing and capabilities at https://nrouter.ai/models, explore the live Pareto frontier and compare empirical metrics on https://nrouter.ai/leaderboard, or fetch the complete machine-readable list (per-token pricing, context window, capabilities; JSON, no key required) at https://nrouter.ai/api/public/models. ## Features - One OpenAI-compatible API key for every model — no per-provider keys, no BYOK - Two ways to ask for a model. Direct: you choose the model and nRouter never swaps it for another; a different model answers only through a fallback you configured yourself (a fallback list for that model in Router Settings, or nrouter_fallbacks on the request), and only when the provider cannot take the request - nrouter/auto: nRouter chooses an eligible model. "Best for the task" (default) uses smart model selection when it is available; "Lowest cost" orders the models fit for the task by the lowest list rate: input plus output price per million tokens, weighted equally, read live from the catalogue. Either way the request is billed at the served model's list price, and the x-nr-model response header names it - Built-in guardrails: PII detection and redaction, keyword rules, secret scanning, and prompt-injection defense — pre-call and post-call, scoped per key, per team, or per org - Prompt template management with versioning and variable substitution - Deterministic A/B testing across model and prompt variants - Real-time cost tracking — per request, per model, per team, and per key - Programmatic cost read-back — GET /api/nrouter-proxy/spend/by-key?request_id=, authenticated with the same nRouter API key, returns that single request's settled spend, token counts, latency and cache state; an unpriced request reports spend: null with cost_status: "unpriced", never 0 - Per-key and per-team budgets with hard enforcement (402 when exceeded; 429 for RPM/TPM rate limits) - Exportable CSV analytics and latency percentiles (p50 / p95 / p99) - Team management with role-based access control (owner / org_admin / member / viewer, plus team_admin / team_member) - SSO / SAML, immutable audit logs, custom branding, GDPR consent tracking — all included on every tier - Interactive browser playground for testing any model with your own virtual key ## API - Base URL: https://api.nrouter.ai/v1 - Authentication: `Authorization: Bearer ` - Format: JSON, OpenAI-compatible request/response shape - Environment variable: `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 - Streaming: Server-Sent Events (`stream: true`), identical to the OpenAI streaming protocol - Function / tool calling: supported on models that expose it upstream - 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 ### Core endpoints The gateway serves these fifteen `/v1/*` inference and catalog routes, plus `/mcp` and `/mcp/{server_id}` for Model Context Protocol (MCP) tool proxying. - POST `/v1/chat/completions` — chat completions (streaming and non-streaming) - POST `/v1/completions` — legacy text completions - POST `/v1/responses` — OpenAI Responses API - POST `/v1/messages` — Anthropic Messages API, served natively - POST `/v1/messages/count_tokens` — token counting for the Messages format - POST `/v1/embeddings` — text embeddings - POST `/v1/images/generations` — image generation - POST `/v1/audio/speech` — text to speech - POST `/v1/audio/transcriptions` — speech to text - POST `/v1/audio/translations` — speech translated to English text - POST `/v1/videos` — create a video generation job - GET `/v1/videos/{id}` — poll a video job - GET `/v1/videos/{id}/content` — download finished video content - GET `/v1/models` — list available models - GET `/v1/models/{model_id}` — retrieve one model Usage and spend reporting is available in the dashboard and via the usage API. ## Quick Start (Python) ```python from openai import OpenAI client = OpenAI( api_key="your-nrouter-api-key", base_url="https://api.nrouter.ai/v1", ) raw_response = client.chat.completions.with_raw_response.create( model="gemini-2.5-flash", messages=[{"role": "user", "content": "Explain LLM gateways in one sentence."}], ) response = raw_response.parse() print(response.choices[0].message.content) print("Cost USD:", raw_response.headers.get("x-nr-request-cost")) ``` ## Quick Start (JavaScript / TypeScript) ```javascript import OpenAI from "openai"; const client = new OpenAI({ apiKey: process.env.NROUTER_API_KEY, baseURL: "https://api.nrouter.ai/v1", }); const response = await client.chat.completions.create({ model: "gemini-2.5-flash", messages: [{ role: "user", content: "Explain LLM gateways in one sentence." }], }); console.log(response.choices[0].message.content); ``` ## Comparison: nRouter vs OpenRouter OpenRouter charges a 5.5% markup on every API call and offers no built-in guardrails or team controls. nRouter charges a 0% platform fee pay-as-you-go with no fee on top and no minimum fee, and includes guardrails, prompt management, A/B testing, team RBAC, SSO, and audit logs on every tier. See https://nrouter.ai/vs/openrouter. ## Frequently Asked Questions **What is nRouter?** nRouter is a managed LLM gateway that gives teams one API key to access 285 AI models across 7 provider clouds (OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI). We manage all provider keys, routing, cost tracking, and safety. **How much does nRouter cost?** nRouter charges 0% platform fee and 0% per-token markup: inference spend settles at the served model's exact provider list price. Pay as you go carries a 0% platform fee (no fee on top of credits), with no minimum fee. A credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00; minimum $5). Every feature is included on pay as you go with rate limits of 200 RPM / 200k TPM / 5 concurrent. Existing subscribers keep their plan and its allowance. Enterprise is custom deployment via sales. **Is nRouter OpenAI-compatible?** Yes. The API at https://api.nrouter.ai/v1 is OpenAI-compatible. Existing OpenAI SDK code works by changing two lines — the base URL and the API key. **Which models does nRouter support?** 285 models are live today across OpenAI, Alibaba US, AWS Bedrock, Google Vertex AI, Anthropic, Azure Foundry, and TypeSafe AI. Per cloud, largest first: OpenAI (110), Alibaba US (78), AWS Bedrock (49), Google Vertex AI (22), Anthropic (13), Azure Foundry (12), TypeSafe AI (1). See https://nrouter.ai/models for the live list in your region, or https://nrouter.ai/api/public/models for the machine-readable catalog. **Do I need my own provider API keys?** No. nRouter manages every provider account. You only hold a single nRouter API key, and you buy credits to pay for usage. **How does cost tracking work?** Every request is settled using the canonical provider cost, surfaced on the `x-nr-request-cost` response header. You get per-request, per-model, per-team, and per-key breakdowns in real time, plus budget enforcement at any of those scopes. ## 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. - Address: 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