Hoody AI Models & Pricing

Hoody AI reaches 300+ AI models. Your server connects to 15+ inference providers through the Hoody AI gateway and its model routing upstream.

Inference providers

Providers your server reaches through Hoody AI include:

MiniMax - MiniMax M-series models
Qwen (Alibaba) - Qwen 3 Max and the Qwen family
DeepSeek - DeepSeek V-series, DeepSeek Coder
Meta (via providers) - Llama 4, Llama 3.3, Llama 3.1
Mistral AI - Mistral Large, Medium, Mixtral
xAI - Grok 4, Grok Vision
Microsoft - Phi models
Amazon - Nova models
NVIDIA - Nemotron models
Cohere - Command R+, Embed models
Perplexity AI - Sonar Pro, Sonar models
Together AI - Open model hosting platform
Fireworks AI - Optimized open model inference

OpenAI, Anthropic, and Google models are excluded from the Hoody AI catalog. /api/v1/ai/models never returns them, so treat that endpoint as the authoritative list. To use those vendors, set their own API key inside your container and call them directly.

The model catalog returns the upstream provider pricing values unchanged; HOODY_AI_MODELS_MARKUP_BPS is not applied to the catalog or to gateway usage. Your prompts and responses flow through the Hoody AI gateway running on your own host, then out through the model routing upstream to the provider. No Hoody-operated platform server terminates them.

The Authorization: Bearer container-<name|N> shown in the HTTP examples below is a container identity/tracking token automatically minted for each container, not a Hoody API token you copy from a dashboard.

Model categories

Text generation models

Chat and completion models handle conversations, code generation, analysis, and general-purpose tasks.

Text models in the catalog come from these providers:

MiniMax - MiniMax M3
Qwen - Qwen 3 Max
DeepSeek - DeepSeek V-series, DeepSeek Coder
Meta - Llama 4, Llama 3.3 70B, Llama 3.1 405B
Mistral - Mistral Large, Mistral Medium, Mixtral
xAI - Grok 4
Microsoft - Phi 4

Request a chat completion from inside a container:

# Chat completion from your container
curl -X POST "https://ai.hoody.com/api/v1/chat/completions" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax/minimax-m3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://api.hoody.com', token: process.env.HOODY_TOKEN });

// List available models
const models = await client.api.ai.listModels();

// Chat completion: use the HTTP endpoint directly (see the HTTP tab)
// The SDK provides model listing; for chat completions,
// call the AI gateway endpoint from your container:
//   POST https://ai.hoody.com/api/v1/chat/completions

# Chat completion
curl -X POST "https://ai.hoody.com/api/v1/chat/completions" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax/minimax-m3",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

# Streaming
curl -X POST "https://ai.hoody.com/api/v1/chat/completions" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax/minimax-m3",
    "messages": [{"role": "user", "content": "Explain AI"}],
    "stream": true
  }'

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Runs the same chat completion shown above, plus its streaming variant with stream: true set on the body.

# Chat completion
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://ai.hoody.com/api/v1/chat/completions&method=POST&bearer_token=container-1&json={"model":"minimax/minimax-m3","messages":[{"role":"user","content":"Hello!"}]}&response=transparent

# Streaming
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://ai.hoody.com/api/v1/chat/completions&method=POST&bearer_token=container-1&json={"model":"minimax/minimax-m3","messages":[{"role":"user","content":"Explain%20AI"}],"stream":true}&response=transparent

The link carries a credential and executes with it, so it is as sensitive as the credential itself — and it passes through the cURL service's request log on the way, not just the target's. Share it only where you would share the secret, and prefer a delegated token with minimal permissions and an expiry: see API tokens.

POST Text generation request

https://ai.hoody.com/api/v1/chat/completions

Image-capable models

Hoody AI’s catalog is served from the gateway’s upstream model list, and image generation happens through the standard OpenAI-compatible /api/v1/chat/completions route, not a separate images endpoint. Models that can return images advertise "image" in their output_modalities in the /models catalog. Request one of those models and the response message includes the generated image.

