AI Gateway & Cloud Sandboxes.
Built for Autonomous Agents.

Bearer API Keys

All API requests authenticate using HTTP Bearer authentication in the Authorization header:

Authorization: Bearer vx_live_...COPY

You can create and manage API keys in the Console → API Keys section. Plaintext keys are shown only once upon creation, hashed securely at rest using salted SHA-256, and can be revoked instantly.

Key Scopes & Service Separation

Active Reasoning & Code Models

Returns the catalog of active model endpoints available to your organization, including context windows and token pricing:

curl https://verbarex.com/api/v1/models \
  -H "Authorization: Bearer $VERBAREX_API_KEY"COPY

Create Chat Completion

Executes model inference against frontier reasoning models. Fully compatible with OpenAI schema including model, messages, temperature, max_tokens, and stream.

{
  "model": "deepseek-v4.1-flash",
  "messages": [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Write a Python one-liner to fetch the public IP."}
  ],
  "temperature": 0.2
}COPY

Responses return standard OpenAI structure plus exact token metrics and execution latency:

{
  "id": "chatcmpl-01M5...",
  "object": "chat.completion",
  "created": 1793110596,
  "model": "deepseek-v4-1-flash",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "import urllib.request, json; print(json.loads(urllib.request.urlopen('https://httpbin.org/ip').read())['origin'])"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 28,
    "completion_tokens": 32,
    "total_tokens": 60
  },
  "verbarex": {
    "cost_microusd": 3,
    "latency_ms": 780
  }
}COPY

Real-Time Token Streaming

Set "stream": true in your request payload to receive server-sent events (SSE) token-by-token with ultra-low time-to-first-token (TTFT). The stream terminates with data: [DONE].

from openai import OpenAI

client = OpenAI(
    base_url="https://verbarex.com/api/v1",
    api_key="vx_live_YOUR_API_KEY"
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a bash script to monitor memory usage."}],
    stream=True
)

for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    print(token, end="", flush=True)COPY

Cloud Sandboxes (Hardware-Isolated Linux MicroVMs)

VERBAREX Cloud Sandboxes run dedicated Linux MicroVMs with persistent NVMe storage at /workspace, full Python 3.14.4 and Bash 5.2 runtimes, and active outbound NAT egress. Compute is billed per second at $0.17 per active hour with zero cold-starts.

List Active Sandboxes

curl https://verbarex.com/api/v1/sandboxes \
  -H "Authorization: Bearer $VERBAREX_API_KEY"COPY

Launch a New MicroVM Sandbox

curl -X POST https://verbarex.com/api/v1/sandboxes \
  -H "Authorization: Bearer $VERBAREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "agent-runtime-1"
  }'COPY

Execute Code & Commands

Executes shell commands or Python scripts inside your running microVM sandbox. You can pass the 26-character sandbox ULID, the sandbox name, or default to target your active sandbox. Returns stdout, stderr, process exit code, and execution latency.

curl -X POST https://verbarex.com/api/v1/sandboxes/test-sandbox-agent/commands \
  -H "Authorization: Bearer $VERBAREX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "command": "python3 -c \"import platform; print(platform.uname())\""
  }'COPY

Response Structure

{
  "data": {
    "id": "01M5YVGP...",
    "status": "succeeded",
    "exit_code": 0,
    "output": {
      "stdout": "uname_result(system='Linux', node='verbarex-microvm', release='6.12.103-x86_64', ...)\n",
      "stderr": ""
    },
    "output_truncated": false,
    "duration_ms": 380
  }
}COPY

Integrate into Python Autonomous Agents

Connect your autonomous agents directly to VERBAREX Cloud Sandboxes for safe code interpretation, web browsing, data analysis, and script execution.

import requests

class VerbarexSandbox:
    def __init__(self, api_key: str, sandbox_id: str, base_url: str = "https://verbarex.com/api/v1"):
        self.api_key = api_key
        self.sandbox_id = sandbox_id
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def run_command(self, cmd: list, timeout: int = 60) -> dict:
        url = f"{self.base_url}/workspaces/{self.sandbox_id}/commands"
        resp = requests.post(url, headers=self.headers, json={"command": cmd, "timeout_seconds": timeout})
        resp.raise_for_status()
        return resp.json()["data"]

# Example usage:
sandbox = VerbarexSandbox(api_key="vx_live_...", sandbox_id="sbx-1793108128")
res = sandbox.run_command(["python3", "-c", "import sys; print(f'Running Python {sys.version.split()[0]} in microVM')"])
print(res["output"]["stdout"])COPY

Instant BDT Wallet Top-Up

VERBAREX natively supports developers and enterprises in Bangladesh with instant automated top-ups via secure payment checkout. Top up using bKash, Nagad, Rocket, Upay, and local/international Visa & Mastercard.

Metered Pay-As-You-Go Billing

All resources on VERBAREX operate on transparent pay-as-you-go billing with per-token and per-second micro-settlement. There are no monthly subscriptions, minimum spends, or hidden platform fees.

Standardized JSON Error Envelopes

All API errors return consistent JSON error envelopes with traceable request IDs:

{
  "error": {
    "code": "insufficient_scope",
    "message": "This API key is scoped for AI Gateway only. Please use a Cloud Sandbox API key for agent workflows.",
    "details": {}
  },
  "request_id": "01M5YV..."
}COPY

Hardware-Isolated MicroVM Architecture

Unlike shared container runtimes where containers share a single host Linux kernel, VERBAREX Cloud Sandboxes run inside dedicated hardware microVMs with individual Linux kernels. Memory, CPU, and process tables are hardware-isolated. Outbound networking is protected via NAT egress rules, and API keys are verified with constant-time token hashing.