API Documentation

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-openai-key",
    base_url="https://api.trustloop.live/v1",
    default_headers={"x-api-key": "tl_your_trustloop_key"}
)

# Your existing code works unchanged — TrustLoop intercepts automatically
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Transfer £5000 to supplier"}],
    tools=[...]
)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-your-openai-key',
  baseURL: 'https://api.trustloop.live/v1',
  defaultHeaders: { 'x-api-key': 'tl_your_trustloop_key' }
});

// Your existing code works unchanged
const response = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [{ role: 'user', content: 'Transfer £5000 to supplier' }],
  tools: [...]
});

curl -X POST https://api.trustloop.live/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-openai-key" \
  -H "x-api-key: tl_your_trustloop_key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Transfer 5000 to supplier"}],
    "tools": [...]
  }'

# Header (recommended)
x-api-key: tl_your_api_key_here

# Query parameter (for browser/CSV export)
GET /api/logs/export?api_key=tl_your_api_key_here

https://api.trustloop.live

// Tool was allowed — normal OpenAI response + metadata
{
  "choices": [...],
  "_trustloop": { "status": "allowed", "tool": "read_file" }
}

{
  "choices": [{ "message": { "content": "Tool 'delete_file' is blocked by governance policy." } }],
  "_trustloop": { "blocked": true, "tool": "delete_file", "rule": "Block all file deletions" }
}

{
  "choices": [{ "message": { "content": "Tool requires human approval. Retry once approved." } }],
  "_trustloop": {
    "status": "pending_approval",
    "approval_id": "uuid-here",
    "tool": "wire_transfer"
  }
}

import requests

def trustloop_check(tool_name, args):
    res = requests.post(
        "https://api.trustloop.live/api/intercept",
        headers={"x-api-key": "tl_your_key"},
        json={"tool_name": tool_name, "arguments": args}
    ).json()

    if not res["allowed"]:
        raise PermissionError(res["message"])

# In your tool executor:
trustloop_check("delete_records", {"table": "customers"})
# Tool only executes if TrustLoop allows it

pip install trustloop-sdk

# With LangChain support
pip install trustloop-sdk[langchain]

# With CrewAI support
pip install trustloop-sdk[crewai]

# With async support (httpx)
pip install trustloop-sdk[async]

from trustloop import TrustLoop, TrustLoopBlockedError

tl = TrustLoop(api_key="tl_your_key", agent_name="my-agent")

# Manual check
result = tl.intercept("send_email", {"to": "ceo@bank.com"})
if not result["allowed"]:
    raise RuntimeError(result["message"])

# Or use the decorator
@tl.guard("delete_records")
def delete_records(table, where):
    ...  # only runs if TrustLoop allows it

# LangChain — wrap all tools in one line
from trustloop.integrations.langchain import wrap_tools
tools = wrap_tools(raw_tools, tl)

# CrewAI — decorate your tool class
from trustloop.integrations.crewai import governed_tool

@governed_tool(tl)
class MyTool(BaseTool):
    ...

import TrustLoop from 'trustloop';

const tl = new TrustLoop({ apiKey: 'tl_your_key' });

const result = await tl.intercept('send_email', { to: 'ceo@bank.com' });
if (!result.allowed) throw new Error(result.message);

// OpenAI proxy shortcut
const openai = new OpenAI(TrustLoop.openai('sk-openai-key', 'tl_your_key'));

Before taking any sensitive action — including sending emails, accessing
databases, calling external APIs, transferring data, modifying files, or
any operation that affects systems outside this conversation — you MUST
call the TrustLoop interceptToolCall action first.

Pass the action name as tool_name and all relevant parameters as arguments.
Set agent_name to the name of this GPT.

Rules:
- If the response is allowed: true → proceed with the action.
- If the response is allowed: false and status is BLOCKED → do NOT proceed.
  Tell the user: "This action was blocked by your organisation's AI
  governance policy: [message from TrustLoop]"
- If the response is allowed: false and status is PENDING → do NOT proceed.
  Tell the user: "This action requires approval from your administrator.
  They have been notified. Please wait for their approval before retrying."

Never skip this check for sensitive operations.