# Get Endpoint Status Source: https://docs.aieev.com/api-reference/endpoint/get-endpoint openapi.json GET /endpoints/{endpoint_id} # Get Log File Content Source: https://docs.aieev.com/api-reference/endpoint/get-log-content openapi.json GET /endpoints/{endpoint_id}/logs/file # Get API Key Context Source: https://docs.aieev.com/api-reference/endpoint/get-me openapi.json GET /me # List Endpoints Source: https://docs.aieev.com/api-reference/endpoint/list-endpoints openapi.json GET /endpoints # List Log Files Source: https://docs.aieev.com/api-reference/endpoint/list-logs openapi.json GET /endpoints/{endpoint_id}/logs # List Replicas Source: https://docs.aieev.com/api-reference/endpoint/list-replicas openapi.json GET /endpoints/{endpoint_id}/replicas # Patch Endpoint Settings Source: https://docs.aieev.com/api-reference/endpoint/patch-endpoint openapi.json PATCH /endpoints/{endpoint_id} # Scale Endpoint Replicas Source: https://docs.aieev.com/api-reference/endpoint/scale-endpoint openapi.json POST /endpoints/{endpoint_id}/scale # Start Endpoint Source: https://docs.aieev.com/api-reference/endpoint/start-endpoint openapi.json POST /endpoints/{endpoint_id}/start # Stop Endpoint Source: https://docs.aieev.com/api-reference/endpoint/stop-endpoint openapi.json POST /endpoints/{endpoint_id}/stop # Overview Source: https://docs.aieev.com/api-reference/introduction Use the AirCloud External API to programmatically manage your endpoints. The AirCloud External API provides programmatic access to your container endpoints. Integrate GPU infrastructure into your applications, workflows, and automation systems. ## Available resources * **Endpoints**: Start, stop, scale, and monitor container endpoints. * **Replicas**: View live replica status for active endpoints. * **Logs**: Access endpoint log files and their contents. ## Authentication All requests require an [API key](/docs/get-started/quickstart) in the request headers. Pass your API key as a Bearer token in the `Authorization` header. ```bash theme={null} Authorization: Bearer YOUR_API_KEY ``` API Keys can only access the projects and endpoints specified at creation time. ## Important notes * Replica scaling is only available when the endpoint is **active**. * Endpoints with autoscaling enabled cannot be manually scaled. * Endpoint settings can only be patched (PATCH) when the endpoint is **inactive**. # API Usage Guide Source: https://docs.aieev.com/docs/air-api/api-usage-guide Authenticate with a secret key and integrate Air API This guide explains how to call Air API from your application after generating a secret key. Air API provides an OpenAI-compatible interface, allowing you to integrate with minimal code changes. If you are already using the OpenAI SDK, simply replace the `base_url` and API key. ## Migrate from OpenAI to AirCloud If your application already uses the OpenAI SDK, you only need to replace two settings. See the [OpenAI Compatible API](/docs/air-api/openai-compatible-api) page for the full quick start and code samples. ### Migration Checklist * Replace `base_url` / `baseURL` with your AirCloud endpoint from the Console. * Replace your OpenAI API key with an AirCloud secret key. * Update the `model` parameter to an AirCloud model ID. ## Find Your Endpoint and Secret Key Select your API workload in the Console, then click **View Code** to view the endpoint URL and code samples for the selected model. Code Sample Eng Replace `YOUR_ENDPOINT` and `YOUR_API_KEY` in the sample code with the values from your Console. ## Authentication Include your secret key in the `Authorization` header for every API request. ```text theme={null} Authorization: Bearer YOUR_API_KEY ``` A secret key is displayed only once when it is created. We recommend storing it as an environment variable instead of hardcoding it in your source code. If you lose the key, generate a new one from the Console. ## Code Examples For chat completion and embedding examples, see the [OpenAI Compatible API](/docs/air-api/openai-compatible-api) page. Air API also supports text-to-speech through the OpenAI SDK's audio endpoint, shown below. ### TTS Models ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="YOUR_ENDPOINT" ) response = client.audio.speech.create( model="YOUR_MODEL_ID", input="Hello. It's a beautiful day today.", voice="aiden" ) response.stream_to_file("output.mp3") ``` ```javascript Node.js theme={null} import OpenAI from "openai"; import fs from "fs"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "YOUR_ENDPOINT", }); const response = await client.audio.speech.create({ model: "YOUR_MODEL_ID", input: "Hello. It's a beautiful day today.", voice: "aiden", }); const buffer = Buffer.from(await response.arrayBuffer()); fs.writeFileSync("output.mp3", buffer); ``` ```bash cURL theme={null} curl YOUR_ENDPOINT/audio/speech \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "YOUR_MODEL_ID", "input": "Hello. It'\''s a beautiful day today.", "voice": "aiden" }' \ --output output.mp3 ``` ```bash Shell theme={null} #!/bin/bash API_KEY="YOUR_API_KEY" curl -s -X POST YOUR_ENDPOINT/audio/speech \ -H "Authorization: Bearer $API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "YOUR_MODEL_ID", "input": "Hello. It'\''s a beautiful day today.", "voice": "aiden" }' \ --output output.mp3 ``` ## Best Practices * **Protect your API key** — Store your secret key as an environment variable and never commit it to a source repository. * **Monitor usage** — Regularly review API usage and costs in the **Usage** tab of the Console. * **Maintain available credits** — API requests stop when your credits are exhausted. We recommend enabling automatic top-up to avoid service interruptions. ## Related Documentation Learn how to select models and test them using the Playground. Connect your existing OpenAI SDK code to Air API in two lines. Find solutions to common issues and errors. Explore detailed API specifications, including endpoints and parameters. # Air API Source: https://docs.aieev.com/docs/air-api/index Quickly integrate and test AI models through APIs Air API is an API-based workload that lets you quickly integrate AI models by selecting a supported model within your Project and generating a secret key. You can immediately test your integration using code samples or the Playground, without managing any infrastructure. It is ideal for rapid prototyping, proof-of-concept (PoC) projects, and applications that require fast model integration. ## What You Can Do with Air API Choose the AI model that best fits your use case. New models are continuously added. Select the API endpoints you want to access and generate a secret key. Verify your integration immediately using the generated secret key. Interact with models directly from your browser using the web-based Playground. ## Quickstart ### 1. Select Air API from the Project Overview Air Api Eng After creating your Organization and Project, navigate to the Project Overview page and select **Air API**. ### 2. Select a Model Request Model Eng Create an API workload and select the model you want to use. If the model you need is not available, you can submit a request through our feedback channel. ### 3. Generate a Secret Key Go to **API Keys** → **Create New Secret Key**. Create Api Key Eng A secret key is displayed only once after it is created. Be sure to copy and store it in a secure location. ### 4. Test with a Code Sample After generating your secret key, open the desired model card and click **View Code** in the upper-right corner. Replace `your-api-key` with your secret key and run the sample to verify your connection. ### 5. Test in Playground Open the Playground to interact with the model directly from the web interface. When you need dedicated resources, lower latency, or specific GPU configurations, you can seamlessly migrate the same workload to Air Container. Example Playground Eng ## Related Documentation Browse supported models and learn how to use the Playground. Learn how to authenticate, call the API, and follow best practices. Connect your existing OpenAI SDK code to Air API in two lines. Find solutions to common errors and troubleshooting tips. # Models and Playground Source: https://docs.aieev.com/docs/air-api/models-and-playground Select supported models and test them in Playground Air API lets you select supported models within your Project and test them directly in your browser using the Playground. ## Supported Models For detailed specifications and usage examples of each model, see the [Models](/models) page. | Model | Type | | :-: | :-: | | Qwen: Qwen3.8-27B | Chat | | Qwen: Qwen3.6-35B-A3B | Chat | | Qwen: Qwen3.5-9B | Chat | | Qwen: Qwen3-32B | Chat | | Meta: Llama3.3-70B-Instruct | Chat | | DeepSeek: DeepSeek-V4-Flash | Chat | | Qwen: Qwen3-Embedding-8B | Embedding | | Qwen: Qwen3-TTS | TTS | * **Chat**: Conversational models that generate responses from text prompts. Suitable for tasks such as chatbots, summarization, and code generation. Pricing is based on input and output tokens (/M tokens). * **Embedding**: Models that convert text into vector embeddings for semantic search, classification, and similarity search. Pricing is based on input tokens (/M tokens). * **TTS**: Models that convert text into speech. Pricing is based on the number of input characters (/1,000 chars). If the model you need is not available, you can request it through our feedback channel. ## Playground The Playground is a web-based interface for testing models directly in your browser. It allows you to quickly validate model behavior and experiment with parameters before integrating the API into your application. Playground is available only for **Chat** and **TTS** models. Embedding models do not provide a Playground and can only be used through the API. The Playground provides two tabs: * **Playground** — Interact with the selected model directly. * **README** — Learn about the selected model's capabilities and usage. You can also access **Generate API Key** and **View Code** from the buttons in the upper-right corner. The Playground interface and available settings vary depending on the model type. ### Chat Models The Chat Playground provides a conversational interface where you can enter prompts and receive responses from the selected model. Chat Playground Eng Use the **Chat Settings** panel on the right to configure model behavior. | Setting | Description | | :- | :- | | **System Prompt** | Sets the initial instruction that defines the model's role or behavior. This prompt is applied throughout the conversation. | | **Reasoning** | Enables reasoning before generating a response. This may increase latency and token usage but can improve accuracy on complex tasks. | | **Temperature** | Controls the randomness of generated responses. Higher values produce more diverse and creative outputs, while lower values generate more consistent and deterministic responses. | | **Max Tokens** | Sets the maximum number of tokens the model can generate in a single response. The sum of the prompt tokens and `max_tokens` cannot exceed the model's context length. | | **Top P** | Uses nucleus sampling as an alternative to temperature sampling. Only tokens within the top cumulative probability are considered, allowing you to control response diversity together with Temperature. | | **Frequency Penalty** | Reduces the likelihood of repeating words or phrases based on how frequently they have already appeared in the generated text. | | **Presence Penalty** | Encourages the model to introduce new topics by penalizing tokens that have already appeared in the conversation. | ### TTS Models The TTS Playground lets you generate speech from text. Enter the text you want to convert, then click **Generate** to create and play the audio. Tts Playground Eng Use the **TTS Settings** panel on the right to configure speech generation. | Setting | Description | | :- | :- | | **Instructions** | Provides guidance for the voice style or speaking tone (for example, *"Speak in a friendly and engaging tone."*). | | **Voice** | Selects the voice used for speech generation. (Currently supports 9 voice options.) | | **Speed** | Adjusts the playback speed of the generated audio. The default value is **1×**. | | **Response Format** | Selects the output audio format. Supported formats: **MP3, Opus, AAC, FLAC, WAV, and PCM**. | Chat and Embedding models are priced per **million tokens (/M tokens)**, while TTS models are priced per **thousand characters (/K chars)**. Use the currency toggle (₩ / \$) to switch between KRW and USD pricing. ## Related Documentation Learn the overall Air API workflow and complete the Quickstart. Learn how to call the API and follow operational best practices. Find solutions to common issues and errors. Explore detailed specifications and usage examples for each supported model. # Monitoring Source: https://docs.aieev.com/docs/air-api/monitoring Monitor Air API requests, usage, and spending AirCloud provides two levels of monitoring for Air API: **Project-level Monitoring** and **Organization-level Usage**. Use **Project Monitoring** to analyze API requests and performance, and **Organization Usage** to track spending trends across projects over time. ## Project Monitoring From the Project sidebar, navigate to **Monitoring** and select the **Air API** tab to view API request metrics and spending for the current project over time. Project Monitoring Eng ### Metrics | Metric | Description | | - | - | | **Total Requests** | Total number of API requests during the selected period. | | **Total Tokens** | Sum of input and output tokens. | | **Total Characters** | Total characters processed by character-based models such as TTS. | | **Total Cost** | Total spending during the selected period, in credits (C). | | **Most Used Model** | The model with the highest number of requests. | | **Input Tokens** | Total number of input tokens. | | **Output Tokens** | Total number of output tokens. | | **Input Cost** | Cost incurred by input tokens. | | **Output Cost** | Cost incurred by output tokens. | ### Filter Options Project Monitoring Filter | Option | Description | | - | - | | **Service Type** | Filter by **All**, **Chat (LLM)**, or **TTS**. | | **Model** | View requests for a specific model only. | | **API Key** | View requests made using a specific API key. | | **Date Range** | Select the time range to analyze. | | **Time Interval** | Choose the aggregation interval (for example, **1 minute** or **5 minutes**). | | **Auto Refresh** | Enable or disable automatic updates. | ### Request History Individual API requests are displayed in a table below the metrics. Click **Export** to download the request history. Export Eng329 | Field | Description | | - | - | | **Created At** | Time when the request was made. | | **API Key** | API key used for the request. | | **Model** | Model used for the request. | | **Engine Type** | Request type, such as **Chat (LLM)** or **TTS**. | | **Usage** | Number of tokens or characters processed. | | **Latency** | Time taken to process the request. | ## Organization Usage From the Organization page, navigate to **Usage Management** → **Usage**, then select the **Air API** filter to view Air API spending across all Projects within the Organization. The table below provides a daily spending breakdown for each Project. Org Usage Eng392 ### Metrics | Metric | Description | | - | - | | **Total Cost** | Total Air API spending during the selected period. | | **Highest Daily Cost** | The highest daily spending amount and the corresponding date. | | **Cost Distribution** | Pie chart showing spending by Project. | | **Service Cost** | Combined spending for other services, such as Air Container. | | **Active Projects** | Number of Projects that made API requests during the selected period. | ## Related Documentation Learn how to authenticate and call Air API. Learn about credit-based billing and the refund policy. # OpenAI Compatible API Source: https://docs.aieev.com/docs/air-api/openai-compatible-api Connect your existing OpenAI SDK code to Air API Air API provides an endpoint that is compatible with the OpenAI API. If your application already uses the OpenAI SDK, you only need to replace **two settings — the base URL and the API key** — to get started. ## Quick Start Update just two lines in your existing OpenAI code. ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_AIEEV_API_KEY", # Replace: Air API key base_url="https://ap-1.aieev.cloud/endpoints//v1" # Replace: Air API base URL ) response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=[ {"role": "user", "content": "Hello!"} ] ) print(response.choices[0].message.content) ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_AIEEV_API_KEY", // Replace: Air API key baseURL: "https://ap-1.aieev.cloud/endpoints//v1", // Replace: Air API base URL }); const response = await client.chat.completions.create({ model: "qwen/qwen3.5-9b", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints//v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_AIEEV_API_KEY" \ -d '{ "model": "qwen/qwen3.5-9b", "messages": [ {"role": "user", "content": "Hello!"} ] }' ``` ```bash Shell theme={null} #!/bin/bash API_KEY="YOUR_AIEEV_API_KEY" response=$(curl -s -X POST https://ap-1.aieev.cloud/endpoints//v1/chat/completions \ -H "Authorization: Bearer $API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3.5-9b", "messages": [{"role": "user", "content": "Hello!"}] }') echo "$response" | jq . ``` See the [Authentication](/docs/get-started/authentication) page for how to generate an API key. ## Base URL Each model has its own endpoint URL. Replace `` with the **endpoint ID** from the table below. ```text theme={null} https://ap-1.aieev.cloud/endpoints//v1 ``` For example, for Qwen3.6-35B-A3B: ```text theme={null} https://ap-1.aieev.cloud/endpoints/qwen3-6-35b-a3b/v1 ``` The **endpoint ID** in the URL and the **model ID** passed as the `model` parameter use different notation. If the `model` value does not exactly match the model ID in the table below, the API returns a 404 error (`The model ... does not exist.`). ## Supported Models and Features | Model | Endpoint ID | Model ID (`model`) | Context | Streaming | Tool Calling | Vision | Reasoning | | :- | :- | :- | :-: | :-: | :-: | :-: | :-: | | Qwen3.8-27B | `qwen-3-8-27b` | `qwen/qwen3.8-27b` | 256K | ✅ | ✅ | ✅ image + video | ✅ | | Qwen3.6-35B-A3B | `qwen3-6-35b-a3b` | `qwen/qwen3.6-35b-a3b` | 256K | ✅ | ✅ | ✅ up to 4 | ✅ | | Qwen3.5-9B | `qwen3-5-9b` | `qwen/qwen3.5-9b` | 256K | ✅ | ✅ | ✅ up to 1 | ✅ | | Llama3.3-70B | `llama3-3-70b-instruct` | `meta-llama/meta-llama-3.3-70b-instruct` | 128K | ✅ | ✅ | ❌ | ❌ | | Qwen3-32B | `qwen3-32b` | `qwen/qwen3-32b` | 40K | ✅ | ✅ | ❌ | ✅ | | DeepSeek V4 Flash | `deepseek-v4-flash` | `deepseek/deepseek-v4-flash` | 128K | ✅ | ✅ | ❌ | ✅ | | Qwen3-Embedding-8B | `qwen3-embedding-8b` | `qwen/qwen3-embedding-8b` | 32K | - | - | - | - | | Qwen3-TTS | `qwen3-tts` | `qwen/qwen3-tts-customvoice` | - | - | - | - | - | ✅ supported · ❌ not supported · `-` not applicable or TBD ## Response Format Chat Completions responses use the same structure as the OpenAI API. ```json theme={null} { "id": "chatcmpl-8f3a1b2c...", "object": "chat.completion", "created": 1753250000, "model": "qwen/qwen3.5-9b", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Hello! How can I help you today?", "reasoning": null, "tool_calls": [] }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 10, "completion_tokens": 12, "total_tokens": 22 } } ``` | Field | Description | | :- | :- | | `choices[].message.content` | The model's response text | | `choices[].message.reasoning` | The model's reasoning trace (see [Reasoning](#reasoning)) | | `choices[].message.tool_calls` | Function calls requested by the model (see [Tool Calling](#tool-calling-function-calling)) | | `choices[].finish_reason` | Why generation stopped — `stop` (natural end), `length` (`max_tokens` reached), `tool_calls` (function call requested) | | `usage` | Input, output, and total token counts | ## Streaming Set the `stream` option to `true` to receive the response in real time as SSE (Server-Sent Events). (Default: `false`) ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=[{"role": "user", "content": "Hello!"}], stream=True, stream_options={"include_usage": True} # optional: usage in the final chunk ) for chunk in response: if chunk.choices and chunk.choices[0].delta.content: print(chunk.choices[0].delta.content, end="", flush=True) ``` * Each chunk delivers a text fragment in `choices[0].delta.content`, and the stream ends with a `data: [DONE]` event. * Send `stream_options={"include_usage": true}` to receive token usage (`usage`) in the final chunk. Streaming is supported on every chat model: **Qwen3.8-27B**, **Qwen3.6-35B-A3B**, **Qwen3.5-9B**, **Qwen3-32B**, **Llama3.3-70B**, and **DeepSeek V4 Flash**. ## Tool Calling (Function Calling) Lets the model call external functions or services. Supported on **Qwen3.8-27B**, **Qwen3.6-35B-A3B**, **Qwen3.5-9B**, **Qwen3-32B**, **Llama3.3-70B**, and **DeepSeek V4 Flash**. Tool calling is a three-step flow: define functions and send the request, the model suggests a function call, then execute the function and send back the result. The model does not execute functions itself — it only generates which function to call and with what arguments. ### 1. Define your functions and send the request ```python theme={null} tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Look up the weather for a given location.", "parameters": { "type": "object", "properties": { "location": { "type": "string", "description": "City name (e.g. Seoul)" } }, "required": ["location"] } } } ] messages = [{"role": "user", "content": "What's the weather in Seoul?"}] response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=messages, tools=tools, tool_choice="auto" ) ``` ### 2. The model suggests a function call When the model decides a function call is needed, it returns a `tool_calls` array with `finish_reason: "tool_calls"`. ```json theme={null} { "role": "assistant", "content": null, "tool_calls": [ { "id": "call_abc123", "type": "function", "function": { "name": "get_weather", "arguments": "{\"location\": \"Seoul\"}" } } ] } ``` `function.arguments` is returned as a JSON **string** — parse it with `json.loads()` (or equivalent) before use. The model may return multiple function calls at once, so iterate over the entire `tool_calls` array. ### 3. Execute the function and return the result Append the result as a `role: "tool"` message and send the request again — the model generates the final answer based on the result. ```python theme={null} import json message = response.choices[0].message if message.tool_calls: messages.append(message) # add the model's tool_calls response to the conversation for tool_call in message.tool_calls: args = json.loads(tool_call.function.arguments) result = get_weather(**args) # execute the actual function messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result), }) final = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=messages, tools=tools, ) print(final.choices[0].message.content) # e.g. "It's currently sunny in Seoul at 28°C." ``` ### tool\_choice options | Value | Behavior | | :- | :- | | `"auto"` (default) | The model decides whether to call a function | | `"none"` | No function calls are returned via `tool_calls` | | `{"type": "function", "function": {"name": "get_weather"}}` | Forces a call to the specified function | Even with `tool_choice: "none"`, the model may still emit function-call-shaped text in the response body if `tools` definitions remain in the request. When you don't need function calls, the most reliable approach is to omit the `tools` parameter entirely. ### Parallel tool calls The model can return multiple function calls in a single response via the `tool_calls` array. Set `parallel_tool_calls` to `false` (default `true`) to limit the model to one function call at a time. ### Streaming tool calls With `stream: true`, tool call data arrives split across chunks. The first chunk of each tool call carries `id` and `function.name`, and subsequent chunks deliver `function.arguments` in sequence. Group tool calls by `index`, then concatenate `function.arguments` in arrival order. The stream ends with a chunk carrying `finish_reason: "tool_calls"`. ```python theme={null} stream = client.chat.completions.create( model="qwen/qwen3.6-35b-a3b", messages=[{"role": "user", "content": "What's the weather in Seoul?"}], tools=tools, stream=True, ) tool_calls = {} for chunk in stream: if not chunk.choices: continue for tc in chunk.choices[0].delta.tool_calls or []: entry = tool_calls.setdefault(tc.index, {"id": "", "name": "", "arguments": ""}) entry["id"] = tc.id or entry["id"] entry["name"] = tc.function.name or entry["name"] entry["arguments"] += tc.function.arguments or "" ``` ## Vision (Image Input) Qwen3.8-27B, Qwen3.6-35B-A3B, and Qwen3.5-9B accept image input. Qwen3.8-27B also accepts video, passed as a `video_url` block. Pass `messages[].content` as an array and include images with the `image_url` type. `image_url.url` accepts an externally reachable image URL or a base64-encoded data URI (`data:image/jpeg;base64,...`). ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.6-35b-a3b", messages=[ { "role": "user", "content": [ {"type": "text", "text": "What do you see in this image?"}, {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}, ], } ], ) ``` The number of images per request is limited per model — **Qwen3.6-35B-A3B: up to 4**, **Qwen3.5-9B: up to 1**. Video input is supported on **Qwen3.8-27B** only. ## Reasoning Qwen chat models and DeepSeek V4 Flash support reasoning (thinking). On **Qwen3.8-27B** the depth is tunable with `reasoning_effort` (`xhigh` / `medium` / `low`), and streamed reasoning arrives in `reasoning_content` rather than `reasoning`. The reasoning trace is returned separately from the final answer (`content`) in the `reasoning` field. ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.6-35b-a3b", messages=[{"role": "user", "content": "Calculate 127 * 43 step by step"}], max_tokens=4096, ) message = response.choices[0].message print(message.reasoning) # reasoning trace print(message.content) # final answer ``` * Reasoning text also consumes `max_tokens`. Set it generously — if the value is too small, the answer may get cut off. * When streaming, reasoning fragments arrive first via `delta.reasoning`, followed by `delta.content`. * **Qwen3-32B** returns its reasoning inline as `` tags inside `content` instead of the `reasoning` field. It can likewise be disabled with `enable_thinking: false`. ### Disabling reasoning To get an answer directly without reasoning, turn it off via `chat_template_kwargs`. ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.6-35b-a3b", messages=[{"role": "user", "content": "Hello!"}], extra_body={"chat_template_kwargs": {"enable_thinking": False}}, ) ``` ## JSON Mode (Structured Outputs) Set `response_format` to always receive valid JSON. ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=[ {"role": "system", "content": "Extract user info as a JSON object."}, {"role": "user", "content": "Chulsoo Kim is a 32-year-old backend developer."}, ], response_format={"type": "json_object"}, ) print(response.choices[0].message.content) # {"name": "Chulsoo Kim", "age": 32, "job": "backend developer"} ``` Also instruct the model to respond in JSON in your prompt for more reliable results. Reasoning consumes tokens and can truncate the JSON, so combining JSON mode with [disabled reasoning](#disabling-reasoning) is recommended. ## Embedding Converts text into vectors, useful for semantic search, recommendation systems, and RAG. You can also pass an array of strings as `input` to embed multiple texts in a single request. ```python theme={null} response = client.embeddings.create( model="qwen/qwen3-embedding-8b", input="Text to embed.", ) print(response.data[0].embedding) # 4,096-dimensional vector ``` ## Supported Parameters Air API supports the core OpenAI parameters based on the official vLLM spec. | Parameter | Description | | :- | :- | | `model` | The model ID to use | | `messages` | Array of conversation messages | | `stream` | Whether to stream the response (default: false) | | `stream_options` | Streaming options (`{"include_usage": true}` to receive usage) | | `temperature` | Controls response randomness (0.0 – 2.0) | | `max_tokens` | Maximum number of tokens to generate | | `top_p` | Nucleus sampling probability | | `frequency_penalty` | Penalizes repetition based on token frequency (-2.0 – 2.0) | | `presence_penalty` | Penalizes repetition based on token presence (-2.0 – 2.0) | | `stop` | String(s) that stop generation | | `seed` | Fixed seed for reproducible outputs | | `n` | Number of response candidates to generate | | `logprobs` / `top_logprobs` | Return per-token log probabilities | | `response_format` | Response format (`{"type": "json_object"}`) | | `tools` | Tool calling function definitions | | `tool_choice` | How tools are invoked (`auto`, `none`, or a specific function) | | `parallel_tool_calls` | Whether multiple function calls may be returned in one response (default: true) | vLLM extension sampling parameters such as `top_k`, `min_p`, and `repetition_penalty` are also available. With the OpenAI SDK, pass them via `extra_body`. ```python theme={null} response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=[{"role": "user", "content": "Hello!"}], extra_body={"top_k": 20, "repetition_penalty": 1.05}, ) ``` ## Related Documentation Learn the full flow for secret key authentication and code-based API integration. See specs and pricing for every model. Find solutions to common issues and errors. Explore detailed API specifications, including endpoints and parameters. # Troubleshooting Source: https://docs.aieev.com/docs/air-api/troubleshooting Common Air API errors and how to resolve them Most issues encountered while using Air API fall into one of four categories: authentication, request validation, billing, or service availability. Use the sections below to identify and resolve your issue. ## Error Code Reference | Code | Meaning | Common Cause | | :- | :- | :- | | **401** | Unauthorized | Missing or invalid secret key | | **402** | Payment Required | Insufficient credits | | **403** | Forbidden | No permission to access the requested model | | **408** | Request Timeout | Request processing exceeded the timeout | | **422** | Unprocessable Entity | Invalid request parameters | | **429** | Too Many Requests | Rate limit exceeded | | **502** | Bad Gateway | Temporary model service error | | **503** | Service Unavailable | Service maintenance or overload | *** ## Authentication Errors **Cause:** The secret key is missing, invalid, or has already been deleted. **Check the following:** * Make sure the request includes the `Authorization: Bearer YOUR_API_KEY` header. * Verify that there are no leading or trailing spaces in the API key. * If you are loading the key from an environment variable, confirm that it is correctly configured. * Verify that the key is still active in the Console. Secret keys are displayed only once when they are created and cannot be viewed again. Delete the existing key from the Console and generate a new one. We recommend copying it immediately and storing it securely as an environment variable. ## Billing and Credit Issues **Cause:** Your Organization's credit balance has been exhausted, preventing further API requests. **Resolution:** * Add credits from the **Billing** page in the Console. * Retry your API request after the credits have been added. * To prevent interruptions, enable **Auto Top-up**. ## Request Validation Errors **Cause:** One or more request parameters are invalid or incorrectly formatted. **Check the following:** * Ensure that every item in the `messages` array includes both `role` and `content`. * Verify that numeric parameters such as `temperature` and `max_tokens` are provided as numbers, not strings. * Refer to the API Reference for the valid range and format of each parameter. **Cause:** The value provided in the `model` parameter does not match a valid AirCloud model ID. **Resolution:** * In the Console, click **View Code** for the selected model. The generated code sample contains the correct model ID, which you can copy directly. ## Rate Limits and Service Errors **Cause:** Your application has exceeded the allowed request rate. **Resolution:** * Check the `Retry-After` response header and retry after the specified delay. * Distribute requests over time or implement exponential backoff. Air API does not enforce a published per-account request or token rate limit today. A 429 means the model's serving capacity is saturated at that moment, so backing off and retrying is the right response. **Cause:** The model did not complete the request within the allowed timeout. This may occur with long prompts or large `max_tokens` values. **Resolution:** * Reduce the `max_tokens` value. * Verify that your client-side timeout is not set too low. * Retry the request after a short delay. **Cause:** The model service is temporarily unavailable or undergoing maintenance. **Resolution:** * Retry the request after a few seconds or minutes. * If the issue persists, contact us through the [Contact and Feedback](/docs/support/contact-and-feedback) page. Planned maintenance and incidents are announced through console notifications. See [Notifications](/docs/console/notifications). **Cause:** Response latency may increase depending on model load, prompt length, or the configured `max_tokens` value. **Check the following:** * Use only the `max_tokens` value you actually need. * Test the same prompt in the Playground to compare response times. * If latency remains high, consider using a smaller model. ## Playground Issues Try the following steps: 1. Refresh your browser and try again. 2. Verify that the correct Project and model are selected. 3. Confirm that your Organization has sufficient credits. 4. Try using an incognito window or a different browser. Playground is not supported for Embedding models. This is expected behavior. To use an Embedding model, send requests through the API. See the [API Usage Guide](/docs/air-api/api-usage-guide) for code examples. ## Model Issues We continuously add support for new models. If the model you need is not available, you can request it through the [Contact and Feedback](/docs/support/contact-and-feedback) page. **Cause:** Your current account or Project does not have permission to access the requested model. **Resolution:** * An API key can only reach the Air API endpoints selected when the key was created. Check the key's **Air API Access** setting in the Console, or create a new key that includes the model you need. * Some models are enabled per organization. If the model does not appear in your Console at all, request it through the [Contact and Feedback](/docs/support/contact-and-feedback) page. ## Still Need Help? If your issue is not resolved, please contact us through the [Contact and Feedback](/docs/support/contact-and-feedback) page. To help us investigate the issue more quickly, include the following information whenever possible: * Error code * Request payload (excluding secret keys) * Time when the issue occurred * Any relevant error messages or logs # Overview Source: https://docs.aieev.com/docs/air-container/access-and-connect Learn how to connect to and operate running containers Air Container provides multiple ways to access and operate running containers. This section is organized into three parts: * **Web Terminal** for browser-based terminal access from the AirCloud console * **aircloud CLI** for installing the CLI and using core commands such as `config`, `whoami`, `endpoints`, `exec`, and `ssh` * **SSH access** for SSH key setup and `aircloud ssh` connection workflows ## Quick links Learn how the Terminal button works for custom containers, including activation, replica selection, and session exit. Install the CLI and use commands such as `config`, `whoami`, `endpoints`, `exec`, and `ssh`. Set up SSH keys and connect with `aircloud ssh`. # Autoscaling and Scheduled Scaling Source: https://docs.aieev.com/docs/air-container/autoscaling-and-scheduling Automatically scale replicas based on traffic or schedules Air Container supports both **Autoscaling** and **Scheduled Scaling**, allowing you to automatically adjust the number of Replicas based on traffic patterns or predefined schedules. ## Autoscaling Autoscaling automatically increases or decreases the number of Replicas based on incoming traffic. It is useful when: * Traffic varies significantly throughout the day. * You want to reduce response latency while improving resource efficiency. * Manually adjusting the number of Replicas is impractical. Autoscaling can be enabled during container deployment or later from the **Settings** page. Autoscaling Setting Eng05 ### Configuration | Setting | Description | | - | - | | **Minimum Replicas** | Minimum number of Replicas to keep running. | | **Maximum Replicas** | Maximum number of Replicas that Autoscaling can provision. | | **Scaling Sensitivity** | Controls how aggressively Autoscaling responds to traffic changes (**Low**, **Medium**, or **High**). | ### Scaling Sensitivity Scaling Sensitivity determines how quickly AirCloud responds to changes in traffic. | Sensitivity | Behavior | Recommended For | | - | - | - | | **Low** | Conservative scaling | Workloads with gradual traffic changes where excessive scale-outs should be avoided. | | **Medium** | Balanced scaling | General API services and model serving workloads. Recommended for most deployments. | | **High** | Aggressive scaling | Workloads with sudden traffic spikes and strict latency requirements. | ## Scheduled Scaling * Set **Minimum Replicas** to **1** if your service must always remain available. Setting it to **0** allows containers to scale down completely when there is no traffic. * Start with **Medium** scaling sensitivity and adjust it based on actual usage patterns. * Create multiple schedules to apply different scaling policies throughout the day. * Switching between fixed Replicas and Autoscaling restarts the container. Schedule these changes during periods of low traffic whenever possible. Scheduled Scaling automatically adjusts the number of Replicas according to a predefined schedule. It is particularly effective for workloads with predictable traffic patterns and can be used together with Autoscaling. Scheduling Eng592 ### Create a Schedule From the container details page, navigate to **Scheduled Scaling** and click **+ Add Schedule**. Each schedule can have its own independent scaling configuration. | Setting | Description | | - | - | | **Name** | A descriptive name for the schedule (for example, **Business Hours Scale Up**). | | **Enable Autoscaling** | Choose whether to use Autoscaling (minimum and maximum Replicas) or a fixed number of Replicas during this schedule. | | **Minimum Replicas** | Minimum number of Replicas to maintain while Autoscaling is enabled. | | **Maximum Replicas** | Maximum number of Replicas that Autoscaling can provision. | | **Initial Replicas** | Number of Replicas to start when the schedule becomes active. | | **Scaling Sensitivity** | Autoscaling responsiveness (**Low**, **Medium**, or **High**). | | **Schedule** | Currently supports daily recurring schedules. | | **Start Time** | Date and time when the schedule starts. (Optional, KST) | | **End Time** | Time when the schedule ends. (Optional) | | **Enabled** | Enables or disables the schedule. | Switching between **fixed Replicas** and **Autoscaling** restarts the container. Zero-downtime deployment is not guaranteed, and additional time may be required for initialization and deployment. ### Example: Business Hours Traffic Suppose your application experiences higher traffic between **9:00 AM and 7:00 PM (KST)** every day. * **Schedule 1** — **Business Hours Scale Up**: Autoscaling **Enabled**, Minimum Replicas **2**, Maximum Replicas **5**, Start Time **09:00 KST** * **Schedule 2** — **Scale Down at Night**: Autoscaling **Disabled**, Fixed Replicas **1**, Start Time **19:00 KST** ## Related Documentation Learn how to deploy a container and configure its resources. Learn how to monitor usage, logs, and deployment settings. # Connect with SSH Source: https://docs.aieev.com/docs/air-container/connect-with-ssh Access running containers over SSH using aircloud ssh `aircloud ssh` allows you to connect to a running container from your local terminal using SSH. It is the preferred option when your workflow depends on native SSH features, such as: * `scp` * SSH tunneling * Port forwarding with `ssh -L` * VS Code Remote SSH Unlike the Web Terminal or `aircloud exec`, SSH access requires a registered SSH public key. ## When to Use `aircloud ssh` Use `aircloud ssh` when you need to: * Transfer files using `scp`. * Create SSH tunnels or port forwarding. * Connect using SSH-based IDEs. * Work with an SSH-centric operational workflow. ## Register an SSH Key Open **SSH Keys** from the Project sidebar. Ssh Menu When adding a new SSH key, provide: * A descriptive name. * Your complete OpenSSH public key. * The endpoint where the key should be injected. Ssh Open Key If the endpoint is already running when a key is added or updated, the new key is applied the next time the endpoint starts or is redeployed. Existing running containers continue using their current key set. Image 8 ## Apply SSH Keys to Specific Containers Registered SSH keys can be managed independently for each endpoint. * **Apply to specific endpoints** — Select which endpoint should receive the SSH key during registration. * **Enable or Disable** — Disable a key without deleting it. Disabled keys are no longer injected after the next container restart and can be re-enabled later. Changes to SSH key settings take effect only after the container has been stopped and started again. ## Prerequisites ### AirCloud Templates Some AirCloud-provided templates, such as Jupyter environments and code workspaces, already include SSH support. ## Basic Setup ### 1. Generate an SSH Key Pair ```bash theme={null} ssh-keygen -t ed25519 -C "your-email@example.com" ``` ### 2. View Your Public Key ```bash theme={null} cat ~/.ssh/id_ed25519.pub ``` ### 3. Register the Public Key In the AirCloud Console: 1. Open your **Project**. 2. Navigate to **SSH Keys**. 3. Click **Add SSH Key**. 4. Select the endpoint where the key should be injected. ### 4. Restart the Endpoint (If Required) If the endpoint was already running when the key was added or updated, stop and restart the endpoint to apply the new SSH key. ## Connect Using `aircloud ssh` ### Connect to an Endpoint ```bash theme={null} aircloud ssh ``` ### Use a Specific Identity File ```bash theme={null} aircloud ssh -i ~/.ssh/aircloud_key ``` ### Connect to a Specific Replica ```bash theme={null} aircloud ssh -r ``` ### Connect as a Different User ```bash theme={null} aircloud ssh -u myuser ``` ### Open a Tunnel Only ```bash theme={null} aircloud ssh --tunnel-only ``` ## Use with VS Code Remote SSH, scp, and other tools To use external SSH tools such as VS Code Remote SSH, `scp`, or `rsync`, register a reusable SSH config entry once: ```bash theme={null} aircloud ssh-config --install -i ~/.ssh/id_ed25519 ``` Then connect by host alias: ```bash theme={null} ssh aircloud- scp ./file aircloud-:/workspace/ # VS Code: Remote-SSH → Connect to Host → aircloud- ``` To remove the entry later: ```bash theme={null} aircloud ssh-config --uninstall ``` ## `aircloud ssh` vs. `aircloud exec` | Feature | `aircloud ssh` | `aircloud exec` | | - | - | - | | Requires SSH key registration | ✅ Yes | ❌ No | | Supports `scp` | ✅ Yes | ❌ No | | Supports SSH tunneling | ✅ Yes | ❌ No | | Supports Remote SSH tools | ✅ Yes | ❌ No | | Connection speed | Slightly slower | Faster | # Container Management Source: https://docs.aieev.com/docs/air-container/container-management Manage the container lifecycle, data persistence, and tags ## Start, Stop, and Restart A deployed container can be in one of five states. Billing and data persistence depend on the current container state. ### Container States | State | Description | Billing | | - | - | - | | 🟢 **RUNNING** | The container is running normally. | Charged hourly | | 🟡 **UPDATING** | The container is restarting to apply configuration changes. | Charged hourly | | ⚫ **READY** | The container is stopped and no compute resources are allocated. | Not charged | | 🔴 **DEPLOY FAILED** | An error occurred during deployment, such as a failed image pull. | Not charged | | 🔴 **UNHEALTHY** | The container is running but has failed health checks or is not operating correctly. | Not charged | When a container is in **DEPLOY FAILED** or **UNHEALTHY**, an **Error Details** chip appears next to the status. Opening it shows the diagnosed cause and what to do about it — see [Troubleshooting](/docs/air-container/troubleshooting). If you do not use **Persistent Storage**, all data stored inside the container will be lost when the container is stopped or restarted. To preserve your data, make sure Persistent Storage is enabled. Hourly charges apply only while the container is in the **RUNNING** or **UPDATING** state. Containers in the **READY**, **DEPLOY FAILED**, or **UNHEALTHY** state are not billed. ### Stop a Container Stopping a container changes its state to **READY**. * Compute resources are released and billing stops. * Starting the container again launches a new container instance. ### Data Persistence Whether your data is preserved depends on whether **Persistent Storage** is enabled. For setup instructions, see [Persistent Storage](/docs/air-container/shared-storage). | Scenario | Without Persistent Storage | With Persistent Storage | | - | - | - | | Stop and start a container | Data is lost | Data is preserved | | Restart a container | Data is lost | Data is preserved | ## Container Tags Tags allow you to organize containers into custom groups. As the number of containers grows, tags make it easier to group and filter containers by purpose, project, or model family. Tag Eng ### Create and Assign Tags Click **+ Add Tag** at the top of the container list, create a tag, and select the containers you want to assign it to. A single tag can be assigned to multiple containers. ### Filter by Tag Click a tag in the tag list to display only the containers associated with that tag. Click **Clear Selection** to return to the full container list. ## Related Documentation Learn how to persist data across container restarts. Learn how to configure Autoscaling and Scheduled Scaling. # Deploy a Container Source: https://docs.aieev.com/docs/air-container/deploy-a-container Create and deploy an Air Container Air Container supports two deployment methods: * **Deploy from a Template** — Quickly deploy using a preconfigured template. * **Create from Scratch** — Configure every deployment option manually. ## Before You Begin Regardless of the deployment method, you'll configure the following settings during deployment. | Item | Description | | - | - | | **Container Image** | The Docker image URL used to run your container. The registry provider is detected automatically from the image URL. | | **Registry Access** | Public images can be pulled without authentication. Private registries require a username and password (or access token). | | **GPU** | The GPU model assigned to the container. Available VRAM, system memory, vCPUs, and hourly pricing vary by GPU type. | | **Replicas** | The number of container replicas to run concurrently. When Autoscaling is enabled,
AirCloud automatically scales between the configured minimum and maximum values. | | **Persistent Storage** | Persistent storage that remains available even if the container is stopped or restarted.
**1 GB to 1,000 GB**, default **30 GB**. | | **Tags** | Optional labels used to organize and filter containers. | ### 1. Select a Project From the Organization Overview, open the Project where you want to deploy the container. ### 2. Start Creating a Container From the **Air Container** page, click **+ Create** in the upper-right corner. Container Eng305 ### 3. Choose a Deployment Method Select how you want to create your container. Container Deploy Eng1 | Deployment Method | Description | | - | - | | **Deploy from a Template** | Quickly deploy using a preconfigured template. The container image, ports, and environment variables are configured automatically. | | **Create from Scratch** | Configure the container image and all deployment settings manually. | *** ## Deploy from a Template ### 1. Select a Template Click **Select Template** and choose the template you want to use. Template Select Modal Eng1 After saving, the selected template is applied automatically, and the container name is initialized using the template name. You can change the container name at any time. Container Settings Eng1 ### 2. Configure Resources Expand the **Resources** section to select the infrastructure option and GPU model. Resource Select Eng2 #### Infrastructure Options | Option | Description | | - | - | | **AirCloud Zero (Spot)** | Coming soon. | | **AirCloud Plus (On-demand)** | Dedicated distributed cloud infrastructure operated by AIEEV, providing stable workloads without interruption. | #### Select a GPU Each GPU option displays its available VRAM, system memory, vCPUs, maximum number of replicas, and hourly cost (C/hr). #### Configure Replicas Replicas determine how many copies of your container run simultaneously. Adjust the desired number using the slider. Replica Config Eng When Autoscaling is enabled, AirCloud automatically adjusts the number of replicas within the configured minimum and maximum range. For more information, see [Autoscaling and Scheduled Scaling](/docs/air-container/autoscaling-and-scheduling). * Each GPU in the list shows its current availability. A GPU with no free capacity is marked as sold out and cannot be selected — use **Refresh availability** to re-check, or join the waitlist to be notified when it frees up. * The number of Replicas is limited by your organization's quota. The form shows how many you can start right now; you can request a quota increase directly from the console. * Containers with a persistent volume run on a dedicated node pool, so availability for that pool is evaluated separately. See [GPU Availability and Limits](/docs/reference/gpu-availability-and-limits) for details. ### 3. Additional Settings (Optional) When deploying from a template, **Persistent Storage** and **Advanced Settings** are preconfigured. You can modify these settings as needed. #### Persistent Storage Persistent Storage preserves your data even if the container is stopped or restarted. For more information, see [Persistent Storage](/docs/air-container/shared-storage). Advanced Settings Eng1 | Item | Description | | - | - | | **Volume Source** | **Create New Volume** creates a dedicated volume for this container. **Attach Existing Volume** shares a volume with another container. | | **Mount Path** | The directory inside the container where the volume is mounted. Default: `/workspace`. Separate several paths with commas to mount the volume at each of them. | | **Capacity (GB)** | Volume size, from **1 GB to 1,000 GB**. Default: **30 GB**. Can be increased later, but not reduced. | #### Advanced Settings Advanced Settings provide fine-grained control over container behavior. All fields are optional. Advanced Settings Eng840 | Item | Description | | - | - | | **Startup Command** | Overrides the default command defined in the container image. Leave blank to use the image default. | | **Port** | Port exposed by the application. Default: **80**. | | **Health Check URL** | Endpoint used to verify service health (for example, `/health`). | | **Metrics Path** | Endpoint used to expose application metrics (for example, `/metrics`). | | **Health Check Timeout (Seconds)** | Maximum time to wait for a health check response. Default: **300 seconds**. | | **Startup Timeout (Seconds)** | Maximum time allowed for the container to start successfully. Default: **600 seconds**. | | **Environment Variables** | Key-value pairs injected into the container at runtime. Click **+ Add** to add more variables. | | **Shared Memory (`/dev/shm`)** | Size of `/dev/shm`, for workloads that use shared memory such as a PyTorch DataLoader. Off by default, in which case **half the instance memory** applies. When on, choose between 1 GB and the instance's memory size. | | **Container ID** | Identifier for the container. Generated automatically, but you can edit it to set a fixed slug (lowercase letters, numbers, and hyphens). It becomes part of the container's public URL, which is previewed underneath. | ### 4. Create the Container Review your configuration and estimated cost (**1 Hour**, **1 Day**, and **30 Days**) in the **Deployment Summary** panel, then click **Create Container**. Enable **Deploy Immediately** to start deployment as soon as the container is created. If disabled, the container is created in the **Pending** state and can be started manually later. Containers in the **Pending** state do not incur charges. Charges begin only after the container is started. *** ## Create from Scratch ### 1. Configure the Container Name Enter a container name and optionally assign tags. Container Name Eng492 | Item | Description | | - | - | | **Name** | A descriptive name for the container. | | **Tags** | Optional labels used to organize and filter containers. | ### 2. Configure the Container Image Enter the container image URL. AirCloud automatically detects the registry provider from the image URL, but you can change it manually if needed. Image Config Eng912 | Item | Description | | - | - | | **Container Image** | URL of the container image. | | **Registry Provider** | Automatically detected from the image URL. Can be changed manually. | | **Registry Region** | Region where the image is stored. For Amazon ECR, this is detected automatically. | | **Registry Access** | **Public** images require no authentication.
**Private** registries require a username and password (or access token). | Supported registry providers: * Google Artifact Registry * Amazon Elastic Container Registry (ECR) * GitHub Container Registry * Docker Hub ### 3. Configure Resources Infrastructure options, GPU selection, Replicas, and Persistent Storage are configured in the same way as described in **Deploy from a Template**. ### 4. Configure Advanced Settings (Optional) Startup commands, ports, health checks, and environment variables are configured in the same way as described in **Advanced Settings**. ### 5. Create the Container Review the configuration and estimated cost, then click **Create Container**. *** ## Next Steps Learn how to configure Autoscaling and Scheduled Scaling. Learn how to monitor container metrics and logs after deployment. # Air Container Source: https://docs.aieev.com/docs/air-container/index Deploy and manage containerized applications Air Container is a workload that allows you to deploy and manage your own container images on AirCloud. It is ideal when you need full control over your runtime environment, dependencies, ports, environment variables, compute resources, and autoscaling behavior. ## When to Use Air Container Air Container is recommended when you need to: * Deploy your own model server or application container. * Configure GPU specifications and the number of Replicas. * Use Autoscaling together with Scheduled Scaling. * Have greater operational control than Air API provides. ## What You Can Do with Air Container Deploy container images from Docker Hub, Amazon ECR, Google Artifact Registry, GitHub Container Registry, and other registries. Start, stop, and restart containers to efficiently manage operational costs. Automatically scale containers based on traffic and configure time-based scaling schedules. Monitor GPU utilization, logs, and deployment settings to quickly diagnose issues. Connect to running containers using the Web Terminal, AirCloud CLI, or SSH. Keep your data intact even when containers are stopped or restarted. # Monitoring Source: https://docs.aieev.com/docs/air-container/monitoring Monitor container metrics and runtime logs AirCloud provides monitoring at two levels: **Project Monitoring** and **Container Monitoring**. ## Project Monitoring From the Project sidebar, open **Monitoring** to view metrics for all containers within the Project. If the Project contains multiple containers, their metrics are displayed together on the same chart with separate legends for comparison. Project Monitoring Eng942 ### Filters and Display Options | Option | Description | | - | - | | **Container** | Display metrics for a specific container only. | | **Metric** | Select the metrics to display. | | **Project / Container** | Switch between aggregated project metrics and per-container metrics. | | **Date Range** | Select the time range to view. | | **Time Interval** | Choose the aggregation interval (for example, **1 minute** or **5 minutes**). | | **Auto Refresh** | Enable or disable automatic updates. | ## Container Monitoring From an individual container page, open **Monitoring** to view detailed metrics for that container. Use the metric selector in the upper-right corner to customize the dashboard and display only the metrics you need. Runtime Endpoint Eng ### Available Metrics | Metric | Description | | - | - | | **GPU Memory Usage** | GPU VRAM usage (MiB). | | **GPU Utilization** | GPU utilization (%). | | **CPU Utilization** | CPU utilization (%). | | **Memory Usage** | System memory usage (GB). | | **Network Traffic** | Total inbound and outbound network traffic (GB). | | **Network Throughput** | Real-time network throughput (KB/s). | | **Healthy Replicas Count** | Number of currently running Replicas. | | **HTTP Requests per Second (QPS)** | Number of HTTP requests processed per second. | | **HTTP P90 Latency** | 90th percentile HTTP response latency. | | **HTTP Errors per Second** | Number of HTTP error responses per second. | | **Request Count** | Number of requests over time. | | **Total Requests** | Cumulative request count. | ### Replica Timeline The **Healthy Replicas Count** card at the top of the container's monitoring page shows when Autoscaling added or removed Replicas, alongside your other metrics. Replica Timeline Eng * **Replica count and runtime**: One card shows how the Replica count changed over the selected range and when each Replica was running. Replicas that ran only briefly appear as dots. * **Min and max guides**: The Autoscaling minimum and maximum Replica counts are drawn as dashed lines, so you can see how close you are to the limit. If Autoscaling is off, the card shows the fixed Replica count instead. * **How Replicas are scaled**: Hover the ⓘ icon on the card to see the scaling rule. With Autoscaling on, a Replica is added when each Replica is handling more than the target number of concurrent requests on average, and removed when the load drops. With Autoscaling off, a change in the Replica count may mean a restart or a failure. * **Scale markers**: Every metric chart marks the moments the Replica count changed with a vertical dashed line, so you can compare how requests, latency, GPU utilization, and other metrics changed before and after each scale event. Autoscaling decides only from the number of concurrent requests per Replica. The scale markers help you compare metrics before and after a scale event; they do not mean that the metric on that chart caused it. ### Drag to Zoom Drag across any chart to zoom every chart on the page into that range. The data is re-queried at a finer interval for the zoomed range. Click **Reset zoom** to return to the previous range. ## Container Runtime Logs From the **Runtime Logs** page of a container, you can view logs for both running and terminated Replicas. Runtime Log Eng The left panel lists the Replicas, each marked **running** or **stopped**, with when it started and stopped. Select one to display its logs. | Filter | Description | | - | - | | **Replica Search** | Quickly find a specific Replica. | | **Time Range** | Display logs within a specific time range. The view starts from the last **7 days**. | | **Keyword Search** | Search log contents using plain text or regular expressions. | | **Log Level** | Filter by Debug, Info, Warning, or Error. | | **Log Source** | Filter by standard output (`stdout`) or standard error (`stderr`). | | **View Options** | Show timestamps, show raw data, hide health-check lines, and toggle word wrap. | * Logs from both **running** and **stopped** Replicas remain viewable. * **Jump to latest** returns to the newest lines after scrolling back. * **Download** saves the selected Replica's logs, and **Download all** saves every Replica's logs at once. If a deployment fails or behaves unexpectedly, checking the runtime logs is usually the fastest way to identify the cause. Very long logs are truncated in the viewer to the most recent lines — download the file to read the whole thing. ## Related Documentation Learn how to diagnose common deployment and operational issues. Learn how Replica counts change with Autoscaling and Scheduled Scaling. # Persistent Storage Source: https://docs.aieev.com/docs/air-container/shared-storage Share persistent storage across multiple containers and replicas Persistent Storage preserves your data even when a container is stopped or restarted. Within a Project, a single volume can be shared across multiple containers or Replicas. ## What You Can Do with Persistent Storage Persistent Storage provides flexible data management across your deployments. * **Support Autoscaling**: Attach the same volume to deployments using Autoscaling and multiple Replicas. * **Create or Reuse Volumes**: Create a new volume or attach an existing one during container deployment. * **Share Across Deployments**: Attach the same volume to multiple deployments. When selecting a volume, AirCloud also shows which deployments are currently using it. * **Modify While Stopped**: Enable, disable, or replace an attached volume while the container is stopped (**READY**). * **Resize While Running**: Increase the size of a volume that is already in use, without stopping the container. * **Mount at Several Paths**: Mount one volume at more than one path inside the container. ## Usage ### Create a New Volume You can create and attach a new Persistent Storage volume during container deployment. A volume can be **1 GB to 1,000 GB**, and defaults to **30 GB**. The actual limit also depends on free space on the device your container lands on. If the requested size exceeds it, creation fails with a `VOLUME_SIZE_EXCEEDED` error — lower the size and try again. Persist Volume Eng498 ### Attach an Existing Volume You can attach a volume that is already in use by another container, allowing multiple deployments to share the same storage. When selecting a volume, AirCloud displays the deployments that are currently using it. Persist Volume Eng742 **Multiple Replicas within the same deployment can share a single Persistent Storage volume.** This works seamlessly with Autoscaling-enabled deployments. ### Mount at Several Paths **Mount Path** accepts more than one path, separated by commas — for example `/workspace, /data`. The same volume is then mounted at each of those paths inside the container. ### Resize a Volume You can increase the size of a volume that is already attached, **while the container is running**. The change applies within about a minute. A volume can only be made larger. Shrinking is not supported. ### Modify a Volume While Stopped Enabling, disabling, or replacing a volume requires the container to be stopped (**READY**). You can: * **Disable** or **re-enable** the attached volume. * **Replace** the attached volume with another one. Changes take effect the next time the container is started. # Templates Source: https://docs.aieev.com/docs/air-container/templates Deploy quickly with preconfigured container environments Templates are preconfigured container configurations for commonly used AI and ML environments. Instead of manually configuring the container image, ports, and environment variables each time, you can simply select a template to deploy your environment in just a few clicks. ## Official Templates Official templates provided by AirCloud are available from **Select Template** during container creation. The picker groups them by what you are trying to do, and you can search by name. | Grouping | Values | | - | - | | **Core workload** | PyTorch, TensorFlow, other deep learning, vLLM, Hugging Face TGI, Ollama, ComfyUI, Stable Diffusion WebUI, other serving, general workspace, other dev environment | | **Interface** | Jupyter, VS Code, or none (a serving API) | | **Variants** | What differs within the same workload and interface — for example CUDA version, Python version, or a bundled tool | Templates whose image runs `sshd` are marked as supporting **SSH access**, which works alongside Jupyter or VS Code once you register an SSH key for the container. The list of available templates may change over time. Refer to the container creation page for the latest templates. ## My Templates You can save an existing container configuration as a reusable template, allowing you to quickly deploy the same environment in future deployments. ### Save a Template 1. From the **Air Container** list, click the **⋮** menu in the upper-right corner of the container card you want to save. Template Card Eng 2. Select **Save as Template**. 3. Enter the template information and click **Save**. Template Modal Eng592 | Field | Description | | - | - | | **Template Name** | A name used to identify the template. (Required) | | **Description** | A brief description of the template. It appears on the template card in the picker. (Optional) | | **Icon** | An icon shown on the template card. | After saving, the template will appear under the **My Templates** filter during container creation. Templates are shared with all members who have access to the current Project. Only the person who created a template or a project manager can delete it, and built-in templates cannot be deleted. ## Use a Template Select a template during the image configuration step when deploying a container. 1. Click **Select Template** on the container creation page. 2. Filter by framework or search by template name. 3. Select the desired template and click **Save**. 4. Continue configuring ports, environment variables, resources, and other deployment settings. If this is your first deployment, we recommend starting with an official template to verify your environment. You can later switch to a custom container image if needed. ## Related Documentation Learn the complete deployment workflow after selecting a template. Learn how to connect to deployed containers using the Web Terminal, AirCloud CLI, or SSH. # Troubleshooting Source: https://docs.aieev.com/docs/air-container/troubleshooting Diagnose and resolve common deployment and runtime issues If you encounter issues after deploying a container, follow the steps below to identify and resolve the problem. ## Check Runtime Logs If a deployment fails or behaves unexpectedly, **Runtime Logs** are the best place to start. You can view logs in real time or download them for further analysis. ## Common Checks Before investigating further, verify the following: * The container image URL is correct. * Registry credentials are valid for private registries. * The configured port matches the application's listening port. * The startup command is correct. * The health check endpoint responds successfully. * All required environment variables are configured. ## Check the Container Status ### READY The container has been created but is not running. Click **Start Container** to run it. Containers in **READY** are not billed. ### DEPLOY FAILED Open the **Error Details** chip next to the status. It names the diagnosed cause and what to do about it — see [Deployment Error Codes](/docs/reference/error-codes) for the full list. The dialog also links straight to the container's runtime logs. Common causes include: * Invalid container image URL. * Registry authentication failure. * Invalid startup command. * Requested resources exceeding what the device can provide. Containers in **DEPLOY FAILED** are not billed. ### UNHEALTHY The container is running but failing its health checks. **Error Details** is available here too. Common causes include: * Application startup failures. * Incorrect port configuration. * Invalid health check configuration — for a slow-loading model, raise the health check timeout. Containers in **UNHEALTHY** are not billed. ## Container Won't Start If the container stays in **READY** or takes a long time to deploy, the GPU may have no free capacity. Check the availability badge on the GPU, and see [GPU Availability and Limits](/docs/reference/gpu-availability-and-limits) — you can join the waitlist or pick another GPU. ## Modify Container Settings Most container settings require the container to be stopped. Exceptions are the container name, the replica count, and the persistent volume size, which can be changed while it runs. Before applying configuration changes, we recommend checking the current deployment status and endpoint health. ## Related Documentation Learn how to deploy containers and configure deployment settings. Learn how to configure Autoscaling and Scheduled Scaling. Contact the AirCloud team if the issue persists. # Use aircloud CLI Source: https://docs.aieev.com/docs/air-container/use-aircloud-cli Install and use the aircloud CLI for container operations The `aircloud` CLI lets you inspect endpoints, open container shells, connect over SSH, and manage local CLI configuration. ## Install the CLI ```bash theme={null} pip install aircloud-cli ``` ## Verify installation ```bash theme={null} aircloud --help ``` Expected commands include: * `config` * `endpoints` * `exec` * `ssh` * `whoami` ## Configure the CLI ### Common commands ```bash theme={null} aircloud config set aircloud config get aircloud config list aircloud config --help ``` ### Initial setup ```bash theme={null} aircloud config set api-base-url https://external.aieev.cloud:5000 aircloud config set api-key sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx aircloud config list ``` The CLI stores configuration in `~/.aircloud/config.json`. ## Check authentication context ```bash theme={null} aircloud whoami ``` Example output: ```json theme={null} { "organization_id": "org-xxxxxxxxx", "project_id": "proj-yyyyyyyy", "api_key_id": "123456fs-4fb4-455a-b951-612df2acaafc", "user_id": "abc123da-85c3-4a46-asbb-4egfgc4df187", "authenticated_via": "api_key" } ``` ## Inspect and manage endpoints ### Available commands ```bash theme={null} aircloud endpoints list aircloud endpoints get aircloud endpoints start aircloud endpoints stop aircloud endpoints scale aircloud endpoints patch aircloud endpoints replicas aircloud endpoints logs ``` ### List endpoints ```bash theme={null} aircloud endpoints list aircloud endpoints list --search jupyter --active aircloud endpoints list --page 2 --size 20 ``` ### Get endpoint details ```bash theme={null} aircloud endpoints get ``` ### Start, stop, and scale ```bash theme={null} aircloud endpoints stop aircloud endpoints start aircloud endpoints scale --replicas 3 ``` ### Patch a stopped endpoint ```bash theme={null} aircloud endpoints patch --command "python main.py --port 8080" aircloud endpoints patch --port 8080 aircloud endpoints patch --health-check-path /healthz --health-check-timeout 30 aircloud endpoints patch --env MODEL_NAME=llama3 --env CUDA_VISIBLE_DEVICES=0 ``` Patching is supported only when the endpoint is stopped. ### Check replicas ```bash theme={null} aircloud endpoints replicas ``` ### View logs ```bash theme={null} aircloud endpoints logs aircloud endpoints logs --replica-id aircloud endpoints logs --start-line 1 --end-line 500 aircloud endpoints logs --list-files ``` ## Open a shell with `aircloud exec` `aircloud exec` opens an interactive shell inside a running container without requiring `sshd`. ### Open a shell ```bash theme={null} aircloud exec ``` ### Pin to a replica ```bash theme={null} aircloud exec -r ``` ### Use a different shell ```bash theme={null} aircloud exec -c "/bin/sh" ``` ### End the session Type `exit` or press `Ctrl + D`. ## Use `aircloud ssh` For SSH-based access workflows, use `aircloud ssh`. Read [Connect with SSH](/docs/air-container/connect-with-ssh) for image preparation, SSH key registration, and examples. # Using the Web Terminal Source: https://docs.aieev.com/docs/air-container/use-web-terminal Access running custom containers directly from the AirCloud Console The Web Terminal lets you connect to a running container through a browser-based shell directly from the AirCloud Console. It is ideal when you need quick operational access without configuring `sshd`, registering SSH keys, or setting up a local terminal. ## When to Use the Web Terminal The Web Terminal is recommended when you want to: * Open a shell directly from the Console. * Quickly inspect files or running processes inside a container. * Run lightweight verification or debugging commands. * Avoid configuring SSH access. ## Availability ### Custom Containers For custom containers deployed by users, click **Terminal** from the endpoint overview page while the container is running. Terminal1 ### AirCloud Templates Some AirCloud-provided templates include their own built-in terminal interface. Examples include: * Notebook environments opened with **Open Notebook** * Web-based IDE environments Jupyter Notebook Terminal2 In these cases, you can use the terminal already provided within the notebook or IDE without opening the **Terminal** button on the endpoint page. ## How the Web Terminal Works ### 1. Open the Terminal From the endpoint overview page, click **Terminal**. ### 2. Enable Terminal Access The first time you open the terminal for an endpoint, an activation dialog appears before the session starts. This enables browser-based terminal access for the endpoint without requiring an `sshd` configuration. Enable Terminal Access Once terminal access has been enabled, you will not be prompted again unless the endpoint's access policy is reset. ### 3. Select a Replica After terminal access has been enabled: * If there is **one running Replica**, the session connects automatically. * If there are **multiple running Replicas**, you are prompted to choose which Replica to connect to. Select Replica If the selected Replica is restarted or replaced while the session is active, the Web Terminal automatically attempts to reconnect. ### 4. Connect to the Replica After selecting a Replica, a browser-based terminal session is opened for that Replica. Image 4 ### 5. End the Session You can close the session by: * Running `exit` * Pressing `Ctrl + D` After the session ends, the terminal window automatically closes after approximately **2 seconds**. Image 5 ## If the Web Terminal Does Not Open Check the following: * The endpoint is running. * At least one Replica is running. * You have permission to access the endpoint. If no running Replica is available, the terminal cannot be opened until a Replica becomes available. ## Using `aircloud exec` from a Local Terminal If you prefer SSH-free shell access from your local terminal instead of the AirCloud Console, use `aircloud exec`. ### Open a Shell ```bash theme={null} aircloud exec ``` Example: ```bash theme={null} aircloud exec 7fe76055-4159-47a5-a68d-320564e20540 ``` ### Connect to a Specific Replica ```bash theme={null} aircloud exec -r ``` ### Use a Different Shell ```bash theme={null} aircloud exec -c "/bin/sh" ``` ### End the Session Run `exit` or press `Ctrl + D` to close the session. ## Web Terminal vs. `aircloud exec` Both **Web Terminal** and **`aircloud exec`** provide SSH-free shell access to running containers. The difference is where you start the session: * **Web Terminal** starts from the AirCloud Console. * **`aircloud exec`** starts from your local terminal. # Account Settings Source: https://docs.aieev.com/docs/console/account Manage your profile, password, and email preferences **Account Settings** covers the settings that belong to you personally, not to the Organization. Open it from your profile in the console header. ## Profile Name The first and last name shown across the console and in notification emails. ## Password Enter your current password, then set a new one. | Requirement | Value | | :- | :- | | Length | At least 8 characters | | Composition | At least 2 of: letters, numbers, special characters | After the password changes, every device — including the one you are on — is signed out shortly afterward. Sign in again with the new password. If you signed up through social login (for example GitHub), there is no AirCloud password to change. Manage it on that service instead. ## Email Preferences Choose whether to receive marketing email about new features, promotions, and events. The change is saved immediately. This is separate from notification email. Which product notifications reach your inbox is configured on the [Notifications](/docs/console/notifications) page, and transactional email — invitations, receipts, and invoices — is always sent. ## Account Withdrawal Withdrawing permanently deletes your account and removes your data from the organizations and projects you belong to. If you are the last Owner of your Organization, withdrawing **also deletes the Organization**. To keep it, transfer ownership to another member first. See [Deleting an Organization](/docs/console/organization-deletion). ## Related Documentation Choose what you get notified about, and where. What has to be settled first, and what is removed. # Air Assistant Source: https://docs.aieev.com/docs/console/air-assistant Ask questions in the console and get answers from the docs and your own account Air Assistant is an AI assistant built into the AirCloud console. Ask how a feature works or what a concept means, or check your own account in plain language: which GPUs are available right now, which endpoints are running, how much you have used this month. Answers are grounded in the official AirCloud documentation and in the account and organization data the signed-in user is allowed to access. Air Assistant is a **beta** feature. It is currently **read-only**: it does not change resources, such as deploying, stopping, or deleting a container. ## Getting Started 1. Click the **Air Assistant** button in the console header. 2. The first time, a data handling notice appears. Read it, tick **I have read the above and agree to use the Air Assistant beta**, and click **Agree and continue**. 3. The Air Assistant panel opens on the right. Pick a suggested question or type your own. When you open the panel for the first time, you see suggested questions such as: * Show me the endpoints that are currently running * Which GPUs are available right now, and at what price? * Summarize this month's usage and credits * Explain how Autoscaling works ## What It Can Do | Area | Example questions | Answered from | | :- | :- | :- | | **Docs and how-tos** | "How does Autoscaling work?"
"Where do I create an Air API key?" | The official AirCloud docs. Links to the pages used in the answer are shown with it. | | **GPU lookups** | "Which GPUs are available right now, and at what price?"
"Is an RTX 5090 available now?" | GPU catalog, prices, and real-time availability | | **Endpoint and container lookups** | "Show me the endpoints that are currently running"
"How many replicas does my-api have?" | Endpoint lists, details, and replica status for projects you can access | | **Usage and credit lookups** | "Summarize this month's usage and credits"
"Show me the latest invoice" | Credit balance, usage summary, and invoice list | Below each answer, related follow-up questions appear as buttons. Clicking one sends that question right away. List results show 10 items by default and up to 20. ## Not Supported Yet During the beta, the following are not supported: * Creating, editing, stopping, or deleting resources (deploy, restart, change replicas, and so on). The assistant can explain how to do them, but you run them in the console yourself. * Monitoring metrics, log analysis, and root-cause diagnosis * Storage and template lookups * Detailed cost breakdowns by period or resource, and configuration change history * Connecting from external agents (Claude, Cursor, and others) over MCP ## Using the Panel | Button | What it does | | :- | :- | | **New conversation** (+) | Clears the current conversation and starts a new one. | | **Export** (↓) | Downloads the current conversation as a file. | | **Expand / Collapse** | Widens the panel or returns it to the default size. | | **Close** (×) | Closes the panel. | The beta does not yet reopen past conversations. If you want to keep a conversation, save it with **Export** (↓). ## Data Handling and Permissions Review the following before using Air Assistant. It is the same information shown on the first-use consent screen. | Item | Details | | :- | :- | | **Access scope** | To answer your questions, it reads account and organization data you have permission to see. It does not access other organizations or projects you cannot see in the console, and it does not read secrets such as API keys. | | **Retention** | Prompts and answers are kept for **30 days** by default, to provide and improve the service. | | **Processing model** | Your input is sent to and processed by Air API models served by AirCloud. | | **Training use** | Your input may be used to train and improve the models and the service. | | **Opt-out and withdrawal** | You can decline or withdraw your consent to use the assistant and to optional data use. To withdraw, [contact us](/docs/support/contact-and-feedback). | AI answers can be inaccurate or wrong. Double-check anything important, such as costs, payments, and resource status, on the corresponding console screen. Do not enter sensitive information such as passwords, API keys, or personal data. ## Getting Better Answers * **Be specific about the target.** "The endpoints in project bs-proj" works better than "my endpoints". Include the project or endpoint name. * **Ask one thing at a time.** Split several questions into separate messages rather than combining them in one sentence. * **Start a new conversation when the topic changes.** Earlier context can affect the answer to a new question. * **If no answer arrives,** resend after a moment or ask again in a new conversation. ## Related Learn what drives replicas up and down. Understand availability indicators, sold-out GPUs, and replica limits. Check credits, payments, and invoices in the console. # Billing Source: https://docs.aieev.com/docs/console/billing Manage credits, payment methods, Auto Top-up, invoices, and payment history All billing and credit management features are available from **Organization → Billing**. ## Billing Overview All usage and charges generated by Projects are aggregated and billed at the Organization level. Services can be used as long as your Organization has sufficient credits. AirCloud bills in **credits**, displayed with the unit **C**. For organizations in the KRW region, **1 C equals KRW 1 of supply price (before VAT)**. Organizations in the USD region see the same balance converted to USD at the current exchange rate. All AirCloud services deduct usage from your credit balance. Purchase credits * Credits are used for all AirCloud services, including API requests, GPU instances, and storage. * Credit purchases are subject to **10% VAT**, in accordance with applicable tax regulations. * A single purchase must be between **10,000 C** and **10,000,000 C**. * When your credits are exhausted, an email notification is sent. If credits are not replenished, running workloads may be terminated. * To avoid service interruptions, we recommend enabling **Auto Top-up**. Billing and Credits ## Purchase Credits AirCloud supports the following payment providers for purchasing credits: * **Toss Payments** — Prepaid credits (Korea) * **PayPal** — Prepaid credits (Global) * **Stripe** — Prepaid credits and saved payment methods for Auto Top-up (Global) ## Payment Methods Register a payment card to use **Auto Top-up**. Saved payment methods can also be reused for future credit purchases without entering card details again. You can register multiple payment methods and choose which one is used for Auto Top-up. Payment Method Eng ## Auto Top-up Auto Top-up automatically purchases credits when your remaining balance falls below a specified threshold. Payments are charged automatically using your selected payment method, allowing you to maintain sufficient credits without manual intervention. Auto Top Up Eng Configure the following settings: * **Threshold** — Remaining credit balance that triggers Auto Top-up. * **Top-up Amount** — Amount of credits to purchase automatically. * **Payment Method** — Saved payment method used for automatic billing. ## Low Credit Notifications Email notifications can be sent to Organization Owners when the remaining credit balance falls below a configured threshold. Unlike Auto Top-up, this feature **does not automatically purchase credits**. It simply notifies Organization Owners so they can manually add credits. Email Alert Eng * **Threshold** — Remaining credit balance that triggers the notification. * **Recipients** — Organization Owners. Low credit notifications send email alerts only. They do not automatically purchase credits. ## Invoices Invoices are available for Organizations using **Postpaid Billing** and are intended primarily for enterprise customers. Invoices are generated automatically at the end of each month based on the total unpaid usage accumulated during the billing period. Generated invoices are available from **Organization → Billing → Invoices**, where you can: * View invoice status. * Download PDF invoices. * Complete invoice payments. ### Invoice Fields | Column | Description | | :- | :- | | **Billing Period** | Billing period covered by the invoice. | | **Status** | Current invoice payment status. | | **Total Credits** | Total credits included in the invoice. | | **Amount Due** | Total amount to be paid. | | **Due Date** | Invoice payment deadline. | | **Pay** | Pay an unpaid invoice. | | **Download** | Download the invoice as a PDF. | ### Invoice Status | Status | Description | | :- | :- | | **Pending** | Invoice has been issued but not yet paid. | | **Paid** | Invoice has been paid successfully. | | **Overdue** | Payment deadline has passed. | | **Canceled** | Invoice has been canceled. | ## Payment History The **Payment History** page displays all credit purchases, promotional credits, Auto Top-up transactions, and invoice payments. ### Payment History Fields | Column | Description | | :- | :- | | **Date** | Payment date and time. | | **ID** | Unique payment identifier. | | **Type** | Payment type. | | **Status** | Payment processing status. | | **Amount** | Amount paid. | | **Credits** | Credits granted or purchased. | | **Receipt** | Download the payment receipt (when available). | Payments are categorized as **Pending**, **Completed**, **Failed**, or **Canceled**. Receipts are available for completed payments. ### Payment Types | Type | Description | | :- | :- | | **Credit Purchase** | Purchase of credits. | | **Promotion Code** | Credits granted through a promotion code. | | **Auto Top-up** | Credits automatically purchased through Auto Top-up. | | **Invoice Payment** | Payment made toward an invoice. | Payment history can be filtered by **Type**, **Status**, and **Date Range**, and sorted by **Date**, **Amount**, or **Credits**. ## Promotion Codes Promotion codes distributed through events, partnerships, or promotional campaigns can be redeemed from **Billing → Promotion Codes**. Promotion Code Eng Once redeemed successfully, credits are added automatically. The transaction appears in **Payment History** with the **Promotion Code** payment type. ## Cancelling a Payment and Refunds A card payment for credits can be cancelled from the console **as long as none of the credits it granted have been used**. Cancelling refunds the **full amount including VAT** to the original payment method and immediately reclaims the granted credits (bonus included). For payments that meet the conditions below, there is no time limit after the payment. A payment can be cancelled when all of the following hold: * The payment status is **Completed** and the type is **Credit Purchase** or **Auto Top-up**. * It was paid by card or PayPal. Auto top-up charges made with a saved card are included. * **The person who made the payment** cancels it. A payment made by another member can only be cancelled by that member. * **None** of the credits granted by that payment have been used. Any usage at all makes it non-cancellable. * Your balance was not negative at the time of payment. When you top up while the balance is negative, part of the payment settles the outstanding amount, so the payment cannot be cancelled even if you never used the new credits. The following cannot be cancelled from the console: * Payments whose granted credits have been used, even partially. * Payments made while the balance was negative, where part of the amount settled outstanding usage. * Credits granted for free — promotion codes, signup credits, survey rewards. They have no payment behind them, so they are never refunded in cash, and credits that carry an expiry date are removed automatically once it passes. * Invoice payments. * Credits added by a recurring contract — they are settled offline by contract or invoice, so no payment record exists in the console. Contact us for cancellation or a refund. * Long-term rentals — they are not cancelled through this flow. A rental that has not started yet can be cancelled from [Long-term Rentals](/docs/console/long-term-rentals), which also covers the cancellation and refund terms. * Older payments with no credit grant record. If a payment is marked as not cancellable, [contact us](/docs/support/contact-and-feedback). ### How to cancel 1. Open **Billing → Payment History** and click **Payment Cancellation**. 2. Select the payments to cancel. Payments that cannot be cancelled are dimmed; hover to see why. 3. Choose a reason, review the amount, and click **Confirm**. Once processed, the payment status changes to Canceled and your credit balance drops by the reclaimed amount. When the refund appears on your card statement depends on the card issuer. ### Disputes and taxes Billing disputes must be submitted **within 15 days** of receiving the invoice. If no dispute is raised during this period, the invoice is considered accepted. Service fees are exclusive of applicable taxes. Customers are responsible for all taxes, duties, and fees other than AIEEV's corporate income tax. For detailed terms, see the [**Terms of Service**](https://www.aieev.com/termsofservices) or [Contact](https://www.aieev.com/contact) the AirCloud support team. ## Related Documentation Learn how to manage members, usage, reserved instances, and organization settings. Contact the AirCloud team or submit product feedback. # Desktop Notifications Source: https://docs.aieev.com/docs/console/desktop-notifications Receive Air Cloud alerts on your operating system Air Cloud can deliver critical alerts as native OS notifications, so you don't have to keep the console tab open to catch them. This guide walks you through enabling desktop notifications in your browser, your operating system, and the Air Cloud console. Only a limited set of high-priority events trigger OS notifications today — for example, **endpoint deployment failures** and **service announcements**. Other in-app notifications (balance updates, member events, etc.) appear in the notification popover but do not pop up on your desktop. ## How It Works Desktop notifications use the browser's native [Web Notifications API](https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API). For an alert to reach you, three independent permissions must all be granted: 1. **Browser permission** — granted per browser, per device. 2. **Operating system permission** — granted to the browser at the OS level. 3. **Air Cloud preference** — a toggle on the console's **Notifications → Settings** tab. If any one of the three is off, no desktop popup will appear. Note that notifications are delivered while the browser is running; if you fully quit the browser, you will not receive new desktop alerts until you return to the console. ## Enabling Notifications in the Console Open **Notifications → Settings** in the console and turn on the **Desktop** channel for the events you want. The first time you enable it, your browser will prompt you to allow notifications from Air Cloud. The settings tab is a matrix of events by channel, so you can pick exactly which events reach your desktop. See [Notifications](/docs/console/notifications) for the full list. Click **Allow** in the prompt. If you accidentally clicked **Block**, the browser will not ask again — see [Re-enabling a Blocked Permission](#re-enabling-a-blocked-permission) below. The toggle state is stored per browser, per device. If you switch laptops or browsers, you'll need to enable it again. ## Allowing Notifications at the OS Level Even with the browser permission granted, your operating system can silently suppress notifications. Make sure your browser is allowed to deliver them. ### macOS 1. Open **System Settings → Notifications**. 2. Find your browser (Chrome, Safari, Edge, etc.) in the list. 3. Turn **Allow notifications** on. 4. Confirm that **Focus** or **Do Not Disturb** is not active. ### Windows 1. Open **Settings → System → Notifications**. 2. Locate your browser under **Notifications from apps and other senders**. 3. Toggle it **On**. 4. Make sure **Focus assist** / **Do not disturb** is off. ## Re-enabling a Blocked Permission If you previously chose **Block** in the browser prompt, the Air Cloud console cannot ask again. Re-enable the permission in the browser's site settings. * **Chrome / Edge**: Click the lock icon in the address bar → **Site settings** → set **Notifications** to **Allow**. * **Firefox**: Click the lock icon → **Connection secure** → **More information** → **Permissions** → uncheck **Block** for Notifications. * **Safari**: **Safari → Settings → Websites → Notifications** → set the Air Cloud entry to **Allow**. After updating the permission, reload the Air Cloud console and toggle **Desktop notifications** off and on once to re-bind the permission. ## Troubleshooting * **The toggle keeps reverting to off.** The browser permission is most likely set to **denied**. Reset it from site settings as described above. * **Toggle is on, but no popups appear.** Check the OS-level setting and any Focus / Do Not Disturb mode. On macOS, Screen Sharing and presentation modes also suppress notifications. * **I get in-app notifications but no desktop popups.** This is expected for events that are not high-priority. See the note at the top of this page. * **Safari shows nothing.** Older Safari versions only deliver web notifications to installed PWAs. Use Chrome, Edge, or Firefox if you need desktop alerts on macOS. ## Supported Events | Event | Type | Desktop notification | | - | - | - | | Endpoint deployment failed | `ENDPOINT` | Yes | | Service announcement | `ANNOUNCEMENT` | Yes | | Balance credited / consumed | `BALANCE` | In-app only | | Member invited / joined | `MEMBER` | In-app only | | Other endpoint events | `ENDPOINT` | In-app only | We expand the list of desktop-eligible events over time. All events remain visible in the in-app notification popover regardless of OS delivery. # Long-term Rentals Source: https://docs.aieev.com/docs/console/long-term-rentals Reserve the GPUs you use regularly at a lower hourly rate A **long-term rental** secures the GPUs you use regularly for a fixed term, starting from one month. While a rental is running, containers on the same GPU are already paid for up to the rented quantity, so no usage charges are added on top. Longer terms come with a lower hourly rate, so the longer you rent, the less it costs overall. Rentals belong to the **Organization**, so any Project under it can share them. Open **Organization → Long-term Rentals** to view and manage them. A rental pays for usage up front — it does not deploy anything for you. You still create and start containers exactly as you normally would. When a running container matches an active rental, the rented quantity runs at no extra cost; anything beyond that quantity is billed as on-demand usage. ## Key Terms | Item | Value | | :- | :- | | **Minimum term** | 1 month | | **Term presets** | 1 month, 2 months, 3 months, 6 months, 1 year, or a custom period | | **Discount** | The longer the term, the lower the hourly rate. The best-value terms are marked **Best value**. | | **Payment** | The full amount for the entire term is deducted from your credits at once when the rental is confirmed. | | **Scope** | Organization-wide — shared across all Projects. | | **Time zone** | All rental times are in KST (Korea Standard Time). | ## Request a Rental Renting directly from the console will open once capacity is ready. Until then, use **rental inquiry** from the same page. 1. Open **Organization → Long-term Rentals** and start a rental. 2. Choose the **GPU**, the **quantity**, and the **term**. 3. Choose whether the rental is for containers **with** or **without** a persistent volume. 4. Review the summary — hourly rate, discount, and total — then submit. After you submit an inquiry, our team checks availability and contacts you within **1 business day**. No payment is taken at that step, and you can withdraw the request at any time while it is in the **Requested** state. The persistent-volume setting on a rental must match how the container is actually deployed. Containers with a persistent volume run on a dedicated node pool, so a rental taken without a volume will not apply to them — and the usage is billed again on top. ### When a Rental Becomes a Request Even when you rent directly, some cases cannot be confirmed on the spot and are submitted as a request instead: | Situation | What happens | | :- | :- | | Not enough free capacity for the period | Only part of the quantity can be confirmed. You can lower the quantity and rent now, or submit the rest as a request. | | Availability cannot be verified | Confirming without that check could leave you without the devices, so our team verifies first. | | Not enough credits (postpaid organizations) | The rental is handled by invoice instead. | For prepaid organizations, if your credit balance falls short at checkout you can add credits inside the same dialog and complete the rental without leaving the page. ## Status | Status | Description | | :- | :- | | **Requested** | An inquiry has been submitted and our team is reviewing it. | | **Scheduled** | The rental is confirmed but has not started yet. | | **Active** | The rental is running and applies to matching containers. | | **Expired** | The rental term has ended. | | **Cancelled** | The rental was cancelled. | The list shows the GPU, quantity, period, hourly rate, amount paid, and days remaining for each rental. ## Cancellation and Refunds * **Before the rental starts** — cancel at any time and the full amount is refunded as credits. * **After the rental starts** — you cannot cancel it yourself. Contact us through the [Contact and Feedback](/docs/support/contact-and-feedback) page. ## Notifications You are notified at the following points. Start and expiry notifications are also delivered by email. * Rental completed * Rented resource started * Rented resource expiring soon * Rented resource expired See [Notifications](/docs/console/notifications) to configure which channels you receive them on. ## Related Documentation Manage members, usage, and organization settings. Purchase credits, configure Auto Top-up, and manage invoices. # Notifications Source: https://docs.aieev.com/docs/console/notifications Choose what you get notified about, and where AirCloud delivers notifications in real time, so you do not have to refresh the page to notice that a deployment finished or that your balance is running low. Open **Notifications** in the console. It has two tabs: * **History** — everything you have received, newest first, with unread items highlighted. * **Settings** — a matrix of events by channel, where you choose what reaches you and how. ## Channels | Channel | Description | | - | - | | **Console** | The in-app notification list, opened from the bell in the console header. Notifications are kept for **30 days** and then disappear automatically. | | **Desktop** | Native OS notifications delivered by your browser. Requires browser permission and is stored per browser, per device. See [Desktop Notifications](/docs/console/desktop-notifications). | | **Email** | Sent to the Organization Owner by default. Waitlist and request emails go to the requester, and invitations go to the invitee. | Turning the Console channel off for an event also stops its Desktop notification — the desktop popup is driven by the same in-app notification. Turning a channel off applies to notifications that arrive afterward. Notifications you already received stay in the list. ## What You Can Be Notified About ### Container | Event | Console | Email | Notes | | :- | :-: | :-: | :- | | Container deployed | ✅ | — | Only for a first successful deploy, or a previously failed deploy succeeding. Restarts and self-recovery are not notified. | | Container deploy failed | ✅ | Owner | | | Container unhealthy | ✅ | Owner | | | Autoscaling applied | ✅ | — | Sent once replicas actually reach the target count. Repeated adjustments in a short window are collapsed into one — the window is configurable. | | Waitlisted GPU capacity available | ✅ | Requester | | | Replica limit increase approved | ✅ | Requester | | ### Long-term Rentals | Event | Console | Email | Notes | | :- | :-: | :-: | :- | | Rental completed | ✅ | — | | | Rented resource started | ✅ | Owner | | | Rented resource expiring soon | ✅ | Owner | How many days ahead to notify is configurable. | | Rented resource expired | ✅ | Owner | | ### Credit and Billing | Event | Console | Email | Notes | | :- | :-: | :-: | :- | | Credit topped up | ✅ | Owner | | | Auto top-up succeeded | ✅ | Owner | | | Recurring payment credited | ✅ | Owner | | | Auto top-up failed | ✅ | Owner | | | Payment failed | ✅ | — | | | Low balance warning | ✅ | Owner | Sent only when low balance alerts are enabled with a threshold in organization settings. | | Containers suspended (out of credit) | ✅ | Owner | | | Postpaid invoice issued | — | Owner | An email with the PDF statement is sent. No console notification is created. | | Invoice overdue | ✅ | — | | ### Members | Event | Console | Email | Notes | | :- | :-: | :-: | :- | | Member joined | ✅ | — | | | Member left | ✅ | — | | | Organization invitation | — | Invitee | The invitation link is emailed to the invitee. No console notification is created. | ### Announcements and Requests | Event | Console | Email | Notes | | :- | :-: | :-: | :- | | Service announcements | ✅ | — | Maintenance and incidents. | | Request received | ✅ | Requester | | | Request outcome | ✅ | Requester | | | Reply to my feedback | ✅ | Requester | | Transactional email — invitations, receipts, and invoices — is always sent, regardless of these settings. ## Organization-wide Mute An Organization Owner or Admin can turn off notifications for the whole organization. While it is off, no member receives in-app notifications, announcements, or notification email from that organization, and individual settings have no effect. Transactional email still goes out. Detailed per-event settings can only be changed by an Organization Owner or Admin. ## Related Documentation Turn on native OS notifications in your browser and operating system. Configure low balance alerts and Auto Top-up. # Organization Management Source: https://docs.aieev.com/docs/console/organization Manage members, usage, long-term rentals, and organization settings An **Organization** is the top-level management unit in AirCloud. Members, Projects, usage, and billing are all managed at the Organization level. * Create separate Projects for **API testing** and **production workloads**. * Define member roles and project access permissions to keep your organization secure. * Regularly review usage and billing to avoid unexpected costs. * Verify your available credits and billing status before deploying workloads. ## Invite Members You can invite members to your Organization and assign roles. Permissions are determined by each member's assigned role. Member Eng | Role | Description | | :- | :- | | **Owner** | Full administrative access to the Organization, including member management, billing, credits, and creating or deleting Projects. | | **Member** | Can access assigned Projects and use AirCloud services, but cannot modify Organization settings or access billing features. | To invite a member: 1. Open the **Members** tab in the Organization page. 2. Click **+ Invite** in the upper-right corner. Invite Members Then complete the following steps: 1. **Email Address** — Enter the email address of the member to invite. Multiple email addresses can be entered, separated by commas. 2. **Role** — Select either **Owner** or **Member**. 3. **Project Access** — Choose which Projects the member can access. You can grant access to all Projects or select individual Projects. 4. **Send Invitation** — Click **Invite** to send an invitation email. * **Each AirCloud account can belong to only one Organization.** Members who already belong to another Organization cannot be invited. * The invited user must register using the same email address that received the invitation. * If the invited user is already signed in to another account, they should sign out before accepting the invitation to avoid authentication issues. ## Usage Management ### Usage Image The **Usage** page provides an overview of your Organization's spending over time. Container and API usage is measured every 10 minutes; actual credit deductions are available on the **Settlement** tab. #### View Options Expand **Options** at the top of the page to configure the following: | Option | Description | | :- | :- | | **Date Range** | Set a custom start and end date, or pick a preset — **Today, 7D, 1M, 3M, 6M, 1Y, or All time**. | | **Granularity** | Aggregate the chart and table by **Daily** or **Monthly**. | | **Service** | Filter by **All**, **Air Container**, or **Air API**. | | **Unused Items** | Choose whether to **Include** or **Exclude** items with no usage in the results. | #### Summary Cards | Card | Description | | :- | :- | | **TOTAL SPEND** | Total spend across the selected period. | | **ON DEMAND** | Cost from on-demand GPU usage. | | **RESERVED** | Cost from long-term rental usage. | | **API CALL** | Cost from Air API calls. | #### Usage Trend The chart displays Air Container and Air API usage cost, excluding RESERVED cost. The table below breaks down usage by Organization for each day (or month) in the selected range. ### Settlement Image The **Settlement** page records the credits actually **deducted or credited** to your Organization. While Usage shows cost measured every 10 minutes, Settlement reflects how that usage was actually billed. #### View Options | Option | Description | | :- | :- | | **Date Range** | Set a custom start and end date, or use a preset (Today, 7D, 1M, 3M, 6M, 1Y, All time). | | **View Unit** | Choose **Organization**, **Project**, or **Container**. Selecting Project or Container reveals a tag list to filter down to specific items. | | **Unused Items** | Choose whether to **Include** or **Exclude** items with no usage. | | **Usage Type** | Options depend on the selected View Unit

