Model Router

Not every prompt needs a $15/M-token model. A “fix this typo” request and a “design an event sourcing system” request look identical to your API call, but one costs 10x more than it should. The Morph Router classifies prompt difficulty, ambiguity, and domain in ~50ms, then tells you how to route it. Trained on millions of coding prompts. $0.005 per request. Pricing: $0.005/request | Max input: 65,536 tokens

Radar chart comparing candidate model routing profiles

Quick Start

Ask the router which model to use, then call it:

cURL
TypeScript
Python

curl -s -X POST "https://api.morphllm.com/v1/router/multimodel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Add error handling to this function",
    "allowed_providers": ["anthropic"]
  }'

// Ask the router which model to use
const res = await fetch("https://api.morphllm.com/v1/router/multimodel", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MORPH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    input: "Add error handling to this function",
    allowed_providers: ["anthropic"],
  }),
});
const { model } = await res.json(); // call this model next

import requests

MORPH_API_KEY = "YOUR_API_KEY"

# Ask the router which model to use
resp = requests.post(
    "https://api.morphllm.com/v1/router/multimodel",
    headers={
        "Authorization": f"Bearer {MORPH_API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "input": "Add error handling to this function",
        "allowed_providers": ["anthropic"],
    },
)
model = resp.json()["model"]  # call this model next

Prefer to map labels to your own models? Use /v1/router/classify to get the raw signals instead, and /v1/router/multimodel when you’d rather hand Morph your model list and let it choose.

/router/classify

Runs the requested classifier heads against your prompt and returns the raw labels. You decide what each label means for your stack. Request

Field	Type	Description
`input`	string	The prompt to classify (required).
`classes`	string[]	Which heads to run: `"difficulty"`, `"ambiguity"`, `"domain"`. Optional — defaults to all three.

cURL
Python
TypeScript

curl -s -X POST "https://api.morphllm.com/v1/router/classify" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Add error handling to this function",
    "classes": ["difficulty", "ambiguity", "domain"]
  }'

import requests

MORPH_API_KEY = "YOUR_API_KEY"

resp = requests.post(
    "https://api.morphllm.com/v1/router/classify",
    headers={
        "Authorization": f"Bearer {MORPH_API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "input": "Add error handling to this function",
        "classes": ["difficulty", "ambiguity", "domain"],
    },
)
classifications = resp.json()["classifications"]
difficulty = classifications["difficulty"]["label"]

const res = await fetch("https://api.morphllm.com/v1/router/classify", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MORPH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    input: "Add error handling to this function",
    classes: ["difficulty", "ambiguity", "domain"],
  }),
});

const { classifications } = await res.json();
const difficulty = classifications.difficulty.label;

Response

{
  "classifications": {
    "difficulty": { "class_id": 0, "label": "easy",   "confidence": 0.93, "meets_threshold": true },
    "ambiguity":  { "class_id": 0, "label": "low",    "confidence": 0.88, "meets_threshold": true },
    "domain":     { "class_id": 2, "label": "coding", "confidence": 0.91, "meets_threshold": true }
  }
}

Each head returns label, class_id, confidence, and meets_threshold (whether confidence cleared the head’s threshold). When difficulty does not meet its threshold, treat it as needs_info — the prompt is too ambiguous to size confidently.

Labels

The classifier heads return these labels. You decide what each means for your stack. Difficulty

Label	What it means	Example mapping
`easy`	Trivial change, any model handles it	Haiku, DeepSeek Flash, Gemini Flash
`medium`	Moderate complexity, benefits from a capable model	Sonnet, GPT-5.5, Gemini Flash
`hard`	Complex task, needs a strong model	Opus, GPT-5.5, Gemini Pro
`needs_info`	Ambiguous prompt — difficulty didn’t clear the confidence threshold	Your default model

Ambiguity

Label	What it means
`low`	Well-specified request
`med`	Some detail missing
`high`	Underspecified; may need clarification

Domain

Label	What it means
`general`	General-purpose prompt
`summary`	Summarization / extraction
`coding`	Code generation or editing
`design`	Design / architecture
`data`	Data / analytics

/router/multimodel

Hand the router your candidate models (or whole providers) plus a policy. It classifies the prompt and returns the single best model to call — no mapping table to maintain. Request

