Connect to the AI gateway

Connect a coding tool or server-side application to a Veryfront project. The project’s AI policy, key limits, and credits apply to requests made with its key.

1. Create or open a project

At Projects, open the project you want to use. To create one, select New project, then Start from scratch, enter a name, and select Create Project. Studio opens the project workspace.

2. Create and save a project key

In the workspace’s panel picker, open API Keys.
Select Create API key and give the key a name identifying its client or owner.
Keep Read enabled for model discovery and enable Write for inference. The form defaults to Read only. Leave Delete off unless the client needs it.
Select Create API Key. Copy the secret from API key created and save it. The secret is shown once.
Select Connect to the AI gateway to open this guide in a new tab, then select Done in the key dialog.

Store the key in a secret manager or a local environment file excluded from source control. Use a separate key for each developer or application so it can be revoked independently. Keep keys out of browser bundles and published configuration. The examples use placeholders. In your local terminal, export the saved key:

Terminal

export VERYFRONT_API_KEY='<your-project-key>'

To create the key over REST instead, call POST /api-keys with a signed-in user session (see Authentication). A signed-in user session token is the authToken cookie of a browser signed in to Veryfront. Export it first:

session.sh

export VERYFRONT_SESSION_TOKEN="<session-token>"

Pass scopes explicitly: a key created without scopes gets only read and can list models but not run inference.

create-key.sh

curl --fail-with-body https://api.veryfront.com/api-keys \
  -H "Authorization: Bearer $VERYFRONT_SESSION_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"gateway-client","project_reference":"<project-slug>","scopes":["read","write"]}' > key.json

export VERYFRONT_API_KEY=$(jq -er '.key' key.json)
export API_KEY_ID=$(jq -er '.id' key.json)

The response holds the secret in key and the key ID in id. Veryfront returns the secret only once. If you created the key in Studio, find its id with GET /api-keys before step 6. Project keys identify their project automatically. These examples require no project-selector header. An account-level key follows the separate authentication guide.

3. Discover a model

Each model family has its own list. Every list comes from the Veryfront catalog and shows only models that family’s request format can serve.

list-models.sh

# OpenAI and open-weight models
curl --fail-with-body 'https://api.veryfront.com/ai/v1/models' \
  -H "Authorization: Bearer $VERYFRONT_API_KEY" | jq -r '.data[].id'

# Claude models: the same endpoint in Anthropic's list format
curl --fail-with-body 'https://api.veryfront.com/ai/v1/models' \
  -H "Authorization: Bearer $VERYFRONT_API_KEY" \
  -H 'anthropic-version: 2023-06-01' | jq -r '.data[].id'

# Gemini models, in Google's list format
curl --fail-with-body 'https://api.veryfront.com/ai/v1beta/models' \
  -H "Authorization: Bearer $VERYFRONT_API_KEY" | jq -r '.models[].name'

Each OpenAI-format entry carries a veryfront object. veryfront.processing names where inference runs, such as eu or worldwide, and veryfront.processing_label describes it in words. If your deployment retains the EU-only default, list the EU models with:

list-eu-models.sh

curl --fail-with-body 'https://api.veryfront.com/ai/v1/models' \
  -H "Authorization: Bearer $VERYFRONT_API_KEY" | \
  jq -r '.data[] | select(.veryfront.processing == "eu") | .id'

To use a model processed outside the EU, see Use models served outside the EU. Use a listed ID rather than guessing a model name. For the examples below, replace <openai-model-id> with a Responses-capable model from the OpenAI-format list and <claude-model-id> with an ID from the Anthropic-format list. A listed model is not a guarantee that every client protocol or hosted tool works with it. Clients using Chat Completions need a model supporting that format. Each model family is served on its native request format. A client using the wrong format gets a 404 naming the surface that serves the model:

Model family	Request format	Endpoint	Client examples
OpenAI and open-weight models (GPT, Mistral, DeepSeek, Qwen)	OpenAI Chat Completions or Responses	`/ai/v1/chat/completions`, `/ai/v1/responses`	OpenAI SDK, Vercel OpenAI provider, LangChain, Codex, Cursor
Claude	Anthropic Messages	`/ai/v1/messages`	Anthropic SDK, Vercel Anthropic provider, Claude Code
Gemini	Google `generateContent`	`/ai/v1beta/models/<model>:generateContent`	Google GenAI SDK