\* **Organization**: Reserved / On Demand / API Call
\* **Project**: On Demand / API Call
\* **Container**: On Demand. | | **Transaction Type** | Filter by **All**, **Deposit**, or **Withdrawal**. | To see how much a specific container cost, set **View Unit** to **Container**. Deleted containers are included, which is useful for historical cost analysis. #### Aggregate View vs. Item View Use the toggle in the upper-right to switch between two ways of viewing Settlement data. | View | Description | | :- | :- | | **Aggregate View** | Groups transactions by type — RESERVED, ON DEMAND, and API CALL. Each group is collapsible and includes a totals row. | | **Item View** | Lists individual transactions recorded at 10-minute intervals. Each row can be expanded to show detailed billing information. | **Aggregate View columns** | Group | Columns | | :- | :- | | **RESERVED** | Payment Date, GPU Model, Quantity, Applied Period, Amount, Status | | **ON DEMAND** | Organization, GPU Type, Usage Time, Amount | | **API CALL** | Organization, Model, Calls, Tokens, Amount | **Item View columns** | Column | Description | | :- | :- | | **Payment Date** | Time the transaction was deducted or credited. | | **Type** | Transaction type (Deposit or Withdrawal). | | **Usage Type** | Billing type, such as On Demand, Reserved, or API Call. | | **Interval** | Billing period for the transaction (for example, `2026-07-22 11:20:00 ~ 2026-07-22 11:30:00`). | | **Credits** | Credits deducted or granted for the interval. | Click the chevron on a row to expand its detail and see the fields below. Image | Detail Field | Description | | :- | :- | | **GPU** | GPU model used. | | **Interval** | The 10-minute billing interval. | | **Hourly Rate** | Hourly rate for the GPU. | | **Job Type** | Workload type (for example, `SERVE_REPLICA`). | | **Amount** | Credits deducted for the interval. | | **Raw Description** | Original description recorded by the billing system. | #### Export Settlement Data Click **Export** in the upper-right corner to download the filtered Settlement data. You can configure: * **Date Range** * **Columns** (including custom column order) * **File Format** (`CSV`, `JSON`, or `TXT`) Exporting a large number of transactions may take several minutes. ## Long-term Rentals A **long-term rental** secures the GPUs you use regularly for a fixed term, starting from **one month**. While a rental is running, containers on the same GPU are already paid for up to the rented quantity, so no usage charges are added on top, and longer terms come with a lower hourly rate. Rentals belong to the Organization and are shared across all its Projects. Manage them from **Organization → Long-term Rentals**. Terms, discounts, payment, status, cancellation, and how a rental applies to your containers. ## Organization Settings The **Organization Settings** page allows Organization Owners to manage basic organization information, billing methods, and payment methods. Changes take effect only after clicking **Save**. | Field | Description | | :- | :- | | **Organization Name** | Name used to identify the Organization. | | **Description** | Brief description of the Organization. | | **Billing Method** | Prepaid or Postpaid. | | **Payment Method** | Registered payment method used for credits or invoices. | | **Organization ID** | Unique identifier assigned when the Organization is created. This value cannot be changed. | AirCloud uses a **prepaid** billing model by default. **Postpaid** billing is available for selected enterprise customers. | Billing Method | Description | | :- | :- | | **Prepaid** | Purchase credits in advance and consume them based on usage. | | **Postpaid** | Use the service first and receive an invoice according to the billing cycle. | For Postpaid billing, available credits are consumed first. Once the balance becomes negative, usage continues to accumulate as a negative balance. At the end of each month, an invoice is automatically generated for the outstanding amount. After payment is completed, the balance is reset to zero. Enabling **Automatic Payment** allows invoices to be paid automatically using the registered payment method. ## Related Documentation Learn how to purchase credits, configure Auto Top-up, and manage invoices. Contact the AirCloud team or submit product feedback. # Deleting an Organization Source: https://docs.aieev.com/docs/console/organization-deletion What must be settled first, and what is removed An Organization Owner can permanently delete the Organization from **Organization → Settings**. Deleting terminates every container, cleans up the Organization's resources, and removes all members' access. Deletion cannot be undone. ## Before You Can Delete The console checks a set of conditions first. While any of these apply, deletion is blocked and the screen tells you what to do. | Blocker | How to clear it | | :- | :- | | **Outstanding balance** | Settle the negative balance from the Billing page. | | **Unpaid invoices** | Pay the outstanding invoices. | | **Active or scheduled long-term rentals** | Wait for them to end, or cancel the ones that can still be cancelled. | | **Postpaid billing** | Postpaid organizations are deleted after settlement — send an inquiry. | | **Suspended organization** | A suspended organization can be deleted once the suspension is lifted — send an inquiry. | | **Dedicated cluster** | Deleted after the cluster is reclaimed — send an inquiry. | | **Deletion already in progress** | A previous deletion was interrupted. Resume it from the same screen. | If you cannot clear these yourself, or you need a refund or settlement, send an inquiry from the same dialog. It is recorded on the [Requests](/docs/console/requests) page, where you can track the reply. ## What You Are Asked to Confirm Before deleting, you confirm each of the following that applies to your Organization: * Your **remaining credit balance is not refunded automatically**. * If any card payments **you made** can still be cancelled, the dialog tells you how many. Cancel them from [Payment History](/docs/console/billing#cancelling-a-payment-and-refunds) **before** deleting. Payments made by other members are not counted and must be cancelled by those members before deletion — nothing can be cancelled from the console afterwards. * The members in the Organization **immediately lose access**. * Data on the Organization's **persistent volumes is irrecoverably deleted**. * Pending invitations are invalidated. * Running containers are terminated automatically. * Payments that have not settled yet will not grant credits if they complete after deletion. Leftover credits are not refunded as part of deletion. Card payments whose credits are unused can be cancelled yourself from Payment History **before** you delete; for anything else, send an inquiry **before** you delete. ## Account Withdrawal Withdrawing your account is a separate action, available in [Account Settings](/docs/console/account). If you are the **last Owner** of the Organization, withdrawing also deletes the Organization and goes through the same checks and confirmations. To keep the Organization, transfer ownership to another member first. ## Related Documentation Profile, password, email preferences, and account withdrawal. Check and cancel rentals before deleting. # Requests and Waitlist Source: https://docs.aieev.com/docs/console/requests Ask for what isn't in the catalog, and track how it was handled When the GPU, template, or model you need is not available, you can ask for it from the console instead of opening a separate support ticket. Every request lands in **My requests**, where you can follow its status and read our team's reply. ## What You Can Request | Request | Where you start it | What it does | | :- | :- | :- | | **Join the waitlist** | GPU selection in the container create flow | For a GPU that is sold out. You are notified — in the console and by email — as soon as capacity frees up. | | **Replica limit increase** | Replica settings, or the limits page | Raises how many replicas your organization can run. Once approved, the new limit applies automatically. | | **Request a GPU** | GPU selection | For a GPU model AirCloud does not offer yet, such as H200 or B200. | | **Request a template** | Template picker | For a framework or image that is not in the template list. | | **Request a model** | Air API model list | For a model you would like to use on Air API. | | **Rental inquiry** | Long-term Rentals | For a [long-term rental](/docs/console/long-term-rentals) — a configuration that is not listed, or custom terms. | Waitlist and limit-increase requests carry the details we need to act on them — how many replicas you need, the volume size, and how long you expect to need it. Requests are recorded per organization, so the same request is not submitted twice. If a teammate already asked for the same thing, you'll see that instead of a duplicate. ## Track Your Requests Open **My requests** in the console. It has two tabs — **Requests** and **My feedback** — and you can filter by status, kind, and requester, or narrow it to your own requests only. | Status | Description | | :- | :- | | **Pending** | Received and under review. | | **Approved** | Approved. For a limit increase, the new limit is already in effect. | | **Fulfilled** | Delivered — the resource is available. | | **Rejected** | Declined. The reply explains why. | | **Cancelled** | You withdrew the request. | You can cancel a request while it is still open. Cancelling closes it for good, but you can always send the same request again later. ## Getting Notified * **Request received** — confirms your request reached us. * **Request outcome** — tells you how it was handled, with our team's reply attached. * **Waitlisted GPU capacity available** — sent to you, not the organization owner, in the console and by email. * **Replica limit increase approved** — sent when the new limit takes effect. See [Notifications](/docs/console/notifications) to choose which channels you receive these on. ## Related Documentation Understand availability, sold-out GPUs, and replica limits. Secure GPUs for a fixed term at a lower hourly rate. # Authentication Source: https://docs.aieev.com/docs/get-started/authentication Generate and securely manage API keys All AirCloud APIs use secret key–based authentication. Once you generate a secret key and include it in the request headers, the same authentication method applies to both Air API and Air Container. ## Generate an API Key Navigate to the Project where you want to create an API key. In the Console, select **API Keys** from the left navigation menu, then click **Create New Secret Key**. Api Key Eng Configure the following options in the key creation dialog. Api Key Modal Eng | Field | Description | | - | - | | **Name** | A descriptive name that identifies the purpose and usage of the key for easier management. | | **Air API Access** | Specifies which Air API endpoints can be accessed using this key. | | **Container Access** | Specifies which Air Container deployments can be accessed using this key. | **A secret key is displayed only once when it is created.** Be sure to copy and store it in a secure location. If you lose the key, you must delete it and generate a new one. ## Authentication Header Include your secret key in the `Authorization` header for every API request. ```text theme={null} Authorization: Bearer YOUR_API_KEY ``` ## Security Best Practices Never hardcode your secret key in your source code. If it is committed to a repository, it may be exposed to others. We recommend storing it as an environment variable. ```bash .env theme={null} AIRCLOUD_API_KEY=YOUR_API_KEY ``` ```python Python theme={null} import os api_key = os.environ["AIRCLOUD_API_KEY"] ``` ```javascript Node.js theme={null} const apiKey = process.env.AIRCLOUD_API_KEY; ``` ## If Your Key Is Lost or Compromised Immediately delete the affected key from the **API Keys** page in the Console and generate a new one. A compromised key remains valid until it is revoked, so we strongly recommend deleting it as soon as possible. ## Related Documentation Learn how to authenticate and call Air API using your secret key. Learn how to resolve authentication errors and other common issues. # Concepts Source: https://docs.aieev.com/docs/get-started/concepts Core concepts for understanding AirCloud This page introduces the core concepts you should understand when getting started with AirCloud. If you are new to AirCloud, we recommend reviewing the [Quickstart](/docs/get-started/quickstart) first to understand the overall flow ## Organization An Organization is the top-level unit that groups users and projects. Create an Organization based on a team, company, or operating entity. Member invitations and permission management are also handled at the Organization level. Each account can belong to only one Organization. Once you create or join an Organization, you cannot be invited to another Organization. If you need to change your Organization, please contact your administrator. ## Project A Project is a workspace for deploying and operating Air API and Air Container. Usage, endpoints, and monitoring data are all managed at the Project level. You can create multiple Projects within a single Organization to separate environments by service or team. ## Air API Air API allows you to integrate AI models through an API without setting up infrastructure yourself. After selecting a model in your Project and generating a secret key, you can start testing immediately using code examples or the Playground. ## Air Container Air Container allows you to deploy your own container images to AirCloud. It gives you control over the full deployment environment, including GPU resources, runtime libraries, port settings, and autoscaling. This option is suitable for custom model servers or complex pipelines that need to run as-is. ## Endpoint An Endpoint is a URL used to send external requests to a deployed service. Both Air API and Air Container are accessed through their respective Endpoints. Within a Project, you can view status, usage, logs, and scheduling settings for each Endpoint. ## Replica A Replica is a copy of the same service running concurrently. Increasing the number of Replicas allows the service to handle more requests at the same time. Replicas can be adjusted manually or automatically through autoscaling. ## Autoscaling Autoscaling automatically increases or decreases the number of Replicas based on request traffic. By setting minimum and maximum values, you can reduce costs during low-traffic periods and automatically expand capacity when traffic increases. ## AirCloud Zero and AirCloud Plus AirCloud Zero and AirCloud Plus are two infrastructure options provided by AirCloud. They differ fundamentally in how nodes are organized and how resources are allocated. **AirCloud Zero** is a distributed cloud pool built by crowdsourcing resources from various participants, such as PC cafés, mining operators, and individuals with idle compute resources. Because resources are allocated on a Spot basis, AirCloud Zero can be used at a lower cost than AirCloud Plus. However, interruptions may occur when resources are reclaimed, making it suitable for workloads that can tolerate interruptions. AirCloud Zero is currently being prepared for launch and will be available soon. **AirCloud Plus** is a distributed cloud pool composed of dedicated AI compute nodes operated and managed directly by AIEEV. Resources are allocated on an On-demand or Reserved basis, allowing workloads to run reliably without interruption. It is suitable for production services that require continuous operation or workloads where predictable performance is important. 🛡️ **AirCloud Plus — ISO 27001 Certified** Suitable for workloads with enterprise-grade security and compliance requirements. | Item | AirCloud Zero (Coming Soon) | AirCloud Plus | | :-: | :-: | :-: | | Infrastructure | Crowdsourced idle resources, such as PC cafés and mining operators | Dedicated AI compute nodes operated directly by AIEEV | | Allocation model | Spot — interruptions may occur | On-demand / Reserved — stable allocation | | Relative pricing | Lower cost | Higher than Zero | | Suitable workloads | Cost-sensitive workloads that can tolerate interruptions | Production workloads that require stability and uninterrupted operation | | Security certification | — | 🛡️ ISO 27001 | | Availability | Coming soon | Available now | ## Recommended Next Learn about credits, payment methods, Auto Top-up, and invoice management. Learn how to quickly test and integrate models through the API. Learn how to deploy container images and configure resources and autoscaling. # Quickstart Source: https://docs.aieev.com/docs/get-started/quickstart A quickstart guide for new AirCloud users. In AirCloud, you first create an Organization and Project, then start your AI workload using either Air API or Air Container. ## Before you start Before using AirCloud, complete sign-up and onboarding. ### 1. Select Get Started and choose a service On the AirCloud homepage, click **Get Started**. In the service selection step, you can choose either **Run AI workloads** or **Provide resources**. Get Started and service selection * If you want to use the cloud, select **Go to User Dashboard** to move to the cloud console. * If you want to register resources as an AirCloud provider, **Join the Waitlist** and we will contact you in order. * If you want to try Air API, you can browse available models in the **AI Model** tab. Models available via Air API will be continuously updated. See [Supported Models](https://docs.aieev.com/models/) for the latest information. ### 2. Sign up and sign in You can sign up using email or social login. Login Kor The currently supported sign-up methods are: * Email * GitHub If you have issues signing up or logging in, request help via [**Contact Support**.](https://www.aieev.com/contact) ### 3. Complete onboarding AirCloud onboarding consists of the following three steps: 1. **Create an Organization** An Organization name can represent a company, lab, or project. You can also add collaborators to an Organization. Onboarding - Create organization **Once you create or join an organization, you cannot be invited to another organization.** If you need to change your organization, please [contact us](https://www.aieev.com/contact). 2. **Create a Project** A Project can represent a service you are building or a development effort. You can create multiple endpoints within a single Project. Create a project 3. **Add credit** *(optional)* After completing onboarding, go to the console to follow the first-time guide and start using the service. Add credit ## Choose your starting path You can start with either of the following options: Create an API workload in your Project, select a supported model, issue an API key, and test immediately. You can also test directly in the Playground. Deploy your own container image and configure resources and autoscaling to build a production-ready environment. # What is AirCloud? Source: https://docs.aieev.com/docs/index [AirCloud](https://ap-1.aieev.cloud:3000/get-started) is a fully distributed GPU Cloud Platform designed to deploy and operate AI inference workloads quickly and flexibly. Users can integrate models quickly through APIs, or deploy container images directly to build the runtime environment they need. ## Choose your deployment method Integrate AI models through APIs without managing infrastructure directly. Ideal when you want to quickly integrate high-quality open-source models or run inference workloads on a usage-based basis without operational overhead. Deploy container images you prepare directly onto AirCloud. Ideal when you need full control over the GPU environment and runtime — for custom CUDA environments, fine-tuned model serving, or complex pipeline configurations. ## Choose your infrastructure option A distributed infrastructure option well suited for workloads where cost efficiency matters most. A dedicated infrastructure option well suited for workloads that require stability and predictable performance. For a detailed comparison of infrastructure configuration, allocation methods, and more, see the [Concepts page](/docs/get-started/concepts). ## Next steps Review account setup, basic configuration, and the first steps to get started. Learn how to generate API keys and configure authentication. Check the support documentation if you need help while using AirCloud. # Container Runtime Reference Source: https://docs.aieev.com/docs/reference/container-runtime-reference Registry, ports, env vars, and health checks This page summarizes common runtime settings used when deploying with Air Container. ## Supported registries * GCP Artifact Registry * AWS ECR * GitHub Container Registry * Docker Hub Private registries require authentication. ## Common configuration fields ### Start command The command used to start the container process. ### Port The port your service listens on for external requests. ### Health check URL A path used to verify the container is healthy. ### Metrics path The path your application exposes metrics on, for example `/metrics`. ### Health check timeout How long to wait for a health check response. Default: **300 seconds**. ### Startup timeout The maximum time allowed for the container to start successfully. Default: **600 seconds**. ### Environment variables Key-value configuration required by your application. AirCloud also injects `AIRCLOUD_AUTHORIZED_KEYS` at deploy time, containing the SSH public keys registered for the container. See [Connect with SSH](/docs/air-container/connect-with-ssh). ### Shared memory (`/dev/shm`) The size of `/dev/shm`, for workloads that use shared memory such as a PyTorch DataLoader. Off by default, in which case half the instance memory applies. When set, it can range from 1 GB up to the instance's memory size. ### Container ID The container's identifier. Generated automatically, but you can set a fixed slug (lowercase letters, numbers, and hyphens). It becomes part of the container's public URL. ### Public URL Deployed containers are served at `https://ap-1.aieev.cloud/endpoints/`. The create form previews the URL as you edit the container ID. ## Operational recommendations * Manage public vs. private registry settings explicitly * Validate ports and health check paths before deployment * Re-check production environment variables before deploying * After changes, review logs and usage together ## Related docs Deployment flow and configuration steps. What to check in Usage, Logs, and Settings. # Deployment Error Codes Source: https://docs.aieev.com/docs/reference/error-codes What each container deployment error means and how to resolve it When a container ends up in **DEPLOY FAILED** or **UNHEALTHY**, an **Error Details** chip appears next to its status in the console. Opening it shows the diagnosed cause, the raw message from the platform, and a shortcut to the container's runtime logs. This page lists the codes you may see there. ## Image and Registry | Code | Meaning | What to do | | :- | :- | :- | | `IMAGE_INACCESSIBLE` | The image could not be pulled. | Check the image URL and, for private registries, the username and password or access token. | | `IMAGE_PULL_NETWORK` | A network error occurred while pulling the image. | Transient. Try again in a few minutes. | ## Resources | Code | Meaning | What to do | | :- | :- | :- | | `RESOURCE_INSUFFICIENT` | The requested resources exceed what the device can provide. | Lower the GPU, CPU, memory, or shared-memory settings, or pick a larger instance type. | | `DISK_FULL` | The device ran out of disk space. | Transient. Try again later, or reduce the persistent volume size. | | `VALIDATION_FAILED` | The submitted configuration is invalid. | Check the memory and CPU settings. | ## Scheduling and Runtime | Code | Meaning | What to do | | :- | :- | :- | | `RAY_SCHEDULING_TIMEOUT` | No device is free yet. | Nothing to do — the container deploys automatically once a device frees up. If it persists, the GPU may be sold out; check availability or join the waitlist. | | `RAY_HEALTH_CHECK_FAILED` | The deployed container is not responding to health checks. | The platform retries on another device. If it keeps failing, verify the health check path and port, and raise the health check timeout for slow-loading models. | | `RAY_DEPLOY_FAILED` | Deployment failed repeatedly. | Check the image and the resource settings, then redeploy. | | `RAY_ACTOR_DIED` | The container exited unexpectedly. | Check the runtime logs for the process's own error. Retry, and contact support if it persists. | | `CONTAINER_RUN_FAILED` | The container failed to start. | Check the startup command and the runtime logs. | | `DAEMON_UNREACHABLE` | The container engine on the device is not responding. | Transient. Try again later. | | `RAY_UNKNOWN` | An unclassified deployment error. | Check the runtime logs, then contact support with the raw message. | ## Platform These indicate a problem on the AirCloud side rather than in your configuration. | Code | Meaning | What to do | | :- | :- | :- | | `PEER_NOT_FOUND` | Internal error during deployment. | Retry. Contact support if it persists. | | `NETWORK_MISSING` | Internal error during deployment. | Contact support. | | `ENDPOINT_NOT_FOUND` | The endpoint could not be found. | Reload the container list. Contact support if it persists. | | `UPSTREAM_UNAVAILABLE` | A platform service is temporarily unavailable. | Try again later. | | `UPSTREAM_TIMEOUT` | A platform service took too long to respond. | Try again later. | | `DB_ERROR` | Temporary platform error. | Try again later. | | `INTERNAL_ERROR` | Temporary platform error. | Try again later. | | `UNKNOWN` | The cause could not be determined. | Contact support with the raw message from the Error Details dialog. | The Error Details dialog also shows the **raw message** from the platform. When contacting support, include that message along with the container ID and the time the failure occurred. ## Related Documentation Diagnose common deployment and runtime issues. Read runtime logs to find the underlying cause. # GPU Availability and Limits Source: https://docs.aieev.com/docs/reference/gpu-availability-and-limits Why a GPU may be unselectable, and how replica limits work Two separate things decide whether you can start a container right now: whether the **GPU has free capacity**, and whether your **organization's replica limit** has room. This page explains both, and what to do when either one blocks you. ## GPU Availability Every GPU in the container create flow carries an availability badge, refreshed from the live device fleet. Use **Refresh availability** to re-check without reloading the page. | Badge | Meaning | | :- | :- | | **Available** | Plenty of free capacity. | | **Limited** | Some capacity left. | | **Low** | Very little capacity left — it may run out while you are configuring. | | **Unavailable** | Sold out. The GPU cannot be selected until capacity frees up. | When the badge is missing, availability could not be verified at that moment. You can still create the container, but it may wait before it starts. Availability reflects the pool your container will actually deploy to, not the total number of devices AirCloud operates. Capacity held by long-term rentals, or reserved for another deployment shape, is not counted as free. ### Persistent Volumes Use a Separate Pool Containers that use a persistent volume run on a dedicated node pool. That pool's capacity is evaluated separately, so a GPU can be available for containers without a volume and sold out for containers with one. Two consequences follow: * Turning a persistent volume on or off can change which GPUs are selectable. * CPU type cannot be selected together with a persistent volume — the dedicated pool assigns without that distinction. ### When a GPU Is Sold Out * **Join the waitlist** — you are notified in the console and by email as soon as capacity frees up. * **Pick another GPU** — availability differs per model. * **Rent it long term** — a [long-term rental](/docs/console/long-term-rentals) secures capacity ahead of time, and can be arranged even for periods with nothing free right now. ## Replica Limits Separately from availability, your organization has a limit on how many replicas it can run, set per GPU type. The create form shows both figures — how many of your limit are already in use, and how many you can start right now. | Situation | What you see | | :- | :- | | Limit has room | The number of replicas you can start immediately. | | Limit reached | You can still create the container, but starting it requires stopping other containers or lowering the replica count. | | Limit is 1 | Autoscaling is turned off automatically, since it needs at least 2. | To raise the limit, request an increase from the replica settings or the limits page. Once approved, the new limit applies automatically and you are notified — see [Requests and Waitlist](/docs/console/requests). ## Related Documentation Configure resources and replicas during deployment. Join a waitlist or request a higher replica limit. # Infrastructure and Instance Types Source: https://docs.aieev.com/docs/reference/infrastructure-and-resource-types Understand Cloud Types and GPU instance types This page provides an overview of the infrastructure options and GPU instance types available in AirCloud. ## Cloud Types Choose one of the following Cloud Types based on your workload requirements. Designed for workloads that require high availability, predictable performance, and production-grade reliability. Recommended for production environments. Uses infrastructure contributed by individuals, PC cafés, and infrastructure partners. Ideal for cost-sensitive workloads where minimizing cost is the highest priority. ## Instance Types The following GPU instance types are available with AirCloud Plus. | GPU Model | VRAM | System Memory | vCPUs | | - | - | - | - | | NVIDIA RTX 4070 Super | 12 GB | 9 GB | 8 | | NVIDIA RTX 4070 Ti Super | 16 GB | 58 GB | 8 | | NVIDIA RTX 4090 | 24 GB | 58 GB | 8 | | NVIDIA RTX 5090 | 32 GB | 58 GB | 16 | | NVIDIA RTX PRO 6000 | 96 GB | 58 GB | 16 | The table above lists the GPU instance types generally available today. Additional types — including NPU and CPU-tier instances — are enabled per organization and appear in the container create flow only when your organization has access. The list in the console is always the authoritative one. Renting a GPU long term, starting from one month, lowers the hourly rate. See [Long-term Rentals](/docs/console/long-term-rentals) for terms and payment, and the [Pricing page](https://www.aieev.com/pricing) for the latest rates. ### Recommended VRAM by Model Size Choose an instance with sufficient GPU memory for your model. | Model Size | Recommended VRAM | Recommended Instance | | - | - | - | | Up to 7B | 12 GB or more | RTX 4070 Super or higher | | 13B | 16 GB or more | RTX 4070 Ti Super or higher | | 30B | 24 GB or more | RTX 4090 or higher | | 70B | 32 GB or more | RTX 5090 or higher | | Multimodal or Very Large Models | 96 GB | RTX PRO 6000 | ## Choosing an Instance Type Consider the following when selecting an instance type: * Required response latency * Model size and GPU memory requirements * Expected request volume * Replica strategy * Whether Autoscaling will be enabled ## Related Documentation Learn how to deploy a container and configure its resources. Learn how to configure Autoscaling and Scheduled Scaling. # Contact and Support Source: https://docs.aieev.com/docs/support/contact-and-feedback We're here to help you get the most out of AirCloud. If you need help, have a technical inquiry, or want to request a model, reach out through the channels below.
Ask our AI assistant trained on AirCloud documentation.
Ask how-to questions and check your own account (GPUs, endpoints, usage, credits) in plain language, right inside the console. Submit your inquiry through our Contact Us page. For sales inquiries or technical support, feel free to reach out directly. For general inquiries, email \ [hk.kim@aieev.com](mailto:hk.kim@aieev.com). For technical inquiries, email \ [bspark@aieev.com](mailto:bspark@aieev.com). ## Ask from Inside the Console For most product requests, the console is the fastest route — the request is recorded with the context we need, and you can track the reply on the **My requests** page. | What you need | Where to ask | | :- | :- | | A GPU that is sold out | Join the waitlist from the GPU selection | | A GPU model we don't offer | **Request a GPU** from the GPU selection | | A framework or image that isn't a template | **Request a template** from the template picker | | A model for Air API | **Request a model** from the Air API model list | | More replicas | **Request limit increase** from the replica settings | | A long-term rental | **Rental inquiry** from Long-term Rentals | See [Requests and Waitlist](/docs/console/requests) for how requests are tracked and answered. ## What Can You Contact Us About? * How to use Air API * Air Container deployment issues * Model addition requests * Sales and technical consultation * Onboarding and organization setup * Other technical inquiries ## Helpful Information to Include Providing the following details helps us respond faster. * Organization or Project name * Feature in use (e.g., Air API, Air Container) * Description of the issue * Steps to reproduce * Screenshots or log output (if available) * For model requests: model name, intended use case, expected traffic or scale, and preferred response speed or deployment type ## Common HTTP Errors The following are frequently encountered issues and how to resolve them. Authentication failed. Please verify your API key or access credentials. The requested container ID or endpoint path is incorrect. Please check the container ID or route. If an internal server error occurs, please try again later or contact the AirCloud support team at [**contact@aieev.com**](mailto:contact@aieev.com). ## Troubleshooting Common issues encountered during use and how to resolve them. * Symptom: API request authentication fails * Cause: Expired or invalid API key * Resolution: * Verify that the API key is still valid (check expiration) * Generate a new API key from the AirCloud dashboard * Symptom: GPU not detected when starting a container * Cause: Node instability or driver mismatch * Resolution: * Redeploy to a new instance * Check compatibility between the container runtime and GPU driver * Symptom: Container cannot connect to external endpoints * Cause: Incorrect port configuration, DNS issue, or firewall blocking * Resolution: * Verify that the container exposes the correct port and the service is listening * Test external connectivity using curl from inside the container * Check that outbound traffic is not blocked in security group settings * Symptom: Deployment stalls at the health check stage * Cause: The /health endpoint is not returning HTTP 200 OK * Resolution: * Confirm the correct health check URL and port are exposed * Review logs for error messages or model loading delays * Symptom: No scaling occurs despite high load * Cause: Scaling threshold set too high or replicas in an unhealthy state * Resolution: * Adjust autoscaling parameters such as CPU threshold and latency * Ensure all replicas pass health checks * Symptom: API returns a server error (502/503) * Cause: Application not bound to the expected port or crashed during startup * Resolution: * Confirm the service is running on `0.0.0.0:` * If model loading takes time, increase the health check timeout # FAQ Source: https://docs.aieev.com/docs/support/faq Frequently asked questions about AirCloud Start by creating an account, generating a secret key, and either deploying a container via **Air Container** or calling an AI model via **Air API**. The [Quickstart](/docs/get-started/quickstart) guide walks through the full process. Yes. AirCloud uses a prepaid credit system. Credits are shown with the unit **C**, and for organizations in the KRW region 1 C equals KRW 1 of supply price. You need to top up credits before you can deploy containers or call APIs. No. A secret key can only be viewed at the moment it is created. If you lose a key, delete it and generate a new one from the console. After deployment, a container goes through image pulling and initialization before entering **Running** state. This may take a few minutes depending on image size and GPU availability. If the container transitions to **Deploy Failed**, check the logs for the specific error. **Autoscaling** adjusts the replica count automatically in response to real-time traffic. **Scheduled Scaling** sets replica counts on a fixed schedule — useful for predictable traffic patterns like business hours. See the [Autoscaling and Scheduling](/docs/air-container/autoscaling-and-scheduling) guide for configuration details. Check the [Troubleshooting](/docs/air-container/troubleshooting) guide for common issues. For direct support, use the chat widget in the console or contact us at [support@aieev.com](mailto:support@aieev.com). # Release Notes Source: https://docs.aieev.com/docs/support/release-notes AirCloud documentation update history ## 2026-10 ### New pages * **Air Assistant**: New Console page for the beta in-console assistant that answers questions from the docs and your own account: getting started, what it can look up, what is not supported yet, panel controls, and data handling and permissions. ## 2026-09 ### Corrections * **Cancelling a Payment and Refunds**: The refund policy on the Billing page now matches how the console behaves. There is no 7-day limit, the full amount including VAT is refunded, and the page explains how the payer cancels a card or PayPal payment (auto top-up included) whose credits have not been used at all. * **Deleting an Organization**: Added the "cancellable card payments" notice to the confirmation list, and made explicit that they must be cancelled from Payment History before deleting. ## 2026-08 ### New pages * **Long-term Rentals**: New Console page covering terms, discounts, payment, status, cancellation and refunds, and how a rental applies to your containers. Replaces the outdated "Reserved Instances" section in Organization Management. * **Requests and Waitlist**: New Console page for the waitlist, replica limit increases, and GPU/template/model requests, and how they are tracked in My requests. * **Account Settings**: New Console page for profile name, password change, email preferences, and account withdrawal. * **Deleting an Organization**: New Console page listing what must be settled before deletion and what is irrecoverably removed. * **GPU Availability and Limits**: New Reference page on availability badges, the separate persistent-volume node pool, and replica limits. * **Deployment Error Codes**: New Reference page documenting every code shown in the Error Details dialog, with what to do about each. ### API Reference * **Spec synced with the running API**: Verified the External API spec against the schema the production service publishes, and added the fields that were missing — `tags` on the endpoint list and status responses, the RFC 9457 `error` object on the status response, `auth_mode` on the PATCH request and response, and the `project_id` query parameter on the endpoint list. * **Endpoint URL examples**: `serving_endpoint_url` examples now use the unified `https://ap-1.aieev.cloud/endpoints/` form instead of the retired cluster-numbered path. ### Corrections * **Credit unit**: Replaced "AU" with the credit unit **C** used across the console. Documented the purchase range (10,000 C – 10,000,000 C). * **Model catalog**: Removed a model that is not offered, added **DeepSeek V4 Flash** and the new **Qwen3.8-27B** to the supported model list, and corrected all KRW prices to the live catalog. TTS is now correctly priced per 1,000 characters rather than per million tokens. * **Container status**: Aligned the state names with the console — READY, RUNNING, UPDATING, DEPLOY FAILED, UNHEALTHY. * **Persistent volume**: Corrected the size range to 1–1,000 GB (default 30 GB). Documented resizing while running and mounting one volume at several paths. * **Runtime logs**: Rewrote the logs section for the current replica-based viewer — log level and source filters, a 7-day default window, and per-replica or bulk download. * **Templates**: Replaced the old category table with the current workload / interface / variant grouping, and corrected the save-as-template fields. * **Desktop notifications**: The toggle moved from profile settings to the Notifications settings tab. * **Monitoring**: Removed the Task Errors metric, which no longer exists. * **Air API troubleshooting**: Replaced unresolved placeholders with the actual behavior for rate limits, model access, and status announcements. ### Improvements * **Notifications**: Rewrote the page as a full event-by-channel reference covering every notification, its recipients, and the 30-day console retention. * **Deploy a Container**: Documented shared memory (`/dev/shm`), the editable container ID and its public URL, and how GPU availability affects selection. * **Container Runtime Reference**: Corrected field names to match the console and added shared memory, the public URL format, and the injected `AIRCLOUD_AUTHORIZED_KEYS` variable. * **Contact and Feedback**: Added the in-console request routes as the primary channel for product requests. * **Fixes**: Repaired duplicated sentences and table headers on the Concepts and Billing pages, and corrected broken internal links across the FAQ, API Reference introduction, and release notes. *** ## 2026-07 ### API Reference * **API Base URL Update**: The External API base URL changed from `https://external.aieev.cloud:5007` to `https://external.aieev.cloud:5000`. Updated the OpenAPI spec, API examples, and the AirCloud CLI setup guides accordingly. *** ## 2026-06 ### Air Container * **Container Management**: The "Start/Stop/Restart" page has been reorganized as **Container Management**, consolidating lifecycle controls under a single section. * **Container Tags**: You can now group containers with user-defined tags and filter the list by tag. * **Deploy a Container — Replica Quota**: Added guidance on quota limits and how to request an increase. Added Waitlist instructions for high-demand GPU models. * **Persistent Volume — Change while stopped**: Documented how to activate, deactivate, or swap volumes while a container is in Pending state. * **SSH Key Per-Container Application**: Added instructions for applying SSH keys to specific containers and enabling/disabling keys without deletion. * **Web Terminal — Replica selection**: Documented replica selection in the web terminal and auto-reconnect behavior. ### Air API * **Monitoring**: Added a new Monitoring page for Air API, covering project-level metrics (request count, latency, token usage, error rate) and organization-level usage aggregation. * **API Usage Guide**: Added Shell (bash/curl) code examples alongside Python, Node.js, and cURL for Chat, TTS, and Embedding models. * **Models and Playground**: Updated model display names shown in usage charts and request logs. ### Reference * **Infrastructure and Resource Types**: Added a new reference page documenting AirCloud Plus and AirCloud Zero infrastructure options, available GPU instance specs, and VRAM guidance by model size. ### Console * **Billing**: Added Refund Policy section documenting AU refund eligibility and the refund request process. ### Support * **FAQ**: Converted FAQ to accordion format for easier navigation. ### Get Started * **What is AirCloud?**: Restructured the index page to separate deployment method selection (Air API / Air Container) from infrastructure option selection (AirCloud Zero / AirCloud Plus). Updated Next Steps to include an Authentication card. *** ## 2026-04 ### Air Container * **Autoscaling**: Added documentation for replica-based autoscaling configuration. * **Scheduled Scaling**: Added documentation for time-based scheduled scaling. * **Monitoring and Troubleshooting**: Added container metrics reference and common error resolution guide. ### Air API * **Models and Playground**: Added Playground usage guide and model selection documentation. * **API Usage Guide**: Added OpenAI SDK migration guide and full code examples for Chat, TTS, and Embedding. ### Get Started * **Authentication**: Added secret key generation and management guide. * **Concepts**: Added infrastructure concepts page covering AirCloud Plus and AirCloud Zero. # DeepSeek V4 Flash Source: https://docs.aieev.com/models/deepseek-v4-flash Efficiency-optimized MoE model for fast, low-cost inference. **Model ID:** `deepseek/deepseek-v4-flash` | **Endpoint ID:** `deepseek-v4-flash` | **Parameters:** 284B (MoE, 13B active) | **Released:** 2026-04-24 | Input Price | Output Price | Context | Modality | | :-: | :-: | :-: | :-: | | \$0.100 / 1M | \$0.200 / 1M | 131,072 | text → text | ## Overview DeepSeek V4 Flash is DeepSeek's efficiency-optimized Mixture-of-Experts model. Out of 284B total parameters, only 13B are activated per token, delivering fast responses at low cost. It's well suited for workloads where speed and cost matter, such as coding assistants, chatbots, and agentic workflows. The model supports a context window of up to 131,072 tokens. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.100 | \$0.200 | | KRW | ₩145 | ₩290 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Multiple calls supported, controllable via `parallel_tool_calls` | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ❌ | Not supported | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ✅ | The reasoning trace is returned separately in the `reasoning` field. Disable via `enable_thinking: false`. | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `response_format: json_object` | | logprobs | ✅ | `logprobs` / `top_logprobs` | ## Key Features * Sparse MoE activation (13B of 284B) for fast, low-cost inference * Reasoning (thinking) support that can be disabled when not needed * Tool calling and JSON mode support * Optimized for coding and agentic workloads ## Use Cases ### Coding Assistant Generate and explain code for practical development tasks. ```text Input theme={null} Write a Python function to check if a number is prime and explain the logic. ``` ```python Output theme={null} def is_prime(n): if n <= 1: return False for i in range(2, int(n ** 0.5) + 1): if n % i == 0: return False return True # This function checks divisibility only up to the square root of n, # which improves efficiency. ``` ### Agentic Workflows ```text Input theme={null} Given a list of files in a directory, write a plan to find and delete all files older than 30 days. ``` ```text Output theme={null} 1. List all files with their last-modified timestamps. 2. Compute the cutoff date (today - 30 days). 3. Filter files whose modified time is before the cutoff. 4. Confirm the filtered list, then delete each file. 5. Log the deleted file names for auditing. ``` ### General Chat Handle everyday conversation and general-purpose Q\&A quickly and at low cost. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | List of input messages for chat-based generation. | | `max_tokens` | integer | Optional | - | Maximum output tokens to generate | | `temperature` | number | Optional | 1 | Sampling temperature (0.0-2.0) | | `top_p` | number | Optional | 1 | Nucleus sampling threshold | | `top_k` | integer | Optional | - | Limit sampling to the top-k most likely tokens | | `min_p` | number | Optional | - | Minimum probability threshold for token sampling | | `frequency_penalty` | number | Optional | 0 | Penalty for token frequency | | `presence_penalty` | number | Optional | 0 | Penalty for token presence | | `repetition_penalty` | number | Optional | - | Penalty for repeated token generation | | `stop` | string \| array | Optional | - | Stop sequence(s) that end generation | | `seed` | integer | Optional | - | Random seed for reproducible sampling | | `stream` | boolean | Optional | false | Enable streaming responses | | `tools` | array | Optional | - | Tool calling function definitions | | `tool_choice` | string \| object | Optional | auto | How tools are invoked (`auto`, `none`, or a specific function) | | `response_format` | object | Optional | - | JSON mode (`{"type": "json_object"}`) | | `logprobs` | boolean | Optional | false | Return per-token log probabilities | ## Model Details | Property | Value | | - | - | | Context Length | 131,072 | | Max Output Length | 131,072 | | Input Modalities | text | | Output Modalities | text | | Supported Features | tools, reasoning, streaming, json\_mode, logprobs | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/deepseek-v4-flash/v1" ) response = client.chat.completions.create( model="deepseek/deepseek-v4-flash", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/deepseek-v4-flash/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "deepseek/deepseek-v4-flash", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/deepseek-v4-flash/v1", }); const response = await client.chat.completions.create({ model: "deepseek/deepseek-v4-flash", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ## Tags `open-source` `conversational` `moe` `reasoning` `efficient` # Available Models Source: https://docs.aieev.com/models/index Browse all available AI models on AirCloud. AirCloud provides access to a variety of AI models for inference. Models are accessible through the Air API using an OpenAI-compatible interface. ## Text models Conversational AI, reasoning, and code generation. | Model | Description | Input | Output | | - | - | - | - | | [Qwen3.8-27B](/models/qwen3-8-27b) | Compact dense vision-language model for agentic and long-horizon work. | \$0.400/1M tokens | \$3.000/1M tokens | | [Qwen3.6-35B-A3B](/models/qwen3-6-35b-a3b) | High-performance MoE model with multimodal support. | \$0.140/1M tokens | \$1.000/1M tokens | | [Qwen3.5-9B](/models/qwen3-5-9b) | Compact and efficient model with multimodal support. | \$0.100/1M tokens | \$0.150/1M tokens | | [Qwen3-32B](/models/qwen3-32b) | Dense 32B model with hybrid reasoning. | \$0.080/1M tokens | \$0.280/1M tokens | | [Llama3.3-70B](/models/llama3-3-70b) | Meta's multilingual 70B instruct model. | \$0.100/1M tokens | \$0.320/1M tokens | | [DeepSeek V4 Flash](/models/deepseek-v4-flash) | Efficiency-optimized MoE model for fast, low-cost inference. | \$0.100/1M tokens | \$0.200/1M tokens | ## Embedding models Vector embeddings for semantic search and RAG. | Model | Description | Input | Output | | - | - | - | - | | [Qwen3-Embedding-8B](/models/qwen3-embedding-8b) | Multilingual embedding model with 4,096-dimensional vectors. | \$0.010/1M tokens | \$0.000/1M tokens | ## Audio models Text-to-speech and voice synthesis. | Model | Description | Input | Output | | - | - | - | - | | [Qwen3-TTS](/models/qwen3-tts) | Multilingual TTS with custom voice cloning. | \$0.080/1,000 characters | \$0.000 | ## Getting Started Sign up for an [AirCloud account](https://aieev.com) and generate an API key from the dashboard. Replace `YOUR_API_KEY` with your actual key and run the code below. ```python Python theme={null} import requests response = requests.post( "https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1/chat/completions", headers={ "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" }, json={ "model": "qwen/qwen3.5-9b", "messages": [{"role": "user", "content": "Hello!"}] } ) result = response.json() print(result["choices"][0]["message"]["content"]) ``` ```bash cURL theme={null} curl --request POST \ --url https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1/chat/completions \ --header 'Authorization: Bearer YOUR_API_KEY' \ --header 'Content-Type: application/json' \ --data '{ "model": "qwen/qwen3.5-9b", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} const response = await fetch( "https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1/chat/completions", { method: "POST", headers: { "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" }, body: JSON.stringify({ model: "qwen/qwen3.5-9b", messages: [{ role: "user", content: "Hello!" }] }) } ); const result = await response.json(); console.log(result.choices[0].message.content); ``` # Llama3.3-70B Source: https://docs.aieev.com/models/llama3-3-70b Meta's multilingual 70B instruct model for general-purpose chat and text tasks. **Model ID:** `meta-llama/meta-llama-3.3-70b-instruct` | **Endpoint ID:** `llama3-3-70b-instruct` | **Parameters:** 70B | **Released:** 2024-12-06 | Input Price | Output Price | Context | Modality | | :-: | :-: | :-: | :-: | | \$0.100 / 1M | \$0.320 / 1M | 131,072 | text → text | ## Overview Meta Llama 3.3 70B Instruct is a dense 70B-parameter model fine-tuned for instruction following and conversational use. It delivers strong multilingual instruction following across a wide range of languages and supports a 131,072-token context window for long conversations and documents. Built on the proven open-source Llama family, it is well suited for general-purpose chat, summarization, and coding assistance. The model focuses on reliable text generation rather than reasoning traces or multimodal input. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.100 | \$0.320 | | KRW | ₩145 | ₩464 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Streaming tool calls supported | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ❌ | Not supported | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ❌ | Not supported | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `response_format: json_object` | ## Key Features * Strong multilingual instruction following across a wide range of languages * 128K-token context window for long conversations and documents * Tool calling and JSON mode support for structured, agentic workflows * Built on the proven open-source Llama family ## Use Cases ### General Q\&A & Conversation Handle general-purpose Q\&A and multi-turn conversation with reliable instruction following. ```text Input theme={null} Explain how transformers work in simple terms and give a real-world analogy. ``` ```text Output theme={null} Transformers process text by modeling relationships between tokens in parallel rather than strictly one by one... A simple analogy is a group discussion where each person listens to everyone else to understand the full context before responding. ``` ### Code Generation & Assistance Generate and explain code for practical development tasks. ```text Input theme={null} Write a Python function to check if a number is prime and explain the logic. ``` ```python Output theme={null} def is_prime(n): if n <= 1: return False for i in range(2, int(n ** 0.5) + 1): if n % i == 0: return False return True # This function checks divisibility only up to the square root of n, # which improves efficiency. ``` ### Summarization & Analysis Summarize long documents and analyze text content across multiple languages. ### Multilingual Conversation Carry on natural conversations and follow instructions across many languages with consistent quality. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | List of input messages for chat-based generation. | | `max_tokens` | integer | Optional | - | Maximum output tokens to generate | | `temperature` | number | Optional | 1 | Sampling temperature (0.0-2.0) | | `top_p` | number | Optional | 1 | Nucleus sampling threshold | | `top_k` | integer | Optional | - | Limit sampling to the top-k most likely tokens | | `min_p` | number | Optional | - | Minimum probability threshold for token sampling | | `frequency_penalty` | number | Optional | 0 | Penalty for token frequency | | `presence_penalty` | number | Optional | 0 | Penalty for token presence | | `repetition_penalty` | number | Optional | - | Penalty for repeated token generation | | `stop` | string \| array | Optional | - | Stop sequence(s) that end generation | | `seed` | integer | Optional | - | Random seed for reproducible sampling | | `stream` | boolean | Optional | false | Enable streaming responses | | `tools` | array | Optional | - | Tool calling function definitions | | `tool_choice` | string \| object | Optional | auto | How tools are invoked (`auto`, `none`, or a specific function) | | `response_format` | object | Optional | - | JSON mode (`{"type": "json_object"}`) | ## Model Details | Property | Value | | - | - | | Context Length | 131,072 | | Max Output Length | 131,072 | | Input Modalities | text | | Output Modalities | text | | Supported Features | tools, streaming, json\_mode | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/llama3-3-70b-instruct/v1" ) response = client.chat.completions.create( model="meta-llama/meta-llama-3.3-70b-instruct", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/llama3-3-70b-instruct/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "meta-llama/meta-llama-3.3-70b-instruct", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/llama3-3-70b-instruct/v1", }); const response = await client.chat.completions.create({ model: "meta-llama/meta-llama-3.3-70b-instruct", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ## Tags `open-source` `conversational` `70B` `multilingual` # Qwen3-32B Source: https://docs.aieev.com/models/qwen3-32b Dense 32B model with hybrid reasoning for general-purpose text tasks. **Model ID:** `qwen/qwen3-32b` | **Endpoint ID:** `qwen3-32b` | **Parameters:** 32B | **Released:** 2025-04-29 | Input Price | Output Price | Context | Modality | | :-: | :-: | :-: | :-: | | \$0.080 / 1M | \$0.280 / 1M | 40,960 | text → text | ## Overview Qwen3-32B is a 32B-parameter dense model from the Qwen3 generation. It supports hybrid reasoning (thinking mode), working through complex problems step by step before answering while responding quickly for everyday conversation. The model shows strong multilingual understanding and generation, along with solid coding and math capabilities. It supports a context window of up to 40,960 tokens. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.080 | \$0.280 | | KRW | ₩116 | ₩406 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Parallel and streaming tool calls supported | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ❌ | Not supported | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ✅ | Reasoning arrives inline as `` tags inside `content`, not in the `reasoning` field. Disable via `enable_thinking: false`. | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `response_format: json_object` | | logprobs | ✅ | `logprobs` / `top_logprobs` | ## Key Features * Stable, high-quality output from a 32B dense architecture * Hybrid reasoning (thinking mode) that can be toggled on or off * Strong multilingual, coding, and math performance * Tool calling and JSON mode support for structured, agentic workflows ## Use Cases ### Complex Q\&A & Reasoning Work through multi-step problems by reasoning before answering. ```text Input theme={null} A train leaves station A at 60 km/h. Two hours later, a second train leaves the same station at 90 km/h in the same direction. How long does it take the second train to catch up? ``` ```text Output theme={null} The first train has a 2-hour head start, covering 120 km before the second train departs. The second train closes the gap at 90 - 60 = 30 km/h, so it needs 120 / 30 = 4 hours to catch up. It takes the second train 4 hours to catch up. ``` ### Code Generation & Assistance Generate and explain code for practical development tasks. ```text Input theme={null} Write a Python function to check if a number is prime and explain the logic. ``` ```python Output theme={null} def is_prime(n): if n <= 1: return False for i in range(2, int(n ** 0.5) + 1): if n % i == 0: return False return True # This function checks divisibility only up to the square root of n, # which improves efficiency. ``` ### Document Summarization Summarize long documents and extract key points across multiple languages. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | List of input messages for chat-based generation. | | `max_tokens` | integer | Optional | - | Maximum output tokens to generate | | `temperature` | number | Optional | 1 | Sampling temperature (0.0-2.0) | | `top_p` | number | Optional | 1 | Nucleus sampling threshold | | `top_k` | integer | Optional | - | Limit sampling to the top-k most likely tokens | | `min_p` | number | Optional | - | Minimum probability threshold for token sampling | | `frequency_penalty` | number | Optional | 0 | Penalty for token frequency | | `presence_penalty` | number | Optional | 0 | Penalty for token presence | | `repetition_penalty` | number | Optional | - | Penalty for repeated token generation | | `stop` | string \| array | Optional | - | Stop sequence(s) that end generation | | `seed` | integer | Optional | - | Random seed for reproducible sampling | | `stream` | boolean | Optional | false | Enable streaming responses | | `tools` | array | Optional | - | Tool calling function definitions | | `tool_choice` | string \| object | Optional | auto | How tools are invoked (`auto`, `none`, or a specific function) | | `response_format` | object | Optional | - | JSON mode (`{"type": "json_object"}`) | | `logprobs` | boolean | Optional | false | Return per-token log probabilities | ## Model Details | Property | Value | | - | - | | Context Length | 40,960 | | Max Output Length | 40,960 | | Input Modalities | text | | Output Modalities | text | | Supported Features | tools, reasoning, streaming, json\_mode, logprobs | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1" ) response = client.chat.completions.create( model="qwen/qwen3-32b", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3-32b", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/qwen3-32b/v1", }); const response = await client.chat.completions.create({ model: "qwen/qwen3-32b", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ## Tags `open-source` `conversational` `32B` `reasoning` `multilingual` # Qwen3.5-9B Source: https://docs.aieev.com/models/qwen3-5-9b Compact and efficient 9B language model with multimodal support. **Model ID:** `qwen/qwen3.5-9b` | **Endpoint ID:** `qwen3-5-9b` | **Parameters:** 9B | **Released:** 2026-03-10 | Input Price | Output Price | Context | Modality | Quantization | | :-: | :-: | :-: | :-: | :-: | | \$0.100 / 1M | \$0.150 / 1M | 262,144 | text + image → text | FP8 | ## Overview Qwen 3.5 9B is a compact yet capable open-source language model designed to balance performance and efficiency. It supports multilingual understanding and generation, long-context inference up to 262,144 tokens, and multimodal input with text and image support while producing text outputs. Compared with larger models, it offers lower serving cost and faster inference, making it well suited for chat assistants, coding help, document summarization, visual understanding, and other real-time AI applications. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.100 | \$0.150 | | KRW | ₩145 | ₩217.5 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Parallel and streaming tool calls supported | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ✅ | Up to 1 image per request | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ✅ | Returned separately in the `reasoning` field, can be disabled | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `response_format: json_object` | | logprobs | ✅ | `logprobs` / `top_logprobs` | ## Key Features * Efficient 9B model well suited for cost- and latency-sensitive deployments * Strong multilingual understanding and generation * Efficient serving through FP8 quantization * Compatible with optimized inference runtimes such as vLLM ## Use Cases ### General Q\&A Handle general-purpose Q\&A with efficient reasoning and context understanding. ```text Input theme={null} Explain how transformers work in simple terms and give a real-world analogy. ``` ```text Output theme={null} Transformers process text by modeling relationships between tokens in parallel rather than strictly one by one... A simple analogy is a group discussion where each person listens to everyone else to understand the full context before responding. ``` ### Code Generation & Assistance Generate and explain code efficiently for practical development tasks. ```text Input theme={null} Write a Python function to check if a number is prime and explain the logic. ``` ```python Output theme={null} def is_prime(n): if n <= 1: return False for i in range(2, int(n ** 0.5) + 1): if n % i == 0: return False return True # This function checks divisibility only up to the square root of n, # which improves efficiency. ``` ### Summarization & Analysis Perform efficient summarization and lightweight analysis of long documents. ### Visual Understanding Understand image inputs and generate text-based explanations or insights. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | List of input messages for chat-based generation. Supports text and image content. | | `max_tokens` | integer | Optional | - | Maximum output tokens to generate | | `temperature` | number | Optional | 1 | Sampling temperature (0.0-2.0) | | `top_p` | number | Optional | 1 | Nucleus sampling threshold | | `top_k` | integer | Optional | - | Limit sampling to the top-k most likely tokens | | `min_p` | number | Optional | - | Minimum probability threshold for token sampling | | `frequency_penalty` | number | Optional | 0 | Penalty for token frequency | | `presence_penalty` | number | Optional | 0 | Penalty for token presence | | `repetition_penalty` | number | Optional | - | Penalty for repeated token generation | | `stop` | string \| array | Optional | - | Stop sequence(s) that end generation | | `seed` | integer | Optional | - | Random seed for reproducible sampling | | `stream` | boolean | Optional | false | Enable streaming responses | | `tools` | array | Optional | - | Tool calling function definitions | | `tool_choice` | string \| object | Optional | auto | How tools are invoked (`auto`, `none`, or a specific function) | | `response_format` | object | Optional | - | JSON mode (`{"type": "json_object"}`) | | `logprobs` | boolean | Optional | false | Return per-token log probabilities | ## Model Details | Property | Value | | - | - | | Context Length | 262,144 | | Max Output Length | 262,144 | | Quantization | fp8 | | Input Modalities | text, image (max 1 image per request) | | Output Modalities | text | | Supported Features | tools, reasoning, streaming, vision, json\_mode, logprobs | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1" ) response = client.chat.completions.create( model="qwen/qwen3.5-9b", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3.5-9b", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/qwen3-5-9b/v1", }); const response = await client.chat.completions.create({ model: "qwen/qwen3.5-9b", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ## Tags `open-source` `conversational` `9B` `reasoning` `multilingual` `efficient` `vision` # Qwen3.6-35B-A3B Source: https://docs.aieev.com/models/qwen3-6-35b-a3b High-performance mixture-of-experts model with multimodal support. **Model ID:** `qwen/qwen3.6-35b-a3b` | **Endpoint ID:** `qwen3-6-35b-a3b` | **Parameters:** 35B (A3B MoE) | **Released:** 2026-04-27 | Input Price | Output Price | Context | Modality | Quantization | | :-: | :-: | :-: | :-: | :-: | | \$0.140 / 1M | \$1.000 / 1M | 262,144 | text + image → text | FP8 | ## Overview Qwen 3.6 35B (A3B) is a mixture-of-experts (MoE) large language model designed to deliver strong performance with efficient inference. It uses sparse activation, where only a subset of parameters is activated per token, enabling a better balance between capability and serving cost. Compared to smaller models such as 9B variants, it offers improved reasoning, coding, and analytical performance for more complex workloads. The model supports long-context inference up to 262,144 tokens and multimodal input (text and image), making it suitable for advanced assistants, backend automation, multimodal understanding, and large-scale inference systems. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.140 | \$1.000 | | KRW | ₩203 | ₩1,450 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Parallel and streaming tool calls supported | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ✅ | Up to 4 images per request | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ✅ | Returned separately in the `reasoning` field, can be disabled | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `response_format: json_object` | | logprobs | ✅ | `logprobs` / `top_logprobs` | ## Key Features * Mixture-of-Experts (MoE, A3B) architecture with sparse activation for efficient scaling * Stronger reasoning and coding performance compared to smaller models such as 9B variants * Supports long-context inference up to 262,144 tokens * Multimodal capability with text and image input support (max 4 images per request; exceeding the limit returns a 400 error) * Strong multilingual understanding and generation * Efficient inference through sparse expert activation * Compatible with high-throughput serving engines such as vLLM * Provided in FP8 format for efficient deployment ## Use Cases ### Complex Q\&A Handle complex multi-step reasoning and analytical queries. ```text Input theme={null} Compare transformer-based models and mixture-of-experts models in terms of scalability and efficiency. ``` ```text Output theme={null} Transformer models scale by increasing parameter count and compute, while MoE models improve efficiency by activating only a subset of parameters per token... MoE advantages: 1. Higher parameter capacity with lower compute cost 2. Better scalability across distributed systems 3. Improved efficiency for large-scale inference workloads ``` ### Advanced Code Generation Generate production-level code and system design explanations. ```text Input theme={null} Design a scalable distributed task queue system using Python and explain key components. ``` ```text Output theme={null} A scalable distributed task queue system can be built using components such as a message broker (Redis/Kafka), worker nodes, and a task scheduler... Key components: - Producer: submits tasks - Broker: queues tasks - Worker: executes tasks - Result backend: stores results ``` ### Deep Analysis & Summarization Perform deeper document understanding and insight extraction. ### Visual Understanding Analyze images and extract insights through multimodal reasoning. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | List of input messages for chat-based generation. Supports text and image content. | | `max_tokens` | integer | Optional | - | Maximum output tokens to generate | | `temperature` | number | Optional | 1 | Sampling temperature (0.0-2.0) | | `top_p` | number | Optional | 1 | Nucleus sampling threshold | | `top_k` | integer | Optional | - | Limit sampling to the top-k most likely tokens | | `min_p` | number | Optional | - | Minimum probability threshold for token sampling | | `frequency_penalty` | number | Optional | 0 | Penalty for token frequency | | `presence_penalty` | number | Optional | 0 | Penalty for token presence | | `repetition_penalty` | number | Optional | - | Penalty for repeated token generation | | `stop` | string \| array | Optional | - | Stop sequence(s) that end generation | | `seed` | integer | Optional | - | Random seed for reproducible sampling | | `stream` | boolean | Optional | false | Enable streaming responses | | `tools` | array | Optional | - | Tool calling function definitions | | `tool_choice` | string \| object | Optional | auto | How tools are invoked (`auto`, `none`, or a specific function) | | `response_format` | object | Optional | - | JSON mode (`{"type": "json_object"}`) | | `logprobs` | boolean | Optional | false | Return per-token log probabilities | ## Model Details | Property | Value | | - | - | | Context Length | 262,144 | | Max Output Length | 262,144 | | Quantization | fp8 | | Input Modalities | text, image (max 4 images per request) | | Output Modalities | text | | Supported Features | tools, reasoning, streaming, vision, json\_mode, logprobs | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/qwen3-6-35b-a3b/v1" ) response = client.chat.completions.create( model="qwen/qwen3.6-35b-a3b", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/qwen3-6-35b-a3b/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3.6-35b-a3b", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/qwen3-6-35b-a3b/v1", }); const response = await client.chat.completions.create({ model: "qwen/qwen3.6-35b-a3b", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` ## Tags `open-source` `conversational` `35B` `reasoning` `multilingual` `moe` `high-performance` # Qwen3.8-27B Source: https://docs.aieev.com/models/qwen3-8-27b Compact dense vision-language model for agentic and long-horizon work. **Model ID:** `qwen/qwen3.8-27b` | **Endpoint ID:** `qwen-3-8-27b` | **Parameters:** 27B (dense) | **Released:** 2026-08-20 | Input Price | Output Price | Context | Modality | Quantization | | :-: | :-: | :-: | :-: | :-: | | \$0.400 / 1M | \$3.000 / 1M | 262,144 | text + image + video → text | BF16 | ## Overview Built on the architectural foundation of Qwen3.5, Qwen3.8 delivers substantial gains across coding, professional work, research, and long-horizon agentic tasks. Qwen3.8-27B brings these advances to a compact, deployment-friendly dense model: a native vision-language model that understands images and videos, with flexible thinking control, designed to carry complex, multi-step tasks through to completion with greater reliability. Try the model in the playground. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.400 | \$3.000 | | KRW | ₩580 | ₩4,350 | ## Supported Features All features are available through the [OpenAI Compatible API](/docs/air-api/openai-compatible-api). | Feature | Supported | Notes | | :- | :-: | :- | | [Streaming](/docs/air-api/openai-compatible-api#streaming) | ✅ | SSE, `include_usage` supported | | [Tool Calling](/docs/air-api/openai-compatible-api#tool-calling-function-calling) | ✅ | Parallel and streaming tool calls supported | | [Vision](/docs/air-api/openai-compatible-api#vision-image-input) | ✅ | Images and video (`image_url`, `video_url`) | | [Reasoning](/docs/air-api/openai-compatible-api#reasoning) | ✅ | Depth is tunable with `reasoning_effort` | | [JSON Mode](/docs/air-api/openai-compatible-api#json-mode-structured-outputs) | ✅ | `json_object` and `json_schema` | | logprobs | ✅ | `logprobs` / `top_logprobs` | When streaming, this model returns reasoning in the `reasoning_content` delta field rather than `reasoning`. ## Key Features * Native vision-language model — understands images and video without a separate adapter * Flexible thinking control: turn reasoning on or off, and tune its depth with `reasoning_effort` * Reasoning from previous turns can be preserved to keep multi-step decisions consistent * Long-context inference up to 262,144 tokens, with up to 131,072 output tokens * Strong agentic coding and tool use across multi-step tasks * Multilingual across 13 languages including Korean, English, Chinese, and Japanese * Served in BF16 for full-precision quality ## Use Cases ### Agentic Coding Work through a repository across multiple steps rather than answering a single question. ```text Input theme={null} This Flask endpoint returns 500 under concurrent load. Find the race condition and patch it. ``` ```text Output theme={null} The counter increment is not atomic, so two requests can read the same value before either writes back. Wrapping the update in a lock, or moving the counter to an atomic backend, closes the lost-update window. Patch follows. ``` ### Document and Chart Understanding Read charts, tables, scanned documents, and technical diagrams from images. ```text Input theme={null} [chart image] What does this throughput curve tell us? ``` ```text Output theme={null} Throughput peaks at concurrency 32 and declines beyond it, which means the batch scheduler saturates before the memory bound is reached. ``` ### Video Understanding Summarize long-form video and answer questions about what happens in it. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `messages` | array | Required | - | Chat messages. Content may be a string or an array of blocks (`text`, `image_url`, `video_url`). | | `max_tokens` | integer | Optional | 32768 | Maximum output tokens, including reasoning tokens. | | `temperature` | number | Optional | 1 | Sampling temperature. 1.0 in thinking mode, 0.7 in non-thinking mode. | | `top_p` | number | Optional | 0.95 | Nucleus sampling. 0.95 thinking, 0.80 non-thinking. | | `top_k` | integer | Optional | 20 | Top-k sampling. Set `-1` to disable. | | `min_p` | number | Optional | 0 | Minimum probability threshold relative to the top token. | | `presence_penalty` | number | Optional | 0 | Raise toward 2 to reduce endless repetition. | | `frequency_penalty` | number | Optional | 0 | Supported but outside the recommended parameter set. | | `repetition_penalty` | number | Optional | 1 | Passed through as an extra body field. | | `reasoning_effort` | string | Optional | xhigh | Reasoning depth — `xhigh`, `medium`, or `low`. | | `enable_thinking` | boolean | Optional | true | Emit a reasoning block before the answer. | | `preserve_thinking` | boolean | Optional | true | Keep reasoning from previous turns for consistency. | | `tools` | array | Optional | - | Tool definitions in OpenAI function-calling format. | | `tool_choice` | string \| object | Optional | auto | Tool selection policy. | | `response_format` | object | Optional | - | `json_object` for JSON mode, `json_schema` for structured outputs. | | `stop` | array | Optional | - | Up to 4 strings that halt generation. Not applied inside the reasoning block. | | `seed` | integer | Optional | - | Seed for reproducible sampling. | | `logprobs` | boolean | Optional | false | Return log probabilities for output tokens. | | `top_logprobs` | integer | Optional | - | Alternatives per position. Requires `logprobs`. | | `stream` | boolean | Optional | false | Enable streaming. | | `stream_options` | object | Optional | - | Set `include_usage` to receive token counts in the final chunk. | ## Model Details | Property | Value | | - | - | | Context Length | 262,144 | | Max Output Length | 131,072 | | Quantization | bf16 | | Input Modalities | text, image, video, file | | Output Modalities | text | | Supported Features | tools, reasoning, streaming, vision, json\_mode, structured\_outputs, logprobs, web\_search | | Hugging Face ID | `Qwen/Qwen3.8-27B` | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/qwen-3-8-27b/v1" ) response = client.chat.completions.create( model="qwen/qwen3.8-27b", messages=[{"role": "user", "content": "Hello!"}] ) print(response.choices[0].message.content) ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/qwen-3-8-27b/v1/chat/completions \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3.8-27b", "messages": [{"role": "user", "content": "Hello!"}] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/qwen-3-8-27b/v1", }); const response = await client.chat.completions.create({ model: "qwen/qwen3.8-27b", messages: [{ role: "user", content: "Hello!" }], }); console.log(response.choices[0].message.content); ``` # Qwen3-Embedding-8B Source: https://docs.aieev.com/models/qwen3-embedding-8b Multilingual embedding model with 4,096-dimensional vectors and 32K input. **Model ID:** `qwen/qwen3-embedding-8b` | **Endpoint ID:** `qwen3-embedding-8b` | **Parameters:** 8B | **Released:** 2025-06-05 | Input Price | Output Price | Max Input | Dimensions | | :-: | :-: | :-: | :-: | | \$0.010 / 1M | \$0.000 | 32,768 tokens | 4,096 | ## Overview Qwen3-Embedding-8B is a multilingual text embedding model that converts input text into dense vector representations. It accepts up to 32,768 tokens of input and outputs 4,096-dimensional embedding vectors. The model is well suited for semantic search, retrieval-augmented generation (RAG), recommendation systems, and classification or clustering tasks. Embedding models have no Playground — call them through the API. Deploy with AIR Container. Connect with the OpenAI SDK as-is. ## Pricing | Currency | Input (1M tokens) | Output (1M tokens) | | :- | -: | -: | | USD | \$0.010 | \$0.000 | | KRW | ₩14.5 | ₩0 | ## Key Features * Multilingual embeddings across a wide range of languages * Long input support up to 32,768 tokens * High-quality 4,096-dimensional vector output * Batch embedding for high-throughput processing ## Use Cases ### Semantic Search Embed queries and documents into the same vector space to find results by meaning rather than exact keyword match. ### RAG (Retrieval-Augmented Generation) Generate embeddings for a knowledge base and retrieve the most relevant passages to ground LLM responses in your own data. ### Recommendation Systems Represent items and user preferences as vectors to power similarity-based recommendations. ### Classification & Clustering Use embedding vectors as features for downstream classification or to group similar texts through clustering. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `model` | string | Required | - | Model ID to use for embedding generation | | `input` | string \| array | Required | - | Text to embed. Accepts a single string or an array of strings for batch embedding | ## Model Details | Property | Value | | - | - | | Dimensions | 4,096 | | Max Input Length | 32,768 tokens | | Input Modalities | text | | Output | embedding | | Batch Input | Supported (array of strings in `input`) | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language (Python, cURL, Node.js). ```python Python theme={null} from openai import OpenAI client = OpenAI( api_key="YOUR_API_KEY", base_url="https://ap-1.aieev.cloud/endpoints/qwen3-embedding-8b/v1" ) response = client.embeddings.create( model="qwen/qwen3-embedding-8b", input=["Hello, world!", "AirCloud makes deploying models easy."] ) for item in response.data: print(item.index, len(item.embedding)) # 4096 dims per vector ``` ```bash cURL theme={null} curl https://ap-1.aieev.cloud/endpoints/qwen3-embedding-8b/v1/embeddings \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "qwen/qwen3-embedding-8b", "input": ["Hello, world!", "AirCloud makes deploying models easy."] }' ``` ```javascript Node.js theme={null} import OpenAI from "openai"; const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://ap-1.aieev.cloud/endpoints/qwen3-embedding-8b/v1", }); const response = await client.embeddings.create({ model: "qwen/qwen3-embedding-8b", input: ["Hello, world!", "AirCloud makes deploying models easy."], }); response.data.forEach((item) => { console.log(item.index, item.embedding.length); // 4096 dims per vector }); ``` ## Tags `embedding` `8B` `multilingual` `semantic-search` `open-source` # Qwen3-TTS Source: https://docs.aieev.com/models/qwen3-tts Multilingual text-to-speech model with custom voice cloning support. **Model ID:** `qwen/qwen3-tts-customvoice` | **Endpoint ID:** `qwen3-tts` | **Parameters:** 1.7B | **Released:** 2026-01-22 | Input Price | Output Price | Languages | Voices | | :-: | :-: | :-: | :-: | | \$0.080 / 1K chars | \$0.000 | EN · ZH · JA · KO | 9 presets + custom | ## Overview Qwen3-TTS-12Hz-1.7B-CustomVoice is a multilingual text-to-speech model from the Qwen3 family. With 1.7 billion parameters, it delivers high-quality speech synthesis across English, Chinese, Japanese, and Korean. The model features 9 preset voices and supports custom voice cloning, making it versatile for various applications. Operating at a 12Hz token rate, it provides efficient audio generation while maintaining natural-sounding output. Try the model in the playground. Deploy with AIR Container. Learn how to use the API. ## Pricing TTS models are billed by **input characters**, not tokens. | Currency | Input (1,000 characters) | Output | | :- | -: | -: | | USD | \$0.080 | \$0.000 | | KRW | ₩116 | ₩0 | ## Key Features * 1.7B parameter model with high-quality multilingual speech synthesis * Supports English, Chinese, Japanese, and Korean * 9 diverse preset voices with custom voice capability * 12Hz token rate for efficient audio generation * Built on Qwen3 architecture with strong language understanding ## Use Cases ### Narration Generation Generate natural voice narration for video content and audiobooks. **Input Text:** > Life is like a box of chocolates. You never know what you're gonna get. ### Voice Announcements Create voice announcements and notifications with various voice styles. **Input Text:** > Your order has been confirmed and will be delivered within 3 business days. ### Conversational AI Voice Generate natural voice responses for chatbots and virtual assistants. **Input Text:** > I'd be happy to help you with that! Let me check your account details. ## Parameters | Parameter | Type | Required | Default | Description | | - | - | - | - | - | | `input` | string | Required | - | Text to convert to speech | | `voice` | enum | Optional | `"serena"` | Voice preset | | `response_format` | enum | Optional | `"mp3"` | Output audio format | | `speed` | number | Optional | 1 | Speech speed multiplier (0.25-4.0) | ## Quick Start Generate an API key from your [AirCloud account](https://aieev.com). Replace `YOUR_API_KEY` with your actual key and choose your preferred language. ```python Python theme={null} import requests response = requests.post( "https://ap-1.aieev.cloud/endpoints/qwen3-tts/v1/audio/speech", headers={ "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" }, json={ "model": "qwen/qwen3-tts-customvoice", "input": "Hello, welcome to AirCloud!", "voice": "serena", "response_format": "mp3" } ) with open("output.mp3", "wb") as f: f.write(response.content) ``` ```bash cURL theme={null} curl --request POST \ --url https://ap-1.aieev.cloud/endpoints/qwen3-tts/v1/audio/speech \ --header 'Authorization: Bearer YOUR_API_KEY' \ --header 'Content-Type: application/json' \ --data '{ "model": "qwen/qwen3-tts-customvoice", "input": "Hello, welcome to AirCloud!", "voice": "serena", "response_format": "mp3" }' \ --output output.mp3 ``` ```javascript Node.js theme={null} const response = await fetch( "https://ap-1.aieev.cloud/endpoints/qwen3-tts/v1/audio/speech", { method: "POST", headers: { "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" }, body: JSON.stringify({ model: "qwen/qwen3-tts-customvoice", input: "Hello, welcome to AirCloud!", voice: "serena", response_format: "mp3" }) } ); const buffer = await response.arrayBuffer(); require("fs").writeFileSync("output.mp3", Buffer.from(buffer)); ``` ## Tags `open-source` `tts` `1.7B` `custom-voice` `multilingual` `multi-voice` # Product Updates Source: https://docs.aieev.com/release-notes/index New features, fixes, and improvements for the AirCloud platform. ## Air Assistant, credit breakdown and expiry, payment improvements, GPU auto-upgrade, and replica timeline **Air Assistant agent (beta)** Ask about the official documentation and your own account in plain language, right inside the AirCloud console. Open it with the **Air Assistant** button in the console header. See the [Air Assistant](/docs/console/air-assistant) guide for details. * **Documentation help**: Ask about AirCloud features, how-tos, Autoscaling, Air API, and more. Answers are grounded in the official docs and come with links to the relevant pages. * **Account lookups**: Check available GPUs and their prices, endpoint and replica status, usage, credits, and invoices. * **Scoped to your access**: Only organizations and projects the signed-in user can access are queried, and secrets such as API keys are never shown. * **Read-only beta**: For now it only answers questions and explains how to use the platform. Creating, stopping, editing, or deleting resources still happens in the console. * **Suggested and follow-up questions**: Suggested questions help you get started, and related follow-ups appear below each answer. * **Conversation controls**: Start a new conversation or download the current one as a file. Reopening past conversations is not supported yet. * **Data handling**: Questions and answers are kept for 30 days by default and processed by Air API models served by AirCloud. Avoid entering sensitive information. * **Double-check what matters**: AI answers can be wrong. Verify costs, payments, and resource status on the corresponding console screens. **Where your credits came from, and when they expire** See what your balance is made of and when each part expires. * **Credit breakdown**: **Credit breakdown** on the Billing page lists your remaining credits by source (payments, sign-up credit, promotions, rewards, and more) and whether each is paid or free. * **Expiry dates**: Each credit shows its expiry date and days remaining. Free credits and credits closest to expiring are used first. * **Expiry reminders**: You get a notification when some of your credits are about to expire. * **Promo code deadlines**: Promo codes can now have a redemption deadline, and credits granted by a code can carry their own validity period. **Cancel unused payments, with no time limit** * **Exact eligibility**: Whether a payment can be cancelled is now decided by **whether the credits granted by that payment are still untouched**, not by the organization's total balance. A payment whose credits were used even partially cannot be cancelled; an unused one can, regardless of how long ago it was made. The 7-day limit is gone. * **Auto top-up included**: Auto top-up charges made with a saved card can be cancelled when unused. Recurring contracts settled offline are not covered. * **Before deleting an organization**: The organization deletion dialog (including a last owner's account withdrawal) shows how many of your own card payments can still be cancelled, with a direct link to Payment History. * **Clear failure reasons**: When a card payment fails, the console tells you why — issuer decline, additional authentication required, overseas payments blocked — and what to try next. * **Card receipt link**: The payment confirmation email links straight to the card issuer's receipt. * **Extra invoice recipients**: Postpaid organizations can send invoices to addresses outside the organization, such as an accounting contact. **Upgrade to an equal-or-better GPU when yours is busy** Choose what happens when the GPU you picked has no free capacity. * **On (default)**: Your GPU is tried first; if none is free, the endpoint starts right away on an equal-or-better GPU in the same family. You are still billed at the rate of the GPU you selected. * **Off**: The endpoint runs only on exactly the GPU you selected and waits until one frees up. Useful for benchmarks and other work where the GPU model affects results. * **Where to set it**: In the container creation flow and under Resources in container settings. If your GPU is sold out, you can turn auto-upgrade on right from the creation screen. **See when replicas scaled up and down** The container's runtime overview now shows when autoscaling added or removed replicas, alongside your other metrics. * **Active replicas card**: At the top of the runtime overview, one card shows how the replica count changed and when each replica was running. Replicas that ran only briefly appear as dots. * **Min and max guides**: The autoscaling minimum and maximum replica counts are drawn as dashed lines, so you can see how close you are to the limit. Containers with autoscaling off show their fixed replica count instead. Hover ⓘ to see how replicas are scaled. * **Scale markers**: Every metric chart marks the moments the replica count changed with a vertical dashed line, so you can compare how requests, latency, GPU utilization, and more changed before and after each scale. * **Drag to zoom**: Drag across any chart to zoom every chart on the page into that range, re-queried at a finer interval. Click Reset zoom to go back to the previous range. * **Default metric order**: Requests, errors, and latency now come first by default. Any order you arranged yourself is kept. **Other improvements** * **Your time zone**: Dates and times in the console follow your device's time zone, and emails and billing documents label the time zone they use. * **Environment variable placeholders**: When you create a container, `{endpoint_id}`, `{endpoint_name}`, and `{project_id}` in environment variable values are replaced with the actual values. The container name is fixed at creation time. * **GPU locked by templates**: When a template specifies an instance type, the GPU selection is locked to that type when you create a container from it. * **Volume mounts carried over**: Creating a container from an existing one now carries over its volume mount settings too. * **USD organizations**: Organizations paying in USD see balances, rates, payments, and exports in a single consistent unit. ## Long-term rentals, in-console requests, unified search, and account controls **Long-term rentals** GPU reservations are now called **long-term rentals**, and the whole flow lives in the console. * **From one month**: The minimum term dropped from three months to one, with presets up to a year and a lower hourly rate the longer you rent. * **Priced before you commit**: The rental screen shows the hourly rate, the discount applied, and the total for the term before you submit. * **Inquiry in the console**: Send a rental inquiry from the same page, track it as a request, and withdraw it if plans change. Our team replies within one business day. * **Rental notifications**: Get notified when a rental completes, starts, is about to expire, and expires. Start and expiry also arrive by email. * **Clearer status**: Rentals are listed as Requested, Scheduled, Active, Expired, or Cancelled, with days remaining. **Requests, in the place you get stuck** Ask for what you need from the screen where you needed it, instead of opening a separate ticket. * **Request a GPU, template, or model**: Each picker now has an entry point for "what I need isn't here". * **My requests**: Every request — waitlists, limit increases, and catalog requests — is tracked in one place, with our team's reply attached. * **Outcome notifications**: You are notified when a request is received and when it is handled. **Unified console search** * **One search box**: Find containers, projects, models, keys, members, rentals, and requests from a single search in the header. * **Documentation included**: Search results reach into the documentation site, linking straight to the relevant section. * **Run actions**: Start common actions — create a container, invite a member, issue an API key — without navigating there first. **Account and organization controls** * **Change your password**: Set a new password directly in Account Settings. All devices sign out afterward. * **Notification settings**: A settings tab lets you choose exactly which events reach the console, your desktop, and your inbox, with a guide to what each notification means. * **Delete an organization or withdraw**: Both are now self-service, with an up-front check of what has to be settled first and what will be irrecoverably removed. * **A place to start**: Users who don't belong to an organization yet land on a start screen instead of an empty console. **Containers** * **Mount a volume at several paths**: One volume can be mounted at more than one path inside the container. * **Templates, regrouped**: The template picker is organized by what you are trying to do — the workload, how you reach it, and what varies inside. * **Live status**: Container status updates on its own, without refreshing or polling. ## GPU availability, create from existing container, revamped usage & billing, and expanded notifications **GPU availability and resource requests** Check GPU stock before you deploy, and request more resources right from the console when you hit a limit. * **Availability at a glance**: The GPU list in the container create flow now shows an availability level per instance type, so you know what can be deployed before you try. * **Waitlist**: For GPUs that aren't currently available, join a waitlist and get notified when they become available again. * **Quota increase requests**: Request a quota increase directly in the console — no external inquiry needed. Requests can be made from the replica settings and the limits page at any time. * **Better GPU list**: The GPU list is sorted by hourly price, with a refresh button to pull the latest stock. **Create from an existing container** Spin up a container with the same configuration without setting everything up again. * **Reuse a configuration**: Create a new container from an existing one's settings — instance, image, scaling, and more. Only the configuration is carried over; no data is copied. * **Edit before creating**: Change the name, endpoint URL, and environment variables before the new container is created. **Revamped usage & billing experience** It's now much clearer what you were charged and why. * **Redesigned billing pages**: Charging, payment methods, and payment history are organized into tabs, and payment history can be exported as CSV. * **Redesigned usage & settlement views**: The organization usage pages have been rebuilt with filters, summary cards, aggregate charts, and a transaction timeline. * **Charge breakdown**: Settlement details now show how each amount was computed (unit price × hours × instance count). * **Reserved usage, separated**: Reserved (prepaid) usage appears in charts and tables distinctly from on-demand usage, with its relationship to total spend explained. * **Actual prices everywhere**: Lists and the create flow show the price you'll actually be charged, and the create dialog includes a 10-minute billing estimate. * **Unified credit unit**: Balance and pricing displays now use a single credit (C) unit. **Expanded notifications** Stay on top of your containers and billing with more granular notifications. * **Deployment complete**: Get notified when a container deployment finishes. * **Reserved device lifecycle**: Receive notifications for key reserved-device moments such as start and upcoming expiry — start and expiry are also delivered by email. * **Billing alerts**: Get notified about low balance, auto top-up failures, and overdue invoices so you can act before service is interrupted. * **Notification guide**: See which notifications arrive in the console, on your desktop, or by email from the guide on the notifications page. * **Mark as read individually**: Mark notifications as read one by one, with the read state reflected instantly. **Other improvements** * **Organization switcher**: The console header now shows which organization you are working in. An account belongs to one organization, so the switcher only appears if you hold more than one membership. * **Model pages, unified**: Public model pages now share the console's new design, and you can try models in the Playground without signing in. Model descriptions are available in Korean. * **Per-replica logs**: The log sidebar is now organized by replica, showing running/stopped status, with per-replica viewing and bulk download. * **Volume resize**: Increase the size of a persistent volume that's already in use. * **Shared memory size**: Set the shared memory (shm) size when creating a container. * **Inline API key issuance**: Issue an API key without leaving the Air API page, with the endpoint address and pricing pinned on screen. * **Better dashboard charts**: Container dashboard charts are easier to read, with new "since deployment" and "since creation" date range presets. * **Refined container create flow**: The persistent volume choice now comes before GPU selection, and the data-loss warning was moved somewhere more visible. ## Redesigned console, real-time notifications, and Persistent Volume **Redesigned console pages** We've refreshed the console's most-used pages for a cleaner, more consistent experience. * **Container create**: A rebuilt create flow — a clearer default mode, a card-based layout, and a configuration summary before you deploy. Start from a template with recommended items and an auto-filled name. * **Organization overview**: Redesigned organization page that surfaces status and usage at a glance. * **Project overview**: A reworked overview that brings your recent containers, recommended quick-start templates, and an Air API usage summary together on one page. * **Consistent navigation**: Cleaner, header-free pages and unified breadcrumb navigation throughout the console. **Real-time notifications** Notifications now arrive the moment something happens — no page refresh needed — and are collected in one place. * **Instant delivery**: Events such as deployment status changes and announcements appear in real time. * **Notification center**: Browse, page through, and dismiss past notifications from a single view. * **Balance & usage alerts**: Get notified about low balance, GPU usage charges, and payment failures so you can act before service is interrupted. **Persistent Volume** Persistent volumes are now more flexible across your deployments. * **Works with autoscaling**: Attach a volume to deployments that use autoscaling and multiple replicas. * **New or existing volume on create**: Choose a fresh volume or reuse an existing one when creating a deployment. * **Shared across deployments**: A single volume can be attached to multiple deployments, and the picker shows which deployments are already using it. * **Edit while stopped**: Enable, disable, or swap the attached volume while a deployment is stopped. **Other improvements** * **Container tags**: Organize and filter your containers with tags. * **Replica quota at start**: Replica quota is now checked when you start a deployment, with an in-line dialog to adjust replicas or request more quota. * **Web Terminal replica selection**: When a container has multiple replicas, choose which one to connect to, and the session auto-reconnects if a replica is replaced. * **SSH key scoping**: Apply a registered SSH key to specific containers, and enable or disable it without removing it. * **Inline email verification**: Enter a verification code directly during signup; disposable email domains are now blocked at registration. * **Better Air API usage page**: More accurate spend totals, consistent filters, and model display names across charts and records. * **Persistent list views**: Sorting, filters, search, and pagination are kept in the URL, so your view is restored when you navigate back from a detail page. * **New brand color**: Updated the primary brand color across the console. ## Web Terminal, AirCloud CLI, SSH access, and Shared Storage AirCloud endpoint access and storage capabilities have been expanded. You can now connect to running containers from the browser or your local terminal, manage endpoints with the AirCloud CLI, use SSH-based development workflows, and share persistent storage across endpoints and replicas. **Web Terminal** Browser-based terminal access is now available for custom container endpoints. * **SSH-free terminal access**: Open a terminal session through AirCloud's exec-based connection without installing `sshd` or configuring SSH keys. * **Custom container support**: Custom container endpoints now show a **Terminal** button on the endpoint overview page. * **Template environment access**: AirCloud-provided templates such as Jupyter Notebook and Code already include terminal access through their web UI. * **Replica selection**: For endpoints with multiple replicas, select the replica you want to connect to. If only one replica is running, AirCloud connects automatically. * **Simple session exit**: Exit the terminal with `exit` or `Ctrl-D`. The terminal window closes automatically shortly after the session ends. * **Connection retry guidance**: If the terminal stays in the connecting state for a long time, try again from a new browser window or incognito mode. **AirCloud CLI** The new `aircloud-cli` lets you manage AirCloud endpoints and access running containers from your local terminal. ```bash theme={null} pip install aircloud-cli ``` Key capabilities: * **CLI configuration**: Configure the API base URL and API key with `aircloud config`. * **Authentication context**: Use `aircloud whoami` to verify your organization, project, user, and API key context. * **Endpoint management**: List, inspect, start, stop, scale, and patch endpoints from your terminal. * **Replica inspection**: View live replica status for active endpoints. * **Endpoint logs**: Retrieve endpoint logs, list log files, inspect per-replica logs, and fetch specific log ranges for debugging. * **Exec-based shell access**: Use `aircloud exec ` to open an interactive shell inside a running container without SSH setup. * **Replica pinning**: Connect to a specific replica with `aircloud exec -r `. * **Custom shell command**: Start a different shell or command with `aircloud exec -c "/bin/sh"`. **SSH access via AirCloud CLI** AirCloud CLI now supports key-based SSH access into containers. * **CLI-based SSH access**: Use `aircloud ssh ` to connect to supported containers from your local terminal. * **SSH key injection**: Register an SSH public key in the AirCloud console and inject it into selected endpoints. * **Template support**: AirCloud-provided Jupyter Notebook and Code templates support SSH access out of the box. * **Custom container support**: To use SSH with custom images, install `sshd`, add injected public keys to `authorized_keys`, and start the SSH server inside the container. * **Standard SSH workflows**: Use SSH-based workflows such as `scp` file transfer, `ssh -L` port forwarding, and VS Code Remote SSH. * **Replica-specific SSH**: Pin an SSH session to a specific replica with `aircloud ssh -r `. * **Tunnel-only mode**: Open only the SSH tunnel with `aircloud ssh --tunnel-only` for advanced workflows. **AirCloud Exec vs SSH** AirCloud now supports two ways to access running containers, depending on your workflow. | Feature | `aircloud exec` | `aircloud ssh` | | - | - | - | | Image requirements | No image changes required | Custom images require `sshd` | | Key setup | API key only | SSH key registration required | | File transfer with `scp` | Not supported | Supported | | Port forwarding with `ssh -L` | Not supported | Supported | | VS Code Remote SSH | Not supported | Supported | | Best for | Fast shell access and debugging | SSH-based development, file transfer, and port forwarding | **Shared Storage** Shared Storage is now available for persistent volumes across endpoints and replicas. * **One volume, multiple endpoints**: Attach the same persistent volume to multiple endpoints within a project. * **Shared storage across replicas**: Multiple replicas in the same endpoint can mount and access the same volume. * **Data independent from containers**: Keep datasets, model checkpoints, logs, and output artifacts independent from the container lifecycle. * **Flexible volume attachment**: Create a new persistent volume when creating an endpoint, or attach an existing volume to another endpoint. * **Read-write shared access**: Shared volumes support read-write access, but applications should handle concurrent writes and file locking. Learn how to install and use the AirCloud CLI. Learn how to access running containers. Learn how to share persistent volumes across endpoints and replicas. ## Air API General Availability Air API is now generally available. Access AirCloud's AI models through an OpenAI-compatible interface with transparent per-token pricing. * **OpenAI-compatible API**: Use existing OpenAI SDKs and code to access AirCloud models with minimal changes. * **Public pricing**: Per-token pricing is now published for all models with pay-as-you-go billing. * **Air API Playground**: Test models directly in the browser without writing code. Learn how to use Air API. Explore all available models and pricing. ## AirCloud Zero Release (RC) AirCloud Zero is now available. Deploy Air Container and run AI inference workloads at a lower cost by leveraging crowdsourced GPU resources. * **Lower-cost container deployment**: Deploy Air Container at a lower cost than standard AirCloud by leveraging crowdsourced GPU resources. * **Built for inference workloads**: Best suited for AI inference workloads where cost efficiency and flexibility matter most. * **Selectable at deployment time**: Choose AirCloud Zero as the Cloud Type when creating an Air Container endpoint. AirCloud Zero is currently in Release Candidate (RC). Some features and availability may be limited until General Availability (GA). ## External API expansion and new model endpoints The External API now covers full endpoint lifecycle management. Three new AI models are available on the platform. **External API: New endpoints** Programmatic control over your deployments is now complete with five new endpoints: * **List Endpoints**: Retrieve a paginated list of all accessible endpoints with status and configuration details. * **List Replicas**: View live replica status for any active endpoint. * **List/Get Log Files**: Access endpoint log files and download their contents for debugging. * **Patch Endpoint**: Update runtime settings (replica count, scaling config) for inactive endpoints. * **Get API Key Context**: Verify your API key's authentication scope and permissions. View the complete API documentation. **New models available** Three new models are now available through the [Air API Playground](https://ap-1.aieev.cloud:3000): | Model | Type | Input | Output | | - | - | - | - | | [Qwen3-TTS](/models/qwen3-tts) | Multilingual TTS with custom voice cloning | \$0/1M tokens | \$0/1M tokens | | [Qwen3.5-9B](/models/qwen3-5-9b) | Efficient 9B with vision support | \$0.05/1M tokens | \$0.15/1M tokens | | Qwen3.5-35B-A3B | High-performance MoE (35B) | \$0.1625/1M tokens | \$1.3/1M tokens | Explore all available models and pricing. ## Jupyter Notebook, Web IDE, and Persistent Volume support New development environments and storage capabilities for GPU workloads. **Jupyter Notebook environment** GPU-powered Jupyter Notebook environments are now available as ready-to-use templates. Start developing immediately without any setup. * Pre-configured with TensorFlow, PyTorch, and other major libraries * Full GPU resource access for experimentation and model development * Browser-based access — no local installation required * Built-in Jupyter AI integration **Web IDE (Code) environment** A VS Code-based Web IDE is now available directly in the browser for cloud-native development. * Write and run code in the browser without a local development environment * Container-based isolated workspace for each session * Built-in development and debugging tools * Code assistant integration included **Persistent Volume** Data now persists beyond container lifecycle with the new persistent volume feature. * Store model checkpoints, logs, and data files across container restarts * Data management independent of container lifecycle * Ideal for long-running jobs and iterative experiments ## External API initial release Launched the AirCloud External API for programmatic endpoint management. Control your inference endpoints without leaving your terminal or CI/CD pipeline: ```bash theme={null} # Check endpoint status curl -X GET https://external.aieev.cloud:5000/external/api/v1/endpoints/{id} \ -H "Authorization: Bearer YOUR_API_KEY" # Scale replicas curl -X POST https://external.aieev.cloud:5000/external/api/v1/endpoints/{id}/scale \ -H "Authorization: Bearer YOUR_API_KEY" \ -d '{"replica_count": 3}' ``` Key capabilities: * **Get Endpoint Status**: Check current status, configuration, and health of any endpoint. * **Start/Stop Endpoint**: Start or stop endpoints on demand via API. * **Scale Replicas**: Adjust replica count for active endpoints to match traffic requirements. Get started with the External API. ## Air API beta launch, observability, dashboards, and UX upgrades Air API launches in beta alongside major improvements to observability, project dashboards, and security. **Air API (beta)** An OpenAI-compatible inference API is now available in beta. Access AirCloud's AI models with a single API key. * OpenAI SDK compatible — swap models without changing your code * API key authentication with per-key endpoint access control * Test models interactively in the Playground **Observability & Logs** Runtime logs are now searchable, filterable, and exportable: * **Log download and bulk export**: Download logs for offline analysis with single or batch export. * **Advanced log filtering**: Regex-based search and time-range filtering for faster troubleshooting. * **Raw log (JSON) view**: Inspect unprocessed log data alongside the structured view. * **Scaling history**: Track autoscale events, timeout-triggered changes, and error-driven replica adjustments over time. **Dashboards** New project-level and organization-level dashboards for usage visibility: * **Project dashboards**: Monitor status and usage at the project level with dedicated views. * **Organization usage breakdown**: View usage and cost distribution by project, endpoint, and instance type. * **Extended request metrics**: Cumulative request counts, job error rates, and other operational metrics. * **Transaction history filtering**: Filter billing records by type and status. **UX Improvements** * **Korean language support**: Full Korean UI now available. * **First-time user onboarding**: Guided tutorial flow for new users to deploy their first endpoint. * **In-product feedback**: Submit feedback directly from within the platform. **Security & Access** * **OpenAI-compatible API keys**: Issue API keys with OpenAI-compatible format. Control which endpoints each key can access. * **HTTPS endpoints**: Enforced HTTPS for all inference endpoints. * **Path-based endpoint addressing**: Moved from port-based to path-based routing with support for custom endpoint URLs. ## AirCloud General Availability AirCloud is now generally available. With this release, Air Container graduates from beta to GA. Deploy and operate your own container images on AirCloud's GPU infrastructure. **Air Container GA** * Deploy custom container images directly on GPU clusters * Autoscaling and scheduled scaling to match traffic patterns * Full control over runtimes, dependencies, and service configuration * Persistent storage integration for models and data Learn how to deploy containers. **Platform features** * **Time-based scaling**: Schedule minimum replica counts or enable/disable autoscaling by time of day. * **Custom endpoint URLs**: Use your own URL identifiers instead of system-generated IDs for cleaner integration. * **API Playground**: Test and integrate APIs interactively through the built-in Playground without writing code. * **One-click cluster deployment**: Reduce repetitive setup with templated, automated cluster deployments. * **Actionable error messages**: Detailed error guidance on failure screens to cut mean-time-to-resolution. * **Secure inference traffic (HTTPS)**: End-to-end HTTPS for all inference requests. ## Usage insights, autoscaling controls, and performance tuning New visibility into costs, smarter autoscaling, and infrastructure-level performance hardening. * **Usage & billing dashboards**: Monthly and daily usage visualization to track credit consumption and spending trends at a glance. * **Autoscaling sensitivity controls**: Configure autoscale responsiveness (Heavy / Normal / Light) to match your workload's characteristics—from bursty inference to steady throughput. * **Deployment template reuse**: Reuse existing deployment configurations to quickly spin up new endpoints with the same settings. * **Predictable scaling behavior**: Adjusted scale-in/out policies to reduce variability under varying load patterns. * **Concurrent request handling improvements**: Improved stability for large-file transfers and concurrent request handling under peak traffic. ## Zero-downtime operations Stability improvements so platform updates and scaling events don't disrupt running workloads. * **Zero-downtime updates**: Minimized service disruption during platform updates. * **Request drop prevention**: Improved handling during scale-in and updates to prevent in-flight request loss. * **Restart stability**: Event processing pipelines now handle component restarts without data loss or ordering issues. * **HTTPS adoption**: Began HTTPS rollout as the platform security baseline. ## Billing and team collaboration Introduced credit-based billing and multi-user collaboration so teams can manage costs and share resources. * **Credits-based billing**: Manage usage costs through a prepaid credit system with top-up and balance tracking. * **Team invites**: Invite team members to your organization via email for collaborative access to shared resources. * **Reserved capacity**: Distinguish between reserved (term-based) and on-demand resources for predictable cost planning. * **Billing automation**: Automated usage collection and settlement processing on scheduled intervals. ## Air Container beta launch and platform foundation upgrades Air Container beta is now available. Deploy custom container images on GPU infrastructure for the first time on AirCloud. **Air Container (beta)** * Deploy custom container images on GPU clusters * Basic autoscaling and monitoring support * Container health checks with automatic recovery **Infrastructure improvements** * **Custom metrics for user workloads**: Collect and display per-container metrics (e.g., vLLM) with configurable metric targets. * **Improved health checks**: Better readiness detection for containers with long boot times to prevent premature termination. * **Faster runtime environments**: Lighter, faster packaging and deployment structures for reduced startup times. * **Offline-friendly deployment**: Support for restricted-network environments with offline operation scenarios. * **Better model caching**: More efficient HuggingFace model cache sharing and management for faster cold starts. * **Reliable event capture**: Hardened autoscale and operational event capture for more stable scaling decisions.