Field	Type	Description
`input`	string	The prompt to route (required).
`allowed_models`	string[]	Restrict selection to these exact models, e.g. `["gpt-5.5", "claude-opus-4-8"]`. Optional.
`allowed_providers`	string[]	Restrict selection to these providers (`openai`, `anthropic`, `gemini`, `deepseek`, `zai`). Optional.
`policy`	string	`"balanced"` (default), `"cost_efficient"`, `"capability_heavy"`, or `"domain_skills"`.
`default_model`	string	Fallback returned as-is when the prompt is too ambiguous to size (`needs_info`). Must satisfy the allowed filter. Optional.

allowed_models and allowed_providers are unioned — a model qualifies if it matches either. Leave both empty to consider every model in Morph’s catalog. The example below allows every Anthropic model plus Z.ai’s GLM-5.2: GLM-5.2 takes over the Sonnet-level tier outright and contests Opus on hard-tier requests, while Fable 5 keeps the one job nothing else can do — the high-ambiguity apex. Policies

balanced (default) — pick a capable model; break ties on cost.
cost_efficient — minimize cost; tolerate a slightly underqualified model.
capability_heavy — maximize capability for the request; never trade quality for cost.
domain_skills — route by domain match first; pick the specialist for the request’s domain.

Model catalog Leave allowed_models and allowed_providers empty to consider every model below.

Provider	Models
`openai`	`gpt-5.5`
`anthropic`	`claude-haiku-4-5-20251001`, `claude-sonnet-4-6`, `claude-opus-4-8`, `claude-fable-5`
`gemini`	`gemini-3.5-flash`, `gemini-3.1-pro-preview`
`deepseek`	`deepseek-v4-flash`, `deepseek-v4-pro`
`zai`	`glm-5.2`

cURL
Python
TypeScript

curl -s -X POST "https://api.morphllm.com/v1/router/multimodel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Add error handling to this function",
    "allowed_providers": ["anthropic", "zai"],
    "policy": "balanced",
    "default_model": "claude-sonnet-4-6"
  }'

import requests

MORPH_API_KEY = "YOUR_API_KEY"

resp = requests.post(
    "https://api.morphllm.com/v1/router/multimodel",
    headers={
        "Authorization": f"Bearer {MORPH_API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "input": "Add error handling to this function",
        "allowed_providers": ["anthropic", "zai"],
        "policy": "balanced",
        "default_model": "claude-sonnet-4-6",
    },
)
model = resp.json()["model"]  # call this model next

const res = await fetch("https://api.morphllm.com/v1/router/multimodel", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MORPH_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    input: "Add error handling to this function",
    allowed_providers: ["anthropic", "zai"],
    policy: "balanced",
    default_model: "claude-sonnet-4-6",
  }),
});

const { model } = await res.json(); // call this model next

With anthropic and zai both allowed: easy prompts still go to Haiku, medium (“Sonnet-level”) prompts now go to glm-5.2 instead of Sonnet, and hard prompts go to glm-5.2 too — except med-ambiguity hard prompts, which stay on claude-opus-4-8, and high-ambiguity prompts, which always go to claude-fable-5. Drop zai from allowed_providers to fall back to the Anthropic-only tiers. Response

{
  "model": "claude-haiku-4-5-20251001",
  "provider": "anthropic",
  "difficulty": "easy",
  "confidence": 0.93,
  "ambiguity": "low",
  "ambiguity_confidence": 0.88,
  "domain": "coding",
  "domain_confidence": 0.91
}

model is what you call next. The classifier signals (difficulty, ambiguity, domain) are echoed back so you can act on them too — e.g. show a “let’s clarify” prompt when difficulty is needs_info. The ambiguity and domain fields are present only when those heads cleared their threshold; treat a missing field as “no signal.” If the prompt resolves to needs_info and you passed a default_model, that model is returned as-is.

Real-World Example

Route dynamically in production to cut costs while keeping quality. Hand the router your candidate models, then call whatever it returns:

TypeScript
Python

import OpenAI from 'openai';

const openai = new OpenAI();

async function handleUserRequest(userInput: string) {
  // 1. Ask the router which model to use
  const res = await fetch("https://api.morphllm.com/v1/router/multimodel", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.MORPH_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      input: userInput,
      allowed_models: ["gpt-5.5"],
      policy: "balanced",
      default_model: "gpt-5.5",
    }),
  });
  const { model } = await res.json();

  // 2. Call the chosen model with your provider SDK
  return await openai.chat.completions.create({
    model,
    messages: [{ role: "user", content: userInput }],
  });
}

