TomdacatAI API docs

Authorization: Bearer tdc_YOUR_API_KEY

curl -X POST https://ai.tomdacat.com/api/chat \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-mini",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What is in this image?" },
          { "type": "image_url", "image_url": { "url": "https://example.com/screenshot.png" } }
        ]
      }
    ]
  }'

// Convert an image file to base64 and send it
const fs = require('fs');

const imageBytes = fs.readFileSync('screenshot.png');
const base64 = imageBytes.toString('base64');
const dataUri = `data:image/png;base64,${base64}`;

const response = await fetch('https://ai.tomdacat.com/api/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer tdc_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'gpt-5-mini',
    messages: [
      {
        role: 'user',
        content: [
          { type: 'text', text: 'Describe what you see.' },
          { type: 'image_url', image_url: { url: dataUri } },
        ],
      },
    ],
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);

-- Send an image URL for vision analysis (server Script)
local HttpService = game:GetService("HttpService")
local API_KEY = "tdc_YOUR_API_KEY"
local API_URL = "https://ai.tomdacat.com/api/chat"

local function analyzeImage(imageUrl, question)
  local ok, result = pcall(HttpService.RequestAsync, HttpService, {
    Url    = API_URL,
    Method = "POST",
    Headers = {
      ["Authorization"] = "Bearer " .. API_KEY,
      ["Content-Type"]  = "application/json",
    },
    Body = HttpService:JSONEncode({
      model = "gpt-5-mini",
      messages = {
        {
          role = "user",
          content = {
            { type = "text",      text = question },
            { type = "image_url", image_url = { url = imageUrl } },
          },
        },
      },
    }),
  })

  if not ok or not result.Success then
    warn("[Vision] error:", ok and result.StatusCode or result)
    return nil
  end

  return HttpService:JSONDecode(result.Body).choices[1].message.content
end

-- Example: analyze a screenshot URL
-- local description = analyzeImage("https://example.com/map.png", "Describe this map.")
-- print(description)

curl -X POST https://ai.tomdacat.com/api/chat \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "your-video-capable-model",
    "messages": [
      {
        "role": "user",
        "content": [
          { "type": "text", "text": "What is happening in this clip?" },
          { "type": "video_url", "video_url": { "url": "https://example.com/clip.mp4" } }
        ]
      }
    ]
  }'

// Convert a video file to base64 and send it
const fs = require('fs');

const videoBytes = fs.readFileSync('clip.mp4');
const base64 = videoBytes.toString('base64');
const dataUri = `data:video/mp4;base64,${base64}`;

const response = await fetch('https://ai.tomdacat.com/api/chat', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer tdc_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'your-video-capable-model',
    messages: [
      {
        role: 'user',
        content: [
          { type: 'text', text: 'Summarize what happens in this video.' },
          { type: 'video_url', video_url: { url: dataUri } },
        ],
      },
    ],
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);

curl -X POST https://ai.tomdacat.com/api/chat \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "reasoning_effort": "high",
    "messages": [
      { "role": "system", "content": "You are a game logic solver." },
      { "role": "user",   "content": "Design an optimal pathfinding algorithm for my Roblox RPG map with dynamic obstacles." }
    ]
  }'

curl -X POST https://ai.tomdacat.com/v1/chat/completions \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-special",
    "reasoning_effort": "minimal",
    "messages": [
      { "role": "user", "content": "What is 17 * 24?" }
    ]
  }'

from openai import OpenAI

client = OpenAI(
    base_url="https://ai.tomdacat.com/v1",
    api_key="tdc_YOUR_API_KEY",
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"thinking": {"type": "disabled"}},
)

{
  "choices": [
    {
      "finish_reason": "tool_calls",
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_player_stats",
              "arguments": "{\"username\":\"PlayerOne\"}"
            }
          }
        ]
      }
    }
  ]
}

local HttpService = game:GetService("HttpService")

local response = HttpService:RequestAsync({
  Url    = "https://ai.tomdacat.com/api/chat",
  Method = "POST",
  Headers = {
    ["Authorization"] = "Bearer tdc_YOUR_API_KEY",
    ["Content-Type"]  = "application/json",
  },
  Body = HttpService:JSONEncode({
    model      = "gpt-5-mini",
    web_search = true,
    web_fetch  = true,
    messages   = {
      { role = "user", content = "What Roblox events are happening this week? Check a source and summarize." },
    },
  }),
})

local data = HttpService:JSONDecode(response.Body)
print(data.choices[1].message.content) -- final answer, web access already applied

curl https://ai.tomdacat.com/v1/chat/completions \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-mini",
    "web_search": true,
    "web_fetch": true,
    "messages": [
      { "role": "user", "content": "What Roblox events are happening this week? Check a source and summarize." }
    ]
  }'

local HttpService = game:GetService("HttpService")

local client = HttpService:CreateWebStreamClient(Enum.WebStreamClientType.SSE, {
  Url    = "https://ai.tomdacat.com/v1/chat/completions",
  Method = "POST",
  Headers = {
    ["Authorization"] = "Bearer tdc_YOUR_API_KEY",
    ["Content-Type"]  = "application/json",
  },
  Body = HttpService:JSONEncode({
    model    = "gpt-5-mini",
    messages = { { role = "user", content = "Tell me a short Roblox story." } },
    stream   = true,
  }),
})

