BizNeuro.AI – Dashboard

BizNeuro.AI delivers a patented intelligent routing technology that helps enterprises reduce their AI costs significantly.

Intelligent Routing

Reduce AI Cost Maximize Value

Built for Safety

Industry Agnostic

Activity

Recent API calls made with your keys (last 100).

Timestamp	Model selected	Routing latency	Cost calculated	Cost saved	Prompt tokens	Completion tokens	Total tokens
Loading logs...

Page 1 of 1

Analytics

From To

💰

Total Spend

—

All-time API cost

⚡

Requests

—

API calls made

🔤

Token Volume

—

Prompt + Completion

⏱

Avg Latency

—

Response time

🛡

Cost Saved

—

Saved via routing

📈

Savings %

—

Percent saved vs baseline

Activity & Performance (Requests vs Latency) 30d

📈

No activity in this period

Cost Savings Over Time Cumulative

Model Distribution 0 models

🤖

No model usage data

Token Breakdown —

🔤

No token data

Completion Tokens

—

Output volume

Prompt Tokens

—

Input volume

Models Used

—

Distinct models

API Keys Active

—

Keys used

RouteNeuro - Intelligent Routing Technology

Connecting…

Send a Prompt

📎 Attach file — PDF, image, or video

Supported: .pdf · jpg / png / gif / webp · mp4 / webm / mov

Model Response

Response will appear here…

Routing Details

Compare vs:

Selected Model
—
Waiting for query…
                    

Complexity

—

Routing Time

—

RouteNeuro Cost

—

Baseline (GPT-4o)

—

Saved vs GPT-4o

—

—

Live Model Catalog — Loading…

Loading models…

Welcome back,

Here's your account overview.

Current Plan

—

Remaining Credits

—

Remaining Tokens

—

License Details

Account Email	—
Plan	—
Role	—
Credits Remaining	—
Tokens Remaining	—
License Type	Commercial – Single Seat
Renewal	Auto‑renew (monthly)

API Keys

Manage keys used to authenticate API requests.

Name	Prefix	Created	Last Used	Actions
Loading keys...

Page 1 of 1

Usage Example

curl https://api.bizneuro.ai/api/v1/chat/completions \
  -H "Authorization: Bearer bzn_YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [
      {"role": "user", "content": "Hello world"}
    ]
  }'

// Using the official OpenAI SDK
import OpenAI from 'openai';
const openai = new OpenAI({
  baseURL: 'https://api.bizneuro.ai/api/v1',
  apiKey: 'bzn_YOUR_KEY_HERE',
});
const completion = await openai.chat.completions.create({
  model: 'auto',
  messages: [{ role: 'user', content: 'Hello world' }],
});
console.log(completion.choices[0].message);

# Using the official OpenAI SDK
from openai import OpenAI
client = OpenAI(
    base_url="https://api.bizneuro.ai/api/v1",
    api_key="bzn_YOUR_KEY_HERE"
)
completion = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Hello world"}]
)
print(completion.choices[0].message)

Credits

Cycle	Amount	Status	Date	Action
Loading invoices...

Remaining Credits: $ --

Remaining Tokens: --

Recent Usage Log

Timestamp	Model	Tokens	Cost
Loading usage logs...

Page 1 of 1

Settings & Preferences

Personalize your AI routing experience. Changes apply to all future API requests.

Bring Your Own Key (BYOK)

Configure Bring Your Own Key (BYOK) and manage active models for RouteNeuro.

Provider API Keys

Provide your own API keys to be used for routing requests to external models.

OpenAI

Anthropic

Gemini (Google)

Model Preferences

Set your default model and routing strategy. These apply when no model is specified in the API request.

Preferred Model Used when SDK sends model="auto"

Fallback Model Used when preferred model is unavailable

Routing Strategy

AutoBalanced cost & quality CostMinimize spend QualityBest available model

Active Models

Select which models are active for your routing engine. Unselected models will be ignored.

Loading models...

Generation Parameters