Don’t hard-code a model name from this page. Pull /models and filter on output_modalities. The exact set of image-output models depends on what the upstream catalog currently offers.

curl -s https://api.hoody.com/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models[] | select(.output_modalities | index("image")) | .id'

Ask an image-capable model to return an image:

# Ask an image-capable model to generate an image (output via chat/completions)
curl -X POST "https://ai.hoody.com/api/v1/chat/completions" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<image-capable-model-id>",
    "messages": [{"role": "user", "content": "A serene mountain landscape at sunset"}]
  }'

// Image-capable models return images in the chat response.
// Pick a model whose output_modalities include "image" (see /models).
const response = await fetch('https://ai.hoody.com/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer container-1',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: '<image-capable-model-id>',
    messages: [{ role: 'user', content: 'A serene mountain landscape at sunset' }]
  })
});
const data = await response.json();
console.log(data.choices[0].message);

curl -X POST "https://ai.hoody.com/api/v1/chat/completions" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<image-capable-model-id>",
    "messages": [{"role": "user", "content": "A serene mountain landscape at sunset"}]
  }'

One request, one link

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Requests an image from a model whose output_modalities includes "image". Replace <image-capable-model-id> with a real id from the live catalog before using this link.

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://ai.hoody.com/api/v1/chat/completions&method=POST&bearer_token=container-1&json={"model":"<image-capable-model-id>","messages":[{"role":"user","content":"A%20serene%20mountain%20landscape%20at%20sunset"}]}&response=transparent

Embedding models

Embedding models convert text into vectors for semantic search, similarity matching, and RAG applications. They come from the same catalog: Cohere, Voyage AI, and the other vendors Hoody AI serves. Pull the live list and pick an id from it rather than hard-coding one from this page:

curl -s https://api.hoody.com/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models[].id' | grep -i embed

Generate an embedding:

# Generate text embeddings
curl -X POST "https://ai.hoody.com/api/v1/embeddings" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{"model": "<embedding-model-id>", "input": "Search for similar documents"}'

// Generate embeddings by calling the AI gateway directly from your container
const response = await fetch('https://ai.hoody.com/api/v1/embeddings', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer container-1',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: '<embedding-model-id>',
    input: 'Search for similar documents'
  })
});
const data = await response.json();
console.log(data.data[0].embedding.length, 'dimensions');

curl -X POST "https://ai.hoody.com/api/v1/embeddings" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<embedding-model-id>",
    "input": "Search for similar documents"
  }'

One request, one link

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Generates an embedding vector for the given text. Replace <embedding-model-id> with a real embedding-model id from the live catalog before using this link.

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://ai.hoody.com/api/v1/embeddings&method=POST&bearer_token=container-1&json={"model":"<embedding-model-id>","input":"Search%20for%20similar%20documents"}&response=transparent

Model selection guide

The catalog changes as the upstream adds and retires models, so select from the live list instead of a table that rots. Every entry has pricing; context_length may be absent or null, and the input_modalities / output_modalities fields are optional.

By use case

For code generation, analysis, and long documents, sort by context window and take the largest that fits your budget:

curl -s https://api.hoody.com/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models | sort_by(-(.context_length // 0))[] | "\(.context_length)\t\(.id)"' | head

For image understanding, filter on models that accept image input:

curl -s https://api.hoody.com/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models[] | select(.input_modalities | index("image")) | .id'

By cost

pricing.prompt is the per-input-token provider base price supplied by the upstream catalog, and Hoody returns it unchanged. Cheapest first:

curl -s https://api.hoody.com/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models | map(select((.pricing.prompt? | tonumber?) >= 0)) | sort_by(.pricing.prompt | tonumber)[] | "\(.pricing.prompt)\t\(.id)"' | head

Prototype on something at the cheap end and promote to a premium model only where the cheap one visibly fails.