An empty list means no suitable model is available under the current project policy and key limits. Resolve that before configuring the client.

4. Configure your client

Use the tab for your installed client. Replace the model placeholders with the IDs selected above and the key placeholder with your saved project key.

Run these variables in the terminal that starts Claude Code. The /model picker uses gateway discovery. Claude Code uses Claude models through the Anthropic Messages format. Its base URL is /ai because the client appends /v1/messages.

Terminal

export ANTHROPIC_BASE_URL='https://api.veryfront.com/ai'
export ANTHROPIC_AUTH_TOKEN='<your-project-key>'
export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
claude --model '<claude-model-id>'

Add the TOML to ~/.codex/config.toml, then start Codex from the terminal containing your key. This configuration uses the Responses API. Hosted web search is disabled in this example; enable hosted tools only when the model and project policy support them.

~/.codex/config.toml

model = "<openai-model-id>"
model_provider = "veryfront"
web_search = "disabled"

[model_providers.veryfront]
name = "Veryfront"
base_url = "https://api.veryfront.com/ai/v1"
env_key = "VERYFRONT_API_KEY"
wire_api = "responses"

Terminal

export VERYFRONT_API_KEY='<your-project-key>'
codex

In Cursor Settings > Models, paste each value into its field and enable Override OpenAI Base URL. Add the returned model name. This applies to chat and agent; Tab completion uses Cursor’s own models. Cursor relays requests through its servers before Veryfront, so the residency guarantee does not cover that hop.

OpenAI API Key

<your-project-key>

Override OpenAI Base URL

https://api.veryfront.com/ai/v1

Model name

<openai-model-id>

Save ~/.config/opencode/opencode.json, then export the key and start OpenCode. The OpenAI adapter uses Responses. The Anthropic adapter appends /messages to /ai/v1. Keep only providers for which your project has a suitable model.

~/.config/opencode/opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "model": "veryfront-anthropic/<claude-model-id>",
  "provider": {
    "veryfront": {
      "npm": "@ai-sdk/openai",
      "name": "Veryfront",
      "options": {
        "baseURL": "https://api.veryfront.com/ai/v1",
        "apiKey": "{env:VERYFRONT_API_KEY}"
      },
      "models": {
        "<openai-model-id>": {}
      }
    },
    "veryfront-anthropic": {
      "npm": "@ai-sdk/anthropic",
      "name": "Veryfront (Claude)",
      "options": {
        "baseURL": "https://api.veryfront.com/ai/v1",
        "apiKey": "{env:VERYFRONT_API_KEY}"
      },
      "models": {
        "<claude-model-id>": {}
      }
    }
  }
}

Terminal

export VERYFRONT_API_KEY='<your-project-key>'
opencode

Save ~/.pi/agent/models.json, then export the key and start Pi. Keep only providers with an available model. The Anthropic adapter uses /ai; the OpenAI-compatible Chat Completions adapter uses /ai/v1.

~/.pi/agent/models.json

{
  "providers": {
    "veryfront": {
      "baseUrl": "https://api.veryfront.com/ai/v1",
      "api": "openai-completions",
      "apiKey": "$VERYFRONT_API_KEY",
      "models": [
        {
          "id": "<openai-model-id>"
        }
      ]
    },
    "veryfront-anthropic": {
      "baseUrl": "https://api.veryfront.com/ai",
      "api": "anthropic-messages",
      "apiKey": "$VERYFRONT_API_KEY",
      "models": [
        {
          "id": "<claude-model-id>"
        }
      ]
    }
  }
}

Terminal

export VERYFRONT_API_KEY='<your-project-key>'
pi --provider veryfront-anthropic --model '<claude-model-id>'

Save both files, then run openclaw gateway restart. OpenClaw runs as a service, so its key belongs in ~/.openclaw/.env, not only in your terminal environment. Keep only providers with an available model.

~/.openclaw/.env

VERYFRONT_API_KEY='<your-project-key>'

~/.openclaw/openclaw.json

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "veryfront-anthropic/<claude-model-id>"
      }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "veryfront": {
        "baseUrl": "https://api.veryfront.com/ai/v1",
        "api": "openai-completions",
        "apiKey": "${VERYFRONT_API_KEY}",
        "models": [
          {
            "id": "<openai-model-id>",
            "name": "<openai-model-id>"
          }
        ]
      },
      "veryfront-anthropic": {
        "baseUrl": "https://api.veryfront.com/ai",
        "api": "anthropic-messages",
        "apiKey": "${VERYFRONT_API_KEY}",
        "models": [
          {
            "id": "<claude-model-id>",
            "name": "<claude-model-id>"
          }
        ]
      }
    }
  }
}

