How to Use the Agent.Space Developer API

The Agent.Space Developer API lets a server-side Agent integration use models available to your Agent.Space account. The reliable setup order is: create an account and a dedicated API key, discover the models currently available to that key, choose the protocol your client expects, send one small request, and verify the result and funding source in Request history. If the goal is to consolidate several provider keys behind one endpoint, use the one API key, multiple AI models migration guide before changing production traffic.

Do not copy a model name from an old article or put a real key in browser code. The live /v1/models response is the source of truth for model IDs and supported protocols, while the Developer API page is the current product entry point.

Last verified: September 10, 2026. The endpoint, SDK connection shapes, live model discovery, Request history fields, and funding guidance were checked against the current Agent.Space product surface. Available models, protocols, funding rules, and product controls can change, so recheck the live Developer API panel before relying on a configuration.

Technical review: Agent.Space Technical Review checked the current product contract and examples. This is a configuration review, not a production benchmark or a promise that every model exposes identical features.

What the Developer API does

The API is a model-access layer for server integrations. Its current integration shapes include:

• OpenAI Responses through an OpenAI-compatible server SDK configuration.
• Anthropic Messages through an Anthropic-compatible server SDK configuration.

These are connection shapes, not a promise that every provider feature behaves identically. A model returned by discovery still has to support the protocol and capabilities your client requires.

The selected model also determines the applicable Agent.Space funding path. Do not assume that an unavailable balance will automatically fail over to another balance. Check the current product panel and price page before starting a sustained workload.

Before you integrate

Prepare four things:

1. An Agent.Space account with the relevant plan allowance or Flex balance.
2. An API key dedicated to this integration or environment.
3. The production endpoint: https://api.agent.space.
4. A model ID returned by the live model-discovery endpoint.

Use separate keys for local development, production, and automation when independent rotation would reduce downtime. A key name is an organizational label; the secret value is what authorizes spending.

Step 1: Create and protect an API key

Open the Developer API panel and create a key with a name that explains its purpose, such as Production backend. Copy the full value into the intended secret store.

Apply normal credential controls:

• keep the key in a server-side environment variable or approved secret manager;
• never commit it to a repository or paste it into a screenshot, issue, browser bundle, or prompt;
• give each environment its own key when separate revocation matters;
• rotate or revoke a key immediately if exposure is possible.

A local shell can use a placeholder like this:

export AGENT_SPACE_API_KEY="<paste-full-api-key>"

Step 2: Discover available models

Ask the API which models the current key can access:

curl "https://api.agent.space/v1/models" \  -H "Authorization: Bearer $AGENT_SPACE_API_KEY"

Choose the exact returned id. Confirm that its protocols list contains the protocol your client will call: openai.responses for the OpenAI Responses shape or anthropic.messages for Anthropic Messages.

export AGENT_SPACE_MODEL="<model-id>"

Repeat discovery when you intentionally change models or a previously valid ID disappears. A static model list in a Blog post will age; the live response will not.

Step 3: Connect through the client-native protocol

Use the base URL expected by the client rather than treating the two SDK configurations as interchangeable.

OpenAI Responses example

import OpenAI from "openai"
const client = new OpenAI({  apiKey: process.env.AGENT_SPACE_API_KEY,  baseURL: "https://api.agent.space/v1",  maxRetries: 0,})
const response = await client.responses.create({  model: process.env.AGENT_SPACE_MODEL,  input: "Explain the next safe change in this repository.",})
console.log(response.output_text)

Anthropic Messages example

import Anthropic from "@anthropic-ai/sdk"
const client = new Anthropic({  apiKey: process.env.AGENT_SPACE_API_KEY,  baseURL: "https://api.agent.space",  maxRetries: 0,})
const message = await client.messages.create({  model: process.env.AGENT_SPACE_MODEL,  max_tokens: 1024,  messages: [{ role: "user", content: "Review this implementation plan." }],})
console.log(message.content)

These examples document the configuration shape. They are not a benchmark, a customer result, or proof of feature parity across models.

Step 4: Verify one small request before real traffic

After the first request, inspect Request history and confirm:

• the expected key was used;
• the model ID and protocol match the configuration;
• the request reached Agent.Space and completed as expected;
• the recorded funding source is the one you intended.

For a cost review, include every call in the accepted task—not only this first request. The coding Agent API cost calculation guide shows how to separate uncached input, cache activity, output, tools, and retries without inventing a universal task price.

This guide did not send a production request with a reader's key. Its examples mirror the current setup shown by Agent.Space; your own small request and Request history are the evidence that the selected key, model, protocol, and funding path work for your account.

Rotate, revoke, and troubleshoot in a fixed order

Rotation invalidates the old secret, so update the dependent service as part of the cutover. Revocation is appropriate when an integration is retired or a key may be exposed. Renaming helps organization but does not change the secret.

When a request fails, check one layer at a time:

1. Is the complete active key available to this server process?
2. Does /v1/models return the configured model ID?
3. Does that model list the protocol the client uses?
4. Is the base URL correct for the SDK shape?
5. Is the relevant funding path available for the selected model?
6. Does Request history show that the request reached Agent.Space?

This order separates authentication, model availability, protocol compatibility, routing, and funding. Changing all five at once makes the failure harder to diagnose.

Use the HTTP response and Request history together rather than guessing from one symptom:

An HTTP status is a clue, not a complete diagnosis. Preserve the response body and request identifier when one is returned, and never paste the API key itself into logs, screenshots, or support messages.

Start with a small verified integration

The safe first integration is deliberately narrow: one named key, one model selected from live discovery, one client-native protocol, and one small verification request. Expand only after Request history matches the configuration you intended.

Review current Agent.Space plans and model pricing, then create your Agent.Space account. Once the account has the funding path you want, return to the Developer API page to create the integration key.