This page takes you from no key to a finished agent task in a few minutes. You need a Jobbit account with some credits on it.

​
1. Create a key

Open Settings → API keys in Jobbit and choose New key. For this guide choose Custom access and tick:
  • Read profile, balance and usage (account:read)
  • Call models (ai)
  • Run and cancel tasks (agent:write)
Copy the key when it is shown. It looks like jb_live_… and is shown only once. More about keys. Keep it in an environment variable rather than in your code: 
export JOBBIT_API_KEY="jb_live_..."

​
2. Check the key

GET /v1/key works with any key and tells you who it belongs to, what it may do and when it expires. 
curl https://platform.jobbit.uk/v1/key \
  -H "Authorization: Bearer $JOBBIT_API_KEY"

import os
import httpx

jobbit = httpx.Client(
    base_url="https://platform.jobbit.uk/v1",
    headers={"Authorization": f"Bearer {os.environ['JOBBIT_API_KEY']}"},
    timeout=60,
)
print(jobbit.get("/key").json())

const jobbit = (path, init = {}) =>
  fetch(`https://platform.jobbit.uk/v1${path}`, {
    ...init,
    headers: {
      Authorization: `Bearer ${process.env.JOBBIT_API_KEY}`,
      "Content-Type": "application/json",
      ...init.headers,
    },
  }).then((response) => response.json());

console.log(await jobbit("/key"));
Response
{
  "id": "k7m2p9x4qa1c",
  "kind": "user",
  "name": "Quickstart",
  "user_id": "5f1c2a9e-8d4b-4c71-9b0e-3a6d2f7e1c44",
  "plan": "pro",
  "scopes": ["account:read", "agent:read", "agent:write", "ai"],
  "restrictions": {},
  "expires_at": null
}
agent:read is in the list although you did not tick it: a write permission always includes its read.

​
3. Check the balance

curl https://platform.jobbit.uk/v1/balance \
  -H "Authorization: Bearer $JOBBIT_API_KEY"
The answer shows the total and how it splits into plan credits and purchased credits. Every paid call takes from this balance.

​
4. Give the agent a task

An agent task is a whole job for the Jobbit agent. It has its own computer, browser and files, works on its own and comes back with a result. Describe the goal and when it counts as done; pass data in input, and ask for a structured answer with output_schema. 
curl https://platform.jobbit.uk/v1/agent-tasks \
  -H "Authorization: Bearer $JOBBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "goal": "Find three physiotherapy clinics in Canterbury that take online bookings. Done when each has a name, website and booking link.",
    "output_schema": {
      "type": "object",
      "properties": {
        "clinics": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": {"type": "string"},
              "website": {"type": "string"},
              "booking_url": {"type": "string"}
            },
            "required": ["name", "website", "booking_url"]
          }
        }
      },
      "required": ["clinics"]
    },
    "effort": "medium",
    "limits": {"max_credits": 20}
  }'

task = jobbit.post(
    "/agent-tasks",
    json={
        "goal": (
            "Find three physiotherapy clinics in Canterbury that take online bookings. "
            "Done when each has a name, website and booking link."
        ),
        "output_schema": {
            "type": "object",
            "properties": {
                "clinics": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "website": {"type": "string"},
                            "booking_url": {"type": "string"},
                        },
                        "required": ["name", "website", "booking_url"],
                    },
                }
            },
            "required": ["clinics"],
        },
        "effort": "medium",
        "limits": {"max_credits": 20},
    },
).json()
print(task["task_id"], task["status"])

const task = await jobbit("/agent-tasks", {
  method: "POST",
  body: JSON.stringify({
    goal:
      "Find three physiotherapy clinics in Canterbury that take online bookings. " +
      "Done when each has a name, website and booking link.",
    output_schema: {
      type: "object",
      properties: {
        clinics: {
          type: "array",
          items: {
            type: "object",
            properties: {
              name: { type: "string" },
              website: { type: "string" },
              booking_url: { type: "string" },
            },
            required: ["name", "website", "booking_url"],
          },
        },
      },
      required: ["clinics"],
    },
    effort: "medium",
    limits: { max_credits: 20 },
  }),
});
console.log(task.task_id, task.status);
The task starts at once and the answer comes back with 202 Accepted, the task_id and the status queued.

​
5. Wait for the result

Ask for the task until its status is succeeded, failed or cancelled. Every few seconds is enough; most tasks take one to several minutes. 
import time

while True:
    task = jobbit.get(f"/agent-tasks/{task['task_id']}").json()
    if task["status"] in ("succeeded", "failed", "cancelled"):
        break
    time.sleep(5)

print(task["status"], task["output"])
print("Credits spent:", task["metrics"]["cost_credits"])

let result = task;
while (!["succeeded", "failed", "cancelled"].includes(result.status)) {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  result = await jobbit(`/agent-tasks/${task.task_id}`);
}
console.log(result.status, result.output);
A finished task has output that follows your schema (or text when you gave none), artifacts with signed links to any files the agent made, and metrics with the credits it cost. The work also shows as a chat in your Jobbit, so you can open it and see what the agent did.
Rather than asking again and again, follow the task as server-sent events, or get a webhook when it finishes.

​
6. Call a model

The model routes are OpenAI-compatible, so an OpenAI SDK works once you point it at Jobbit. This needs the ai permission. 
from openai import OpenAI

client = OpenAI(
    base_url="https://platform.jobbit.uk/v1",
    api_key=os.environ["JOBBIT_API_KEY"],
)
reply = client.chat.completions.create(
    model="jobbit/pro",
    messages=[{"role": "user", "content": "Write a two-line welcome for a physio clinic."}],
)
print(reply.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://platform.jobbit.uk/v1",
  apiKey: process.env.JOBBIT_API_KEY,
});
const reply = await client.chat.completions.create({
  model: "jobbit/pro",
  messages: [{ role: "user", content: "Write a two-line welcome for a physio clinic." }],
});
console.log(reply.choices[0].message.content);

curl https://platform.jobbit.uk/v1/chat/completions \
  -H "Authorization: Bearer $JOBBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jobbit/pro",
    "messages": [{"role": "user", "content": "Write a two-line welcome for a physio clinic."}]
  }'
GET /v1/models lists every model the key may use. Each answer carries the credits it cost in the X-Jobbit-Credits header.

​
Next steps

Permissions and limits

What each permission allows, and how to cap a key’s spending.

Errors and rate limits

The error format, status codes and the limits of each plan.

Deploy an app

Upload a project with a Dockerfile and host it on Jobbit.

Connect an agent

Use Jobbit from Claude, ChatGPT or Codex over MCP.