Use /ai/v1 as the OpenAI-compatible base URL and /ai as the base for the official Anthropic SDK. Send the project key as a Bearer token or the supported API-key header. List models with the command below before choosing a request format.

List the models this key can use

curl 'https://api.veryfront.com/ai/v1/models' \
  -H 'Authorization: Bearer <your-project-key>'

Application SDKs

For server-side application code, use the same project key and returned model ID. Install the SDK shown in the selected tab, save its .mts TypeScript example, and run it with npx tsx <filename>. The .mts extension supports top-level await in existing CommonJS projects as well as ESM projects. The endpoint prefix depends on the SDK: OpenAI clients use /ai/v1, the official Anthropic SDK uses /ai, and the Vercel Anthropic provider uses /ai/v1. Native Google clients use /ai with API version v1beta, which produces requests under /ai/v1beta. Do not substitute one prefix for every SDK.

Terminal

export OPENAI_MODEL_ID='<openai-model-id>'
export ANTHROPIC_MODEL_ID='<claude-model-id>'

OpenAI SDK
Vercel AI SDK
LangChain
Anthropic SDK
Google Gemini

Terminal

npm install openai

openai-gateway.mts

import OpenAI from 'openai';

const apiKey = process.env.VERYFRONT_API_KEY;
const model = process.env.OPENAI_MODEL_ID;
if (!apiKey || !model) throw new Error('Set VERYFRONT_API_KEY and OPENAI_MODEL_ID');

const client = new OpenAI({ apiKey, baseURL: 'https://api.veryfront.com/ai/v1' });
const response = await client.responses.create({
  model,
  input: 'Reply with gateway connected.',
});
console.log(response.output_text);

See the official OpenAI SDK documentation for SDK installation and response handling. The credential and endpoint here belong to Veryfront.

Terminal

npm install ai @ai-sdk/openai

ai-sdk-gateway.mts

import { createOpenAI } from '@ai-sdk/openai';
import { generateText } from 'ai';

const apiKey = process.env.VERYFRONT_API_KEY;
const modelId = process.env.OPENAI_MODEL_ID;
if (!apiKey || !modelId) throw new Error('Set VERYFRONT_API_KEY and OPENAI_MODEL_ID');

const gateway = createOpenAI({ apiKey, baseURL: 'https://api.veryfront.com/ai/v1' });
const result = await generateText({
  model: gateway.responses(modelId),
  prompt: 'Reply with gateway connected.',
});
console.log(result.text);

For Claude models, use createAnthropic from @ai-sdk/anthropic with baseURL: 'https://api.veryfront.com/ai/v1' and the Veryfront key. That adapter appends /messages, so /ai is not its complete prefix. Consult the OpenAI provider reference when choosing Responses or Chat Completions.

Terminal

npm install @langchain/openai @langchain/core

langchain-gateway.mts

import { ChatOpenAI } from '@langchain/openai';

const apiKey = process.env.VERYFRONT_API_KEY;
const model = process.env.OPENAI_MODEL_ID;
if (!apiKey || !model) throw new Error('Set VERYFRONT_API_KEY and OPENAI_MODEL_ID');

const client = new ChatOpenAI({
  apiKey,
  model,
  useResponsesApi: true,
  configuration: { baseURL: 'https://api.veryfront.com/ai/v1' },
});
const response = await client.invoke('Reply with gateway connected.');
console.log(response.content);

This example selects Responses explicitly. See ChatOpenAI for custom endpoints and request-format options.

Terminal

npm install @anthropic-ai/sdk

anthropic-gateway.mts

import Anthropic from '@anthropic-ai/sdk';

const apiKey = process.env.VERYFRONT_API_KEY;
const model = process.env.ANTHROPIC_MODEL_ID;
if (!apiKey || !model) throw new Error('Set VERYFRONT_API_KEY and ANTHROPIC_MODEL_ID');

const client = new Anthropic({ apiKey, baseURL: 'https://api.veryfront.com/ai' });
const response = await client.messages.create({
  model,
  max_tokens: 128,
  messages: [{ role: 'user', content: 'Reply with gateway connected.' }],
});
console.log(response.content);