Default parameters applied to all requests. Individual API calls can override these.

Temperature 1.0 Lower = more focused, Higher = more creative

Max Tokens 4096 Maximum tokens per response (1 - 128,000)

Top P 1.0 Nucleus sampling threshold (0.0 - 1.0)

Frequency Penalty 0.0 Reduces repetition (-2.0 to 2.0)

Presence Penalty 0.0 Encourages new topics (-2.0 to 2.0)

Budget Controls

Set spending limits to control costs. Set to 0 for unlimited.

Monthly Budget (USD)

Requests will be blocked when budget is exhausted

Alert Threshold 80% Get notified when spend reaches this % of budget

Logging & Privacy

Control what data is stored. Prompt logging is disabled by default for privacy.

Request Logging Log request metadata (endpoint, latency, model, cost)

Prompt Logging Store actual prompt and response content (privacy sensitive)

Log Retention Period Older logs will be automatically cleaned up

Total Users

—

Free

—

Paid

—

Admins

—

All Users

Email	Name	Tier	Role	Actions

Page 1 of 1

Global API Keys

Key Name	Prefix	User ID	Created At
Loading global keys...

Page 1 of 1

Global System Logs

Timestamp	User ID	Query Type	Model	Status	Latencies (API/Engine)	Tokens (P/C/T)	Cost
Loading global logs...

Page 1 of 1

User Subscriptions & Quotas

User Email	Plan	Credits Remaining	Tokens Remaining
Loading subscriptions...

Global Invoices

Invoice ID	User ID	Amount	Cycle	Status	Date
Loading global invoices...

CIO Intelligence Dashboard: AI Spend Command Center

Monthly AI spend

—

Budget remaining

—

RouteNeuro savings

—

ROI vs. list price

—

Routed vs. unrouted

Budget burn rate

62%

of monthly budget consumed

50% advisory 80% warning 90% critical

Spend by model

GPT 42% Claude 28% Gemini 18% Llama 12%

Monthly spend trend — before vs. after RouteNeuro

Without RouteNeuro With RouteNeuro

Monthly budget

Total budget (USD)

Simulated current spend

62%

$0$50,000

Alert thresholds

50% Advisory Forecast projection alert

80% Warning Finance + CIO notify

90% Critical Route throttle + escalate

Notify channels

Email Slack On Call

Alert history

Timestamp	Threshold	Spend at trigger	Action taken	Status
Jun 15 · 09:14	50%	$15,200	Forecast email sent	Resolved
Jun 26 · 14:37	80%	$40,100	CIO + Finance notified	Active
Jun 29 · 08:02	90%	$45,600	Route throttle activated	Escalated

Before vs. After RouteNeuro (current month)

Workload	Without RouteNeuro	With RouteNeuro	Savings	Reduction
Customer support (RAG)	$12,400	$4,960	$7,440	60%
Document summarization	$8,200	$2,870	$5,330	65%
Code generation	$14,600	$7,300	$7,300	50%
Data extraction (batch)	$9,800	$2,940	$6,860	70%
Agentic workflows	$18,000	$9,000	$9,000	50%
Total	$63,000	$27,070	$35,930	57%

Cost comparison by workload

Without RouteNeuro With RouteNeuro

Waste identified

$11,240

This month

Overprovisioned calls

38%

Frontier for simple tasks

PII exposure risk

Routes without masking

Recovery potential

$8,900

RouteNeuro re-route savings

Spend leakage patterns

Leakage pattern	Volume	Monthly waste	Recommended fix
GPT-4o for simple classification	142K calls	$4,260	Route → Haiku / Llama 3 8B
Retry storms (no circuit breaker)	22K excess	$1,980	Circuit breaker policy
Unmasked PII → frontier model	14 routes	$1,820	PII blocker — urgent
Off-peak calls to premium tier	67K calls	$1,040	Time-of-day routing

Leakage by pattern (USD/month)

Workload configuration

Monthly call volume

500K

Avg. prompt tokens per call