Model format

For catalog-listed models, treat identifiers as opaque: copy the id exactly as returned by /api/v1/ai/models; do not abbreviate or alter it. The free-tier routing alias is an exception: when Hoody Free is enabled with a valid provider bundle, container-authenticated chat requests may use hoody-free, hoody/hoody-free, or hoody-ai/hoody-free even though those aliases are not catalog entries.

Model availability

Query the Hoody API for the current list of available models, including real-time availability.

curl "https://api.hoody.com/api/v1/ai/models" \
  -H "Authorization: Bearer $HOODY_TOKEN"

The SDK equivalent is client.api.ai.listModels(), which returns the same data from any supported language.

Model-specific features

Streaming support

All text models support streaming responses:

POST Streaming chat completion

https://ai.hoody.com/api/v1/chat/completions

The endpoint returns Server-Sent Events (SSE) for real-time token streaming.

Function calling

The gateway forwards tools unchanged, so function calling works with any catalog model whose provider supports it. Check the model’s own capabilities before relying on it.

POST Function calling request

https://ai.hoody.com/api/v1/chat/completions

Vision capabilities

Models with image understanding advertise "image" in input_modalities. Filter the live catalog on that field (see By use case above).

The following body is a template. Replace <vision-capable-model-id> with a current catalog id whose input_modalities contains "image", and replace <image-url> with a reachable image URL before sending it.

{
  "model": "<vision-capable-model-id>",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "What is in this image?" },
        { "type": "image_url", "image_url": { "url": "<image-url>" } }
      ]
    }
  ]
}

Best practices

Model selection

Start cheap and scale up:

Prototype on a model from the cheap end of the pricing.prompt sort
Test on a mid-tier model once the prompt shape is settled
Promote to a premium model only for the calls that visibly need it

Performance optimization

Match the model to task complexity:

Simple tasks → fast, cheap models
Complex reasoning → premium models
Bulk operations → batched requests with economical models

Example:

// Replace these placeholders with three ids selected from the live catalog after sorting on pricing.prompt
const CHEAP = '<cheap-chat-model-id>';
const MID = '<mid-tier-chat-model-id>';
const PREMIUM = '<premium-chat-model-id>';

// Classification: Use cheap model
const category = await classifyWithModel(CHEAP, text);

// Based on category, use appropriate model
const modelMap = {
  'simple': CHEAP,
  'moderate': MID,
  'complex': PREMIUM
};

const response = await processWithModel(modelMap[category], text);

Cost management

Monitor AI usage per container:

# Check which containers have AI enabled
curl "https://api.hoody.com/api/v1/containers/" \
  -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq '.data.containers[] | select(.ai == true) | {id, name, ai}'

# Enable/disable AI per container to control access
curl -X PATCH "https://api.hoody.com/api/v1/containers/{id}" \
  -H "Authorization: Bearer $HOODY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ai": false}'  # Disable AI to prevent usage

Container-level quotas and rate limiting are not currently available. You control cost by enabling or disabling AI access per container.

Troubleshooting

”Model not found” error

Problem: Invalid model identifier

Solution: Verify exact model string:

# Wrong
"model": "minimax-m3"

# Correct
"model": "minimax/minimax-m3"

Rate limiting

Problem: 429 Too Many Requests

Solutions:

Implement exponential backoff
Use multiple containers to distribute load
Switch to faster models to reduce request count
Contact Hoody support for increased AI credit allocation

Slow responses

Problem: Long wait times for responses

Solutions:

Use streaming ("stream": true) for immediate feedback
Switch to a faster, smaller model from the catalog
Reduce max_tokens parameter
Simplify prompts

What’s Next

A dynamic model browser is planned, covering:

Live model availability
Real-time pricing
Capability comparison
Performance benchmarks
Usage recommendations

Available now:

Usage Guide → - Integration examples
Security → - Key-less operation
Hoody AI Overview → - Gateway features and pricing