Quickstart: Developers

Get started with Gloo AI Studio. This walks you through what to expect when you create an account as well as how you can make your first API call.

Step 1: Create Your Account & Organization

Start by creating your account at Gloo AI Studio. Once your email is verified, the onboarding wizard will guide you through setting up your organization:

Create your Organization: Give your team a name to manage projects and collaboration.
Invite your Team: (Optional) Add email addresses to invite collaborators immediately, or skip this step.

As the account creator, you are the Organization Admin. You can invite team members, create Publishers, and manage your organization at any time from the Studio sidebar. See the Admin Quickstart for a full walkthrough.

Step 2: Set Up Billing & Spend Limits

Adding a payment method is required to activate Studio on a Pay-As-You-Go plan. This unlocks API access and is a prerequisite for using the Studio Playground.

Add a Payment Method: Enter your credit card details to activate your account. You are only charged for what you use.
Set a Spend Limit: You can define a weekly spending limit (e.g., $50/week) to control costs. If you don’t set a limit, you’ll be capped at $100/week which is also the maximum you can spend in a week for the Pay-As-You-Go plan.

Want more details? See our comprehensive guides:

Billing & Plans - Plan comparison, upgrades, and payment management
API Usage - Monitor your consumption and costs

Once your payment method is added, continue below to generate API credentials. After your credentials are created, you can either call the API directly or open the Studio Playground to chat with models in the browser — both routes use the same credentials and count against your spend limit.

Step 3: Create Your API Credentials

The Gloo AI APIs use OAuth2 client credentials flow for authentication. To make an API call, you:

Get API Credentials (Client ID and Client Secret) from Gloo AI Studio
Use those credentials to get a short-lived access token
Use the access token to authenticate your API calls
Repeat step (2) whenever the access token expires

Here’s how to get your API credentials:

Navigate to API Credentials in the Studio Dashboard.
Copy the Client ID and Client Secret values if there are existing credentials, otherwise go to the next step.
Click Create New Key to generate a Client ID and Client Secret.

Prefer using an SDK? Now that you have credentials, you can use the OpenAI Python or Node.js libraries with Gloo AI Studio. See Libraries & SDKs for a streamlined approach that handles token exchange for you.

Step 4: Generate an Access Token

Once you have a Client ID and Client Secret, you can generate an access token using one of the following methods:

import base64
import requests

def get_access_token(client_id: str, client_secret: str) -> dict:
    auth = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()

    response = requests.post(
        "https://platform.ai.gloo.com/oauth2/token",
        headers={
            "Content-Type": "application/x-www-form-urlencoded",
            "Authorization": f"Basic {auth}"
        },
        data={
            "grant_type": "client_credentials",
            "scope": "api/access"
        }
    )

    return response.json()

# Check token expiration
from jwt import decode
token_data = get_access_token(client_id, client_secret)
decoded = decode(token_data["access_token"], verify=False)
expiration = decoded["exp"]

curl -X POST \
  https://platform.ai.gloo.com/oauth2/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Authorization: Basic <Base64("client_id:client_secret")>' \
  -d 'grant_type=client_credentials&scope=api/access'

import { Buffer } from 'buffer';

async function getAccessToken(clientId: string, clientSecret: string): Promise<string> {
  const auth = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');

  const response = await fetch(
    'https://platform.ai.gloo.com/oauth2/token',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Authorization': `Basic ${auth}`
      },
      body: new URLSearchParams({
        'grant_type': 'client_credentials',
        'scope': 'api/access'
      })
    }
  );

  const data = await response.json();

  // Check token expiration
  const decoded = JSON.parse(
    Buffer.from(data.access_token.split('.')[1], 'base64').toString()
  );
  const expiration = decoded.exp;

  return data.access_token;
}

require 'base64'
require 'net/http'
require 'json'
require 'jwt'

def access_token(client_id, client_secret)
  auth = Base64.strict_encode64("#{client_id}:#{client_secret}")

  uri = URI('https://platform.ai.gloo.com/oauth2/token')
  request = Net::HTTP::Post.new(uri)
  request['Content-Type'] = 'application/x-www-form-urlencoded'
  request['Authorization'] = "Basic #{auth}"
  request.set_form_data(
    'grant_type' => 'client_credentials',
    'scope' => 'api/access'
  )

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
    http.request(request)
  end

  data = JSON.parse(response.body)

  # Check token expiration
  decoded = JWT.decode(data['access_token'], nil, false).first
  expiration = decoded['exp']

  data['access_token']
end

package main

import (
    "encoding/base64"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "strings"
    "time"
)