1200

Task complexity mix

Primary model (baseline)

Compliance regime

Routing preview

Configure a workload and click Run simulation to see how RouteNeuro's composite scoring function S(m) routes each task class, estimates savings, and enforces compliance.

Simulation result

—

Baseline cost/mo

—

With RouteNeuro

—

Cost reduction

Back to Dashboard

Integrate RouteNeuro API Onboarding & Integration Guide

API v1

1 Install the OpenAI SDK

Install the native RouteNeuro SDK client library for Python using pip.

pip install routeneuro

2 Generate an API key

Create a key from your workspace dashboard — see the API Key Generation tab for the full walkthrough.

Sample key

bzn_QcBTDXX2aIgVwssGFNIYwnj5-NlcpThkpDs7pyYPYbI

3 Send your first request

from openai import OpenAI
client = OpenAI(
    api_key="ROUTENEURO_API_KEY",
    base_url="https://stg-bizneuro-ai-1084382769362.asia-south1.run.app"
)
response = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)
print(response.rn_model_selected)

Generating an API key

API keys authorize your applications to access the RouteNeuro routing gateway. Manage your keys directly within the BizNeuro workspace dashboard.

1

Create Account & Open the BizNeuro Dashboard

Log in to the dashboard portal in your browser.
2

Navigate to the API Keys tab

From the left-hand sidebar navigation, click on the API Keys menu item.
3

Click "Create New Key"

Click the blue Create New Key button in the top right corner of the page.
4

Name your key

Give the key a descriptive name (e.g. development-backend or production-api) to identify where it is used.
5

Copy the key immediately

Copy the full key value immediately from the screen. For security reasons, the full key is shown only once and cannot be retrieved later. All RouteNeuro SDK keys are prefixed with bzn_.
6

Store it securely

Never hardcode live keys. Store them in a secrets manager and load them via the ROUTENEURO_CLIENT_API_KEY environment variable.

Authenticating a request

Pass the key as a bearer token on every request.

curl https://api.routeneuro.io/v1/chat/completions \
  -H "Authorization: Bearer $ROUTENEURO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "auto", "messages": [{"role": "user", "content": "Hi"}], "config": {"temperature": 0.7, "max_tokens": 100}}'

Enterprise workspaces can also authenticate via JWT (short-lived session tokens from /auth/token) or OAuth2/OIDC SSO through Okta, Azure AD, or Google Workspace.

Native RouteNeuro SDK

Install with pip install routeneuro for typed helpers on top of the OpenAI SDK — routing profile management, cost analytics, and feedback submission.

import os
from routeneuro import RouteNeuro
with RouteNeuro(
    api_key=os.environ["ROUTENEURO_API_KEY"]
) as client:
    response = client.chat.completions.create(
        model="auto",
        messages=[{"role": "user", "content": "Summarize this contract clause."}],
        routing_mode="quality",
        temperature=0.7,
        max_tokens=1000
    )
    print("Model used:", response.rn_model_selected)
    print("Cost:", f"${response.rn_cost_usd:.6f}")
    # Optional: feed a quality signal back into the routing model
    client.feedback.submit(trace_id=response.rn_trace_id, rating=5)

Streaming

Identical to the OpenAI streaming API. Routing overhead completes before the first token is dispatched, so time-to-first-token is preserved.

stream = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Write a short release note."}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

If a provider fails mid-stream, RouteNeuro surfaces the error rather than switching providers mid-response — fallback only operates pre-dispatch, to avoid incoherent output.

Native Node.js SDK

Install with npm install routeneuro for typed helpers in Node.js/TypeScript.

