Getting Started

1. Create Your Account

Sign up at app.floopy.ai/signup — it’s free and no credit card is required. The onboarding flow will create your organization automatically.

2. Add a Provider

Go to Settings > Providers in the dashboard and add at least one LLM provider API key (OpenAI, Anthropic, Google Gemini, etc.). This is the key Floopy uses to call the provider on your behalf.

Click Add provider.
Select a provider from the list.
Paste your provider API key.
Click Save.

Your provider key is encrypted at rest and never shown again after saving.

3. Create an API Key

Go to Settings > API Keys and create a Floopy API key. This is the key your application uses to authenticate with the gateway.

Click Create API key.
Give the key a name (e.g. dev-local).
Copy the key immediately — it is shown only once.

4. Make Your First Request

For Node/TypeScript we recommend the official floopy-sdk — it ships typed wrappers for every gateway endpoint (chat, embeddings, decisions, experiments, constraints, export, evaluations, routing) and is a drop-in replacement for openai. Already using openai? Point its baseURL at the gateway and migrate later.

app.ts

// pnpm add floopy-sdk
import { Floopy } from "floopy-sdk";

const floopy = new Floopy({
  apiKey: process.env.FLOOPY_API_KEY!,
});

const response = await floopy.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello from Floopy!" }],
});

console.log(response.choices[0].message.content);

# pip install floopy-sdk
from floopy import Floopy

floopy = Floopy(
    api_key=os.environ["FLOOPY_API_KEY"],
)

response = floopy.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello from Floopy!"}],
)

print(response.choices[0].message.content)

// go get github.com/floopy-ai/floopy-go
package main

import (
    "context"
    "fmt"

    "github.com/floopy-ai/floopy-go"
)

func main() {
    client := floopy.NewClient(floopy.WithEnv())

    res, _ := client.Chat.Completions.Create(context.Background(), &floopy.ChatRequest{
        Model:    "gpt-4o",
        Messages: []floopy.Message{{Role: "user", Content: "Hello from Floopy!"}},
    })

    fmt.Println(res.Choices[0].Message.Content)
}

// cargo add floopy
use floopy::Floopy;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let floopy = Floopy::from_env()?;

    let response = floopy
        .chat()
        .completions()
        .create(floopy::ChatRequest {
            model: "gpt-4o".into(),
            messages: vec![floopy::Message::user("Hello from Floopy!")],
            ..Default::default()
        })
        .await?;

    println!("{}", response.choices[0].message.content);
    Ok(())
}

// npm i openai
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.floopy.ai/v1",
  apiKey: process.env.FLOOPY_API_KEY,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello from Floopy!" }],
});

console.log(response.choices[0].message.content);

# pip install openai
from openai import OpenAI

client = OpenAI(
    base_url="https://api.floopy.ai/v1",
    api_key=os.environ["FLOOPY_API_KEY"],
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello from Floopy!"}],
)

print(response.choices[0].message.content)

curl https://api.floopy.ai/v1/chat/completions \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Hello from Floopy!"}]
  }'

5. Verify in the Dashboard

Open the Requests page in the dashboard. You should see your request listed with:

Model — the model that handled the request (e.g. gpt-4o)
Provider — which provider was called (e.g. OpenAI)
Latency — end-to-end response time in milliseconds
Tokens — prompt and completion token counts
Cost — estimated cost based on provider pricing

Click any row to see the full request and response payload, headers, and cache status.

Next Steps

Routing — control which provider and model handles each request
Caching — reduce latency and cost with exact and semantic caching
Firewall — block prompt injections and harmful content
Prompts — manage and version prompt templates
Headers Reference — full list of Floopy request and response headers