// "Add a TODO comment"           → easy → gpt-5.5
// "Design event sourcing system" → hard → gpt-5.5

import os
import requests
from openai import OpenAI

openai = OpenAI()
MORPH_API_KEY = os.environ["MORPH_API_KEY"]

def handle_user_request(user_input: str):
    # 1. Ask the router which model to use
    resp = requests.post(
        "https://api.morphllm.com/v1/router/multimodel",
        headers={
            "Authorization": f"Bearer {MORPH_API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "input": user_input,
            "allowed_models": ["gpt-5.5"],
            "policy": "balanced",
            "default_model": "gpt-5.5",
        },
        timeout=5,
    )
    model = resp.json()["model"]

    # 2. Call the chosen model with your provider SDK
    return openai.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": user_input}],
    )

Wrap the router call in a try/catch and fall back to a safe default model if it ever fails — default_model already covers the needs_info case.

Integrate with Claude Code

Route every Claude Code turn through the router with no change to how developers work. A local proxy sits between Claude Code and Anthropic (ANTHROPIC_BASE_URL points at it), classifies each turn, and picks the cheapest Claude model — and reasoning effort — that can handle it, following your org’s routing policy. Requires macOS or Linux, Node 22+, and the claude CLI. 1. Install with your Morph API key:

curl -fsSL https://morphllm.com/router/install.sh | MORPH_API_KEY=sk-... bash

The installer pulls the latest routing runtime, verifies its sha256, installs it under ~/.morph/ccr-router, and gives you a morph-claude command. Re-running the one-liner upgrades in place. 2. Authenticate upstream. By default the proxy uses your Claude Pro/Max subscription — run claude login once. To use your org’s Anthropic key instead, add it to the install:

curl -fsSL https://morphllm.com/router/install.sh | MORPH_API_KEY=sk-... ANTHROPIC_API_KEY=sk-ant-org-... bash

3. Run morph-claude instead of claude:

morph-claude              # Claude Code, routed per-turn by your org policy
morph-claude uninstall    # full removal, restores your pre-install config

Each turn is classified on difficulty, ambiguity, and domain, matched against your org’s routing matrix to a {model, effort}, then clamped to the models that user is permitted. One decision per turn, 1.5s classify timeout; if the classify ever fails, routing fails open to your default model. Set the policy. Admins configure the routing matrix and per-user permissions in the dashboard under Administration → Model Router. Edits reach every developer within the hour — no redeploy, no reinstall. The Analytics tab shows the model mix, turn volume, and estimated savings vs sending every turn to Opus. Prefer to own the policy? Point the proxy at a local router-matrix.json or an endpoint you host via MORPH_MATRIX_FILE / MORPH_MATRIX_URL.

Routing metrics are metadata-only — no prompt or completion text ever leaves the machine. Set MORPH_METRICS_DISABLED=1 to send nothing at all.

Edge / Cloudflare Workers

fetch is available natively at the edge, so you can call the router from a Cloudflare Worker, Vercel Edge Function, or Deno with no SDK:

export default {
  async fetch(request: Request, env: Env) {
    const { input } = await request.json();

    const res = await fetch("https://api.morphllm.com/v1/router/multimodel", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${env.MORPH_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ input, allowed_providers: ["anthropic"] }),
    });
    const { model } = await res.json();

    return Response.json({ model });
  }
};

The @morphllm/morphsdk/edge build ships a RawRouter helper, but it targets the legacy /router/raw endpoint. For the current endpoints, call them directly with fetch as shown above.

API Reference

Both endpoints are POST https://api.morphllm.com/... with an Authorization: Bearer YOUR_API_KEY header.

/router/classify
/router/multimodel

POST /v1/router/classify

Request:
{
  "input": "string",                                 // required
  "classes": ["difficulty", "ambiguity", "domain"]   // optional, defaults to all three
}

Response:
{
  "classifications": {
    "difficulty": { "class_id": 0, "label": "easy",   "confidence": 0.93, "meets_threshold": true },
    "ambiguity":  { "class_id": 0, "label": "low",    "confidence": 0.88, "meets_threshold": true },
    "domain":     { "class_id": 2, "label": "coding", "confidence": 0.91, "meets_threshold": true }
  }
}

POST /v1/router/multimodel