import { RouteNeuro } from 'routeneuro';
const client = new RouteNeuro({
    apiKey: process.env.ROUTENEURO_API_KEY,
    baseUrl: "https://api.routeneuro.io/v1"
});
async function main() {
    const response = await client.chat.completions.create({
        model: 'auto',
        messages: [{ role: 'user', content: 'Summarize this contract clause.' }],
        routing_mode: 'quality',
        temperature: 0.7,
        max_tokens: 1000
    });
    console.log("Model used:", response.rn_model_selected);
    console.log("Cost:", `$${response.rn_cost_usd.toFixed(6)}`);
    // Optional: feed a quality signal back into the routing model
    await client.feedback.submit(response.rn_trace_id, { rating: 5 });
}
main().catch(console.error);

Standard integration (OpenAI SDK)

The fastest path for any codebase already using the OpenAI Python SDK. Pass personalization configuration using extra_body.

import os
from openai import OpenAI
client = OpenAI(
    api_key=os.environ["ROUTENEURO_API_KEY"],
    base_url="https://api.routeneuro.io/v1",
)
response = client.chat.completions.create(
    model="auto",  # delegate model choice to the routing engine
    messages=[
        {"role": "system", "content": "You are a support triage assistant."},
        {"role": "user", "content": "My invoice shows a duplicate charge."},
    ],
    extra_body={
        "config": {
            "temperature": 0.7,
            "max_tokens": 1000,
            "routing_mode": "cost"
        }
    }
)
print(response.choices[0].message.content)
print(response.rn_model_selected)

Endpoint

POST https://api.routeneuro.io/v1/chat/completions — 100% OpenAI Chat Completions compatible.

Body parameters

Parameter	Type		Description
`model`	string	Required	Target model ID, or `auto` to let the routing engine choose.
`messages`	array	Required	Standard OpenAI-format message array (system / user / assistant roles).
`stream`	boolean	Optional	Enables server-sent event streaming. Default `false`.
`temperature`	float	Optional	Passed through to the winning provider unchanged. Can also be passed inside the `config` object.
`max_tokens`	integer	Optional	Output token cap, passed through to the provider. Can also be passed inside the `config` object.
`config`	object	Optional	Personalization configurations container. Supports: `temperature`, `max_tokens`, `top_p`, `frequency_penalty`, `presence_penalty`, `preferred_model`, `fallback_model`, `routing_mode`, `request_logging`, `prompt_logging`, `monthly_budget_usd`.

Routing control headers

Routing behavior is controlled via headers, not schema changes — your request body stays pure OpenAI format.

Header		Description
`Authorization`	Required	`Bearer <api_key>`
`X-RouteNeuro-Mode`	Optional	`auto` · `cost` · `quality` · `fixed:{model_id}`
`X-RouteNeuro-Budget`	Optional	Maximum cost in USD allowed for this request.

Response envelope

Standard OpenAI-format JSON, extended with flat rn_ metadata fields directly at the root of the response describing the routing decision.

{
  "id": "chatcmpl-8f2a1c9b",
  "object": "chat.completion",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 42, "completion_tokens": 118, "total_tokens": 160 },
  "rn_model_selected": "claude-3-5-sonnet",
  "rn_model_requested": "auto",
  "rn_routing_latency_ms": 0.66,
  "rn_cost_usd": 0.000842,
  "rn_cost_saving_usd": 0.002403,
  "rn_task_class": "information_and_reasoning:low",
  "rn_input_type": "text",
  "rn_output_type": "text",
  "rn_cache_hit": false,
  "rn_trace_id": "tr_9f1c2e7a"
}

Field reference — `rn_` parameters

rn_model_selected — the downstream model that ultimately served the request.
rn_model_requested — the target model ID requested by the client (e.g. auto).
rn_routing_latency_ms — the latency overhead of the routing classifier in milliseconds.
rn_cost_usd — actual cost of this request in USD based on measured token usage.
rn_cost_saving_usd — amount saved in USD relative to standard baseline model pricing.
rn_task_class — task category scorer (e.g. creative_expression:low).
rn_cache_hit — true if served from the semantic cache instead of a live model call.
rn_trace_id — correlates this request with audit logs and the feedback API.

The questions most new clients ask while wiring up the SDK.

Why should I use RouteNeuro?