func getAccessToken(clientID, clientSecret string) (string, error) {
    auth := base64.StdEncoding.EncodeToString([]byte(clientID + ":" + clientSecret))

    data := url.Values{}
    data.Set("grant_type", "client_credentials")
    data.Set("scope", "api/access")

    req, err := http.NewRequest("POST",
        "https://platform.ai.gloo.com/oauth2/token",
        strings.NewReader(data.Encode()))
    if err != nil {
        return "", err
    }

    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Set("Authorization", "Basic " + auth)

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    var result struct {
        AccessToken string `json:"access_token"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return "", err
    }

    // Check token expiration from JWT payload
    parts := strings.Split(result.AccessToken, ".")
    if len(parts) != 3 {
        return "", fmt.Errorf("invalid token format")
    }

    var payload struct {
        Exp int64 `json:"exp"`
    }

    payloadBytes, _ := base64.RawURLEncoding.DecodeString(parts[1])
    json.Unmarshal(payloadBytes, &payload)

    expiration := time.Unix(payload.Exp, 0)

    return result.AccessToken, nil
}

The response will include an access token that you can use to authenticate your API calls. It should look like this:

{
  "access_token":"eyJraWQiOiJ...jwvh2t..cumG9g",
  "expires_in":3600,
  "token_type":"Bearer"
}

Access tokens expire after one hour. Monitor the token’s expiration by checking the ‘exp’ claim in the JWT payload. Since refresh tokens are not provided with client credentials, you will need to request a new access token when the current one expires.

Step 5: Make An API Call

Using the get_access_token function from Step 4, make a call to the Responses API, the recommended endpoint for OpenAI-compatible, multimodal integrations.

# Uses get_access_token() from Step 4
token = get_access_token(client_id, client_secret)["access_token"]

response = requests.post(
    "https://platform.ai.gloo.com/ai/v1/responses",
    headers={
        "Content-Type": "application/json",
        "Authorization": f"Bearer {token}"
    },
    json={
        "model": "gloo-openai-gpt-5-mini",
        "instructions": "You are a human-flourishing assistant.",
        "input": [
            {"role": "user", "content": "How do I discover my purpose?"}
        ]
    }
)

# Find the assistant message in the typed output array (a reasoning item
# may precede it on reasoning-capable models).
output = response.json()["output"]
message = next(item for item in output if item["type"] == "message")
print(message["content"][0]["text"])

# Replace CLIENT_ACCESS_TOKEN with the token from Step 4
curl https://platform.ai.gloo.com/ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer CLIENT_ACCESS_TOKEN" \
  -d '{
    "model": "gloo-openai-gpt-5-mini",
    "instructions": "You are a human-flourishing assistant.",
    "input": [
      {
        "role": "user",
        "content": "How do I discover my purpose?"
      }
    ]
  }'

The response should look like this:

{
    "id": "resp_1768500882-56HaBYeuAb4pLpv8PXqh",
    "object": "response",
    "created_at": 1768500882,
    "model": "gloo-openai-gpt-5-mini",
    "output": [
        {
            "type": "message",
            "role": "assistant",
            "status": "completed",
            "content": [
                {
                    "type": "output_text",
                    "text": "What a profound and meaningful question! ..."
                }
            ]
        }
    ],
    "usage": {
        "input_tokens": 1115,
        "output_tokens": 459,
        "total_tokens": 1574
    }
}

Prefer routing, values-aligned (tradition) responses, or grounded/RAG completions? Use Completions V2 — it’s fully supported and backwards-compatible.

Next Steps

Libraries & SDKs

Use the OpenAI Python or Node.js SDK with Gloo AI to skip the manual token exchange code.

Supported Models

Explore all available models and their capabilities.

GlooCode

Use your credentials with GlooCode — an AI coding agent that plans, builds, and tests from your terminal.

Get Started

Completions & Responses

Content

Organization & Billing

GlooCode

Learn More

External

Legacy

Quickstart: Developers

Step 1: Create Your Account & Organization

Step 2: Set Up Billing & Spend Limits

Step 3: Create Your API Credentials

Step 4: Generate an Access Token

Step 5: Make An API Call

Next Steps

Libraries & SDKs

Supported Models

GlooCode

​Step 1: Create Your Account & Organization

​Step 2: Set Up Billing & Spend Limits

​Step 3: Create Your API Credentials

​Step 4: Generate an Access Token

​Step 5: Make An API Call

​Next Steps

Libraries & SDKs

Supported Models

GlooCode

Step 1: Create Your Account & Organization

Step 2: Set Up Billing & Spend Limits

Step 3: Create Your API Credentials

Step 4: Generate an Access Token

Step 5: Make An API Call

Next Steps