Meta

Meta’s Model API — the Muse Spark family, built for long, tool-heavy tasks that plan and orchestrate across services — is routable through Verlon in whichever SDK you already use. No Meta-specific SDK required.

Chat models

Model ID	Type	Context
`muse-spark-1.1`	chat	1049K
`muse-spark-1.2`	chat	1049K
`muse-spark-1.2-contributor`	chat	1049K

This table is auto-generated from the Verlon model registry on every sync — see the live registry for pricing, benchmarks, and deprecation dates.

Quickstart

The fastest path — the official OpenAI SDK, pointed at Verlon:

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://api.verlon.ai/v1',
  apiKey: process.env.VERLON_API_KEY,
});

// @ts-ignore - gateId is a Verlon AI extension
const response = await openai.chat.completions.create({
  gateId: process.env.GATE_ID,
  model: 'muse-spark-1.2', // optional — overrides the gate's configured model
  messages: [{ role: 'user', content: 'Hello!' }],
});

console.log(response.choices[0].message.content);

Any chat model from the table above works — swap muse-spark-1.2 for any other ID.

Reasoning

Muse Spark reasons on every request and reasoning cannot be turned off. reasoning_effort controls how much of it happens, but even the lowest setting still thinks:

const response = await openai.chat.completions.create({
  gateId: process.env.GATE_ID,
  messages: [{ role: 'user', content: 'Prove there are infinitely many primes.' }],
  reasoning_effort: 'low', // 'low' | 'medium' | 'high' — Meta defaults to 'high'
});

This matters more here than on most providers. A trivial prompt like “say hi” spends hundreds of reasoning tokens before it produces a single visible word, and those tokens are billed as output and count against your output cap. Verlon automatically reserves extra headroom on top of your max_tokens for reasoning models, so a small max_tokens won’t be consumed entirely by thinking and leave you with an empty response. reasoning_effort is portable: Verlon passes the same value straight through to OpenAI and Meta, maps it to a thinking-token budget on Anthropic and Google, and ignores it for Mistral. Switching models doesn’t require changing your code.

SDK compatibility

The official OpenAI SDK against Verlon’s drop-in endpoint is the native path to every model on this page — the quickstart above is all it takes. The Verlon SDK isn’t needed for inference; its home is agent tracing, observability, and the model registry. Already using Meta’s own API? Meta serves OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages, and Verlon mirrors all three — so the swap is a base URL and nothing else:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.VERLON_API_KEY,
  baseURL: 'https://api.verlon.ai/v1', // was https://api.meta.ai/v1
});

const response = await client.chat.completions.create({
  model: 'muse-spark-1.2',
  messages: [{ role: 'user', content: 'Hello!' }],
});

The same applies to the Anthropic SDK against /v1/messages. Any SDK with a Verlon drop-in endpoint can reach these models: point it at Verlon, reference a gate that routes here, and your code stays unchanged.

Streaming

const stream = await openai.chat.completions.create({
  gateId: process.env.GATE_ID,
  messages: [{ role: 'user', content: 'Tell me a joke.' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

What’s supported

Streaming

Full support for stream: true in every supported SDK — identical semantics to the source SDK.

Tool / function calling

Fully supported, including parallel tool calls. Verlon translates the tool-call shape between OpenAI / Anthropic / Meta native formats.

Structured output

response_format with json_object or a json_schema works the same as on OpenAI.

Reasoning effort

reasoning_effort passes straight through to Meta. See Reasoning above.

Standard parameters

temperature, max_tokens, and top_p are passed through.

Prompt caching

Cached input tokens are billed at a large discount and reported in every response’s usage. No configuration needed.

Usage + cost tracking

Every response includes token usage — visible output and reasoning tokens separately — plus Verlon’s cost field with the per-call dollar amount.

Not available

Image, video, audio, embeddings, OCR. The Model API is text-only; Muse Spark is a text and reasoning family. Route those modalities to OpenAI, Google, Anthropic, or Mistral and keep your chat traffic on Meta — that mix is exactly what gates are for.

How it works

You send a request in your chosen SDK’s format
Verlon receives — validates the gate, applies routing rules
Verlon translates to Meta’s format and dispatches to the Model API
Meta responds with its raw response
Verlon normalizes back to your SDK’s expected shape
You receive a response in the format your code already handles, with an added cost field

Your existing code doesn’t know it’s talking to Meta.

Errors

Status	Meaning	What to check
`400`	Invalid request	Malformed body or missing `gateId`
`401`	Invalid API key	Your `VERLON_API_KEY` value and the `Authorization: Bearer` header
`404`	Gate not found	Your `GATE_ID` — the error message names the offending ID
`429`	Rate limit exceeded	Back off and retry; the body includes `reset_at`, and every response carries `X-RateLimit-*` headers

The error shape always matches the SDK you’re calling with. Through the OpenAI SDK it surfaces as a thrown APIError:

try {
  await openai.chat.completions.create({
    gateId: process.env.GATE_ID,
    messages: [{ role: 'user', content: 'Hello!' }],
  });
} catch (error) {
  // error.status and error.message carry the API's answer,
  // e.g. 404 'Gate with ID "…" not found'
  console.error(error.status, error.message);
}

OpenAI · Anthropic · Google · Mistral · xAI
Verlon SDK reference — agent tracing, observability, and the model registry
Gates — set up routing rules and model configuration

Getting Started

SDK Reference

Platform

Integrations

Provider Compatibility

Chat models

Quickstart

Reasoning

SDK compatibility

Streaming

What’s supported

Not available

How it works

Errors

​Chat models

​Quickstart

​Reasoning

​SDK compatibility

​Streaming

​What’s supported

​Not available

​How it works

​Errors

​Related

Chat models

Quickstart

Reasoning

SDK compatibility

Streaming

What’s supported

Not available

How it works

Errors

Related