Every AI inference call made today is routed by hand — hardcoded model names, manual provider selection, or no routing at all. That means GPT-4-class spend on tasks a smaller model handles equally well, compliance-sensitive prompts reaching non-compliant providers, and agentic pipelines failing silently under load.

RouteNeuro sits between your application and every model provider, making that routing decision in real time using four signal classes: semantic task complexity, per-token econometrics, operational health (rate limits, circuit breakers), and governance constraints (data residency, PII, compliance policy). The result:

40–70% inference cost reduction — verified across production workloads
<10ms P99 routing overhead — sub-millisecond scorer; classifier adds ~5ms
91%+ routing accuracy — outperforms OpenRouter (83%) and RouteLLM/Portkey (63%)
Compliance built in — PII masking, data residency enforcement, and SHA-256 audit trails run on every request path, not as post-processing
Zero code changes — OpenAI-compatible API; set base_url and routing activates transparently

RouteNeuro is backed by a patent-filed composite scoring architecture and is the only routing middleware that treats PII sensitivity as a first-class routing input.

What LLM models does RouteNeuro support?

RouteNeuro currently routes across the following provider families:

OpenAI — GPT-4o, GPT-4o-mini, o1, o3-mini, and prior GPT-4 variants
Anthropic — Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku, and successor releases
Google — Gemini 1.5 Pro, Gemini 1.5 Flash, Gemini Ultra
Mistral — Mistral Large, Mistral Small, Mixtral 8×7B
Open-weight — Llama 3, Qwen 2.5, DeepSeek R1/V3, Phi-3, Gemma — served via Ollama or compatible inference endpoints
Custom — proprietary fine-tuned models hosted on GCP, AWS, or Azure via the custom model registry API

Developer-tier accounts access mid-tier models across three providers. Growth and above unlock the full candidate pool including frontier models (GPT-4o, Claude 3 Opus, Gemini Ultra). The current model index is always visible in the dashboard under Model Registry.

What is the expected latency across different models?

RouteNeuro's internal routing overhead is <10ms P99 (classifier: ~5ms; scorer: ~1ms; cache lookup: ~1ms; PII detection: ~1.5ms; gateway: ~1ms). This overhead is additive to the model's own time-to-first-token (TTFT) and generation latency.

Live P50 latency per provider is surfaced in the Provider Health Panel (paid plans), updated every 30 seconds. Approximate TTFT ranges from the RouteNeuro Model Registry:

Fast tier (Gemini Flash, GPT-4o-mini, Groq-hosted Llama): 200–600ms TTFT
Mid tier (GPT-4o, Claude 3.5 Sonnet, Mistral Large): 600ms–2s TTFT
Frontier tier (Claude 3 Opus, o1, Gemini Ultra): 2–8s TTFT depending on reasoning depth

The routing engine can optimise for latency by setting X-RouteNeuro-Mode: quality or adjusting the latency preference slider in routing profile settings. At >8K token prompts, the classifier truncates to the first 1,024 tokens to preserve the sub-10ms overhead guarantee.

What data is logged during API use?

For every API request, RouteNeuro logs the following to an append-only, SHA-256 hash-chained audit store:

Timestamp, tenant ID, workspace ID, trace ID
Task classification output (task type, complexity score, domain tags) — derived from the prompt, not the prompt itself
Routing decision: candidate models scored, winning model, scoring weights applied, confidence level
Cost estimate vs. actual token counts (input/output)
Provider response latency (P50, P99) and circuit breaker state at time of dispatch
PII detection outcome — entity types detected and action applied (MASK/HASH/BLOCK/ALLOW). Raw PII values are never stored; SHA-256 hashes are stored for correlation only
Response quality feedback, if submitted via the feedback API

Prompt content and model responses are not stored by default. Tenants may opt in to request/response logging for debugging purposes via a dashboard toggle; this is a tenant-controlled, off-by-default setting subject to their own data retention policy.

What data is logged during playground use?

