Hoody AI Models & Pricing

Access 300+ AI models through Hoody AI. Your server reaches 15+ inference providers through Hoody AI’s gateway and its model routing upstream.

Inference Providers

Your server reaches these providers through Hoody AI:

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
And more providers…

Not offered: 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.

How it works: 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

Hoody AI provides access to multiple categories of AI models:

Text Generation Models

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

Leading 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

Example usage:

# Chat completion from your container
curl -X POST "https://ai.hoody.icu/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.icu', token: process.env.HOODY_TOKEN });

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

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

# Chat completion
curl -X POST "https://ai.hoody.icu/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.icu/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
  }'

POST Text generation request

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

Click "Run" to execute the request

Image-Capable Models

Generate images from text — through the same chat endpoint.

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.

Discover image-capable models from the live catalog. 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.icu/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models[] | select(.output_modalities | index("image")) | .id'

Example usage:

# Ask an image-capable model to generate an image (output via chat/completions)
curl -X POST "https://ai.hoody.icu/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.icu/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.icu/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"}]
  }'

Embedding Models

Convert text into vector embeddings for semantic search, similarity matching, and RAG applications.

Available Models: embedding models 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.icu/api/v1/ai/models -H "Authorization: Bearer $HOODY_TOKEN" \
  | jq -r '.data.models[].id' | grep -i embed

Example usage:

# Generate text embeddings
curl -X POST "https://ai.hoody.icu/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 — call the AI gateway directly from your container
const response = await fetch('https://ai.hoody.icu/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.icu/api/v1/embeddings" \
  -H "Authorization: Bearer container-1" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<embedding-model-id>",
    "input": "Search for similar documents"
  }'

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

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

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

Image understanding — filter on models that accept image input:

curl -s https://api.hoody.icu/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.icu/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, 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.

Checking Model Availability

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

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

SDK equivalent: client.api.ai.listModels() 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.icu/api/v1/chat/completions

Click "Run" to execute the request

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.icu/api/v1/chat/completions

Click "Run" to execute the request

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, 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 model to task complexity:

Simple tasks → Use fast, cheap models
Complex reasoning → Use premium models
Bulk operations → Batch 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.icu/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.icu/api/v1/containers/{id}" \
  -H "Authorization: Bearer $HOODY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ai": false}'  # Disable AI to prevent usage

Note: Container-level quotas and rate limiting are not currently available. Cost management is achieved by enabling/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

Dynamic Model Browser (Coming Soon):

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

Current Resources:

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