client.MessageReceived:Connect(function(message)
  if message == "[DONE]" then return end
  local ok, chunk = pcall(HttpService.JSONDecode, HttpService, message)
  local delta = ok and chunk.choices and chunk.choices[1] and chunk.choices[1].delta and chunk.choices[1].delta.content
  if delta then
    print(delta) -- append to your UI as each piece arrives
  end
end)

client.Closed:Connect(function()
  print("Stream closed")
end)

local HttpService = game:GetService("HttpService")
local API_KEY = "tdc_YOUR_API_KEY" -- server-side Script only, never a LocalScript

local response = HttpService:RequestAsync({
  Url    = "https://ai.tomdacat.com/v1/chat/completions",
  Method = "POST",
  Headers = {
    ["Authorization"] = "Bearer " .. API_KEY,
    ["Content-Type"]  = "application/json",
  },
  Body = HttpService:JSONEncode({
    model    = "gpt-5-mini",
    messages = { { role = "user", content = "Tell me a short Roblox story." } },
    stream   = false, -- real streaming isn't available in live experiences yet
  }),
})

if response.Success then
  local data = HttpService:JSONDecode(response.Body)
  local text = data.choices[1].message.content

  -- Fire to the client and "type" it out — feels like streaming, works everywhere
  local revealEvent = game.ReplicatedStorage.RevealChatMessage -- a RemoteEvent
  revealEvent:FireClient(player, text)
end

local revealEvent = game.ReplicatedStorage.RevealChatMessage
local chatLabel = script.Parent.ChatLabel -- a TextLabel

revealEvent.OnClientEvent:Connect(function(text)
  chatLabel.Text = ""
  for i = 1, #text do
    chatLabel.Text = text:sub(1, i)
    task.wait(0.015) -- tune for typing speed
  end
end)

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "gpt-5-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "I have a collection of swords, shields, and potions for sale!"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 22,
    "completion_tokens": 14,
    "total_tokens": 36
  }
}

{
  "usage": {
    "prompt_tokens": 1562,
    "completion_tokens": 14,
    "total_tokens": 1576,
    "prompt_tokens_details": {
      "cached_tokens": 1552,    // subset of prompt_tokens billed at the model's cached rate
      "cache_write_tokens": 0   // subset billed at the cache-write rate (falls back to the
                                 // normal input rate if the model has no cache-write rate)
    }
  }
}

{
  "usage": {
    "input_tokens": 1562,
    "output_tokens": 14,
    "cache_read_input_tokens": 1552,
    "cache_creation_input_tokens": 0
  }
}

curl -X POST https://ai.tomdacat.com/api/image \
  -H "Authorization: Bearer tdc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "dreamshaper-8-lcm",
    "prompt": "A neon cyberpunk cityscape at night, ultra detailed",
    "width": 1024,
    "height": 1024
  }'

const response = await fetch('https://ai.tomdacat.com/api/image', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer tdc_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'mai-image-2-6',
    prompt: 'A dragon flying over a glowing Roblox city at sunset',
    width: 1024,
    height: 1024,
  }),
});

const data = await response.json();
console.log(data.url); // permanent hosted image URL

import requests

response = requests.post(
    'https://ai.tomdacat.com/api/image',
    headers={
        'Authorization': 'Bearer tdc_YOUR_API_KEY',
        'Content-Type': 'application/json',
    },
    json={
        'model': 'gpt-image-1-mini',
        'prompt': 'A cute anime character in a magical forest',
        'width': 1024,
        'height': 1024,
    },
)

data = response.json()
print(data['url'])  # permanent hosted image URL — download separately if you need the bytes

local HttpService = game:GetService("HttpService")
local API_KEY = "tdc_YOUR_API_KEY"

local response = HttpService:RequestAsync({
  Url    = "https://ai.tomdacat.com/api/image",
  Method = "POST",
  Headers = {
    ["Authorization"] = "Bearer " .. API_KEY,
    ["Content-Type"]  = "application/json",
  },
  Body = HttpService:JSONEncode({
    model  = "dreamshaper-8-lcm",
    prompt = "A fantasy RPG sword with glowing runes, game asset style",
    width  = 1024,
    height = 1024,
  }),
})

if response.Success then
  local data = HttpService:JSONDecode(response.Body)
  print(data.url)        -- permanent hosted image URL
  print(data.tomdacat.creditsCharged)  -- 1
end

{
  "url": "https://media.pollinations.ai/HWSTclgEfU",
  "model": "dreamshaper-8-lcm",
  "prompt": "A neon cyberpunk cityscape at night",
  "width": 1024,
  "height": 1024,
  "seed": null,
  "tomdacat": {
    "creditsCharged": 1,
    "creditsRemaining": 242
  }
}

// Limit-reached error response
{
  "error": {
    "message": "Weekly token limit reached for this plan. Resets at 2026-08-02T00:00:00.000Z.",
    "type": "rate_limit_error",
    "code": "code_weekly_limit_reached"
  }
}

// Error response body
{
  "error": {
    "message": "Insufficient credits. Please top up your account.",
    "type": "insufficient_credits"
  }
}