The official SDK appends /v1/messages. It therefore takes /ai as its base, unlike Vercel’s Anthropic adapter. See the Anthropic SDK.

For a native Google client, configure the gateway’s Google-provider route. Use a native Google model name for an allowed Google deployment; an OpenAI or Claude model ID is not a Google model name.

Terminal

npm install @google/genai
export GOOGLE_MODEL_ID='<native-google-model-name>'

gemini-gateway.mts

import { GoogleGenAI } from '@google/genai';

const apiKey = process.env.VERYFRONT_API_KEY;
const model = process.env.GOOGLE_MODEL_ID;
if (!apiKey || !model) throw new Error('Set VERYFRONT_API_KEY and GOOGLE_MODEL_ID');

const client = new GoogleGenAI({
  apiKey,
  httpOptions: { baseUrl: 'https://api.veryfront.com/ai', apiVersion: 'v1beta' },
});
const response = await client.models.generateContent({
  model,
  contents: 'Reply with gateway connected.',
});
console.log(response.text);

The SDK sends the Veryfront credential in x-goog-api-key; the gateway authenticates it before routing upstream. See GoogleGenAI and HTTP options. Availability and project policy still apply; this guide does not claim every native Google model is admitted.

Veryfront Code applications

For a Veryfront Code application, follow Code getting started and its model/provider configuration. The framework CLI’s login and linked-project flow remain separate from the direct gateway-key configuration above. A project API key does not replace veryfront login.

5. Verify one request

In your configured client, send: Reply with gateway connected. Confirm that it returns an answer without an authentication, model, or policy error. The request consumes project credits. For an HTTP-level check of a Responses-capable model, run:

first-response.sh

export OPENAI_MODEL_ID='<openai-model-id>'
jq -n --arg model "$OPENAI_MODEL_ID" \
  '{model: $model, input: "Reply with gateway connected."}' | \
  curl --fail-with-body 'https://api.veryfront.com/ai/v1/responses' \
    -H "Authorization: Bearer $VERYFRONT_API_KEY" \
    -H 'Content-Type: application/json' \
    --data-binary @- > response.json
jq -r '.output[]? | select(.type == "message") | .content[]? | select(.type == "output_text") | .text' response.json

Expect an assistant answer. If the request fails, read its error body before retrying:

Result	Check
`401`	The key is present, valid, and not expired or revoked.
`403`	Write permission, project policy, key model limits, and hosted-tool support.
Model or request-format error	The returned model ID supports the API used by this client.
`gateway_project_required`	Use a project key, or follow the account-key project selector in the authentication guide.

A successful discovery request proves Read access, not inference access. Check the project key’s usage after the inference test. A successful request is the completion check; saving a configuration alone does not prove it works.

6. Check the key’s usage

In Studio, open API Keys and select the key. Over REST, call GET /api-keys/{id}/usage with the key ID from step 2:

Credential	`GET /api-keys/{id}/usage`	`GET /account/usage`
Signed-in user session	Yes	Yes
Account API key, for its own ID	Yes	No, returns `403`
Project API key	No, returns `403`	No, returns `403`

key-usage.sh

curl --fail-with-body "https://api.veryfront.com/api-keys/$API_KEY_ID/usage" \
  -H "Authorization: Bearer $VERYFRONT_SESSION_TOKEN" | jq '.summary'

summary holds the request count, tokens, and credits for the time frame. Account billing endpoints such as /account/usage need a signed-in user, not a machine credential.

API Keys in Studio: Rotate or revoke the client key and inspect usage.
Create an API key: Manage credentials for other API clients.

Authenticate API requests: Bearer credentials and resource access.
AI Gateway API: Request formats, model discovery, and project policy.
Codex configuration: Local Codex settings, including hosted web search.

Get started

APIs

REST API

GraphQL API

MCP API

Connect to the AI gateway

1. Create or open a project

2. Create and save a project key

3. Discover a model

4. Configure your client

Application SDKs

Veryfront Code applications

5. Verify one request

6. Check the key’s usage

Next

​1. Create or open a project

​2. Create and save a project key

​3. Discover a model

​4. Configure your client

​Application SDKs

​Veryfront Code applications

​5. Verify one request

​6. Check the key’s usage

​Next

​Related

1. Create or open a project

2. Create and save a project key

3. Discover a model

4. Configure your client

Application SDKs

Veryfront Code applications

5. Verify one request

6. Check the key’s usage

Next

Related