Request:
{
  "input": "string",                       // required
  "allowed_models": ["gpt-5.5"],           // optional
  "allowed_providers": ["anthropic"],      // optional: "openai" | "anthropic" | "gemini" | "deepseek" | "zai"
  "policy": "balanced",                    // "balanced" (default) | "cost_efficient" | "capability_heavy" | "domain_skills"
  "default_model": "claude-sonnet-4-6"     // optional, returned as-is on needs_info
}

Response:
{
  "model": "claude-haiku-4-5-20251001",
  "provider": "anthropic",
  "difficulty": "easy",
  "confidence": 0.93,
  "ambiguity": "low",              // present only when the head clears its threshold
  "ambiguity_confidence": 0.88,
  "domain": "coding",
  "domain_confidence": 0.91
}

When to Use

Use the router when:

Processing varied user requests (simple typo fixes to complex architecture tasks)
You want to minimize API costs without manually classifying prompts
Building cost-conscious AI products with mixed complexity workloads

Skip the router when:

All tasks need the same model tier (e.g., always Opus for agentic coding)
The ~180ms routing latency matters more than cost savings
You need deterministic model selection for testing or compliance

Performance

Latency: ~180ms average
Parallel: Can run in parallel with other work
HTTP/2: Connection reuse for subsequent calls

Deprecated endpoints

/v1/router/raw and /v1/router/{provider} are superseded by /v1/router/classify and /v1/router/multimodel. They remain fully supported for backward compatibility — existing integrations keep working with no changes — but new code should use the endpoints above. The provider endpoints will be removed in a future release.

/router/raw

Returns just a difficulty label. Use /v1/router/classify instead for new code.

cURL
Python
TypeScript SDK

curl -s -X POST "https://api.morphllm.com/v1/router/raw" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Add error handling to this function",
    "mode": "balanced"
  }'

Returns: { "difficulty": "easy", "confidence": 0.93 }

import requests

MORPH_API_KEY = "YOUR_API_KEY"

resp = requests.post(
    "https://api.morphllm.com/v1/router/raw",
    headers={
        "Authorization": f"Bearer {MORPH_API_KEY}",
        "Content-Type": "application/json",
    },
    json={"input": "Add error handling to this function", "mode": "balanced"},
)
difficulty = resp.json()["difficulty"]

import { MorphClient } from '@morphllm/morphsdk';

const morph = new MorphClient({ apiKey: "YOUR_API_KEY" });

const { difficulty } = await morph.routers.raw.classify({
  input: 'Add error handling to this function',
  mode: 'balanced', // 'balanced' (default) | 'aggressive'
});

Modes — balanced (default) balances cost and quality; aggressive optimizes harder for cost, pushing more prompts to easy. Returns difficulty (easy | medium | hard | needs_info). For edge environments (Cloudflare Workers, Vercel Edge, Deno), use @morphllm/morphsdk/edge:

import { RawRouter } from '@morphllm/morphsdk/edge';

export default {
  async fetch(request: Request, env: Env) {
    const { input } = await request.json();
    const router = new RawRouter({ apiKey: env.MORPH_API_KEY });
    const { difficulty } = await router.classify({ input });
    return Response.json({ difficulty });
  }
};

/router/

Returns a provider-specific model name directly instead of a difficulty label, for openai, anthropic, and gemini. Use /v1/router/multimodel instead — it does the same model selection with control over the candidate set and policy. Under the hood these now call the multimodel router constrained to that provider, so they keep working with no changes on your side.

curl -s -X POST "https://api.morphllm.com/v1/router/anthropic" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": "your task", "mode": "balanced"}'

Returns: { "model": "claude-haiku-4-5-20251001", "confidence": 0.93 } The SDK still exposes morph.routers.anthropic.selectModel(), morph.routers.openai.selectModel(), and morph.routers.gemini.selectModel() for backwards compatibility. Migrate to /v1/router/multimodel.

Get Started

Models

API Reference

Integrations

Quick Start

/router/classify

Labels

/router/multimodel

Real-World Example

Integrate with Claude Code

Edge / Cloudflare Workers

API Reference

When to Use

Performance

Deprecated endpoints

/router/raw

/router/

​Quick Start

​/router/classify

​Labels

​/router/multimodel

​Real-World Example

​Integrate with Claude Code

​Edge / Cloudflare Workers

​API Reference

​When to Use

​Performance

​Deprecated endpoints

​/router/raw

​/router/

Quick Start

/router/classify

Labels

/router/multimodel

Real-World Example

Integrate with Claude Code

Edge / Cloudflare Workers

API Reference

When to Use

Performance

Deprecated endpoints

/router/raw

/router/