The RouteNeuro playground (app.routeneuro.io/playground) is a UI layer over the same API; the same logging rules apply. Additionally:

Session interactions (prompts and responses) are retained for 7 days in the playground to support the session history panel, then permanently deleted
Routing decision metadata and cost breakdown displayed in the playground UI are drawn from the same telemetry store as the API and are subject to the same retention policy as your plan tier
Playground sessions are isolated per workspace; team members cannot see each other's playground sessions unless the workspace admin explicitly enables session sharing

Playground data is never used to train the routing classifier or any model without explicit tenant consent via the feedback opt-in toggle.

How long does integration actually take?

Under five minutes for any application already on the OpenAI SDK: sign up, generate a key, install the package (or skip it and use the REST API directly), and change base_url. No prompt or schema rewrites are required.

What authentication methods are supported?

API key (bearer token) is the primary method for server-to-server calls. JWT short-lived tokens are available via /auth/token, and OAuth2/OIDC SSO is supported for Okta, Azure AD, and Google Workspace on enterprise plans. Keys are scoped per workspace and AES-256 encrypted at rest.

Do I need to change my request or response handling?

No. RouteNeuro uses the OpenAI Chat Completions schema natively for both requests and responses. Routing control is passed through optional headers or the optional request-level config object, and the extra root-level rn_ metadata parameters in the response are additive — existing response parsing keeps working unmodified.

What happens if my chosen model or provider is unavailable?

A per-provider circuit breaker tracks health in real time. On failure, RouteNeuro auto-falls-back to the next-ranked candidate in a pre-computed chain (configurable depth 1–3), so fallback latency is negligible. You can switch to fail-fast mode if your application handles retries itself.

How are rate limits calculated?

Rate limits in RouteNeuro operate at two levels:

RouteNeuro gateway limits — applied per workspace per minute, based on your subscription tier. Developer: 60 RPM / 100K TPM. Growth: 600 RPM / 5M TPM (monthly). Business: 3,000 RPM / 50M TPM (monthly). Enterprise: custom.
Provider pass-through limits — RouteNeuro monitors the rate-limit headroom on each provider in real time (displayed as a fraction of per-minute quota remaining in the Provider Health Panel). The routing scorer factors in headroom as part of the operational signal class — providers near saturation are deprioritised before they are rate-limited, reducing hard 429 errors at the source.

If you hit a RouteNeuro gateway limit, the response includes a Retry-After header. If the underlying provider returns a 429, RouteNeuro automatically routes to the next-ranked candidate in the fallback chain rather than surfacing the error to the caller.

Which languages have SDK support?

Native SDKs ship for Python (pip install routeneuro) and Node.js/TypeScript (npm install routeneuro). Because the API is fully OpenAI-compatible, any language with an OpenAI SDK — Go, Java, Ruby, PHP, .NET — integrates by setting base_url, no native SDK required.

Is my prompt content stored anywhere?

Not by default. RouteNeuro logs routing decisions, cost, latency, and PII-detection outcomes to an audit store — but prompt content and model responses are not retained unless you explicitly opt in to request/response logging from the dashboard for debugging.

Sign in to your account

Enter details to create account

Activity

Welcome back,

License Details

API Keys

Usage Example

Credits

Remaining Credits: $ --

Recent Usage Log

Settings & Preferences

Bring Your Own Key (BYOK)

Provider API Keys

Model Preferences

Active Models

Generation Parameters

Budget Controls

Logging & Privacy

All Users

Global API Keys

Global System Logs

User Subscriptions & Quotas

Global Invoices

1 Install the OpenAI SDK

2 Generate an API key

3 Send your first request

Generating an API key

Authenticating a request

Native RouteNeuro SDK

Streaming

Native Node.js SDK

Standard integration (OpenAI SDK)

Endpoint

Body parameters

Routing control headers

Response envelope

Field reference — rn_ parameters

Create Manual Invoice

Create User

Edit User

Create new API key

Save your API key

Request Details

Reset Password

Set New Password

Field reference — `rn_` parameters