Console
Use the Skytells Console to experiment with AI models through a fully interactive playground — no coding experience required.
What Is the Console?
The Skytells Console is a fully interactive, browser-based playground that communicates directly with Skytells APIs. It's built for everyone — from developers prototyping their next product to designers, researchers, content creators, and complete beginners who have never written a line of code.
Think of it as a control panel for every AI model on Skytells. You pick a model, fill in a form, click Run, and see the result instantly — no terminal, no IDE, no deployment. The Console handles authentication, request formatting, parameter validation, and output rendering so you can focus entirely on what you're building.
Why Use the Console?
- Zero coding required — every parameter is exposed as a visual form field (text inputs, dropdowns, sliders, toggles). Just fill in the blanks and hit Run.
- Instant visual previews — generated images render inline, audio plays back directly, video streams in the browser, and text outputs are formatted and syntax-highlighted. You see the result exactly as your users would.
- Built-in code generation — once you've crafted the perfect input in the form, switch to the Node.js, Python, or HTTP tab to grab a production-ready code snippet. The Console writes the code for you.
- Full schema documentation — every model's input and output schema is browsable right in the Console. See every parameter, its type, description, default value, and constraints without leaving the page.
- Transparent pricing — costs are shown before you run. You always know what a request will cost.
- Experiment freely — try different prompts, tweak parameters, compare outputs, and iterate in real time. The Console is designed for rapid experimentation.
The Console is available at skytells.ai/dashboard/console. Open any model from the model catalog and you'll land directly in its Console page.
Who Is the Console For?
The Console is designed to be approachable for every experience level:
| Audience | How They Use the Console |
|---|---|
| Complete beginners | Fill in a text prompt, click Run, and see AI-generated images, text, or audio — no setup needed |
| Designers & creatives | Rapid visual prototyping — generate images, iterate on prompts, compare aspect ratios and styles |
| Developers | Prototype API calls visually, then copy the auto-generated code into their apps |
| Product teams | Evaluate models before committing to integration — test quality, latency, and cost |
| Researchers | Explore model capabilities, test edge cases, and inspect raw JSON responses |
Prerequisites
Before using the Console, make sure you have:
An API Key
You need an active API key. If you don't have one, follow the Generating an API Key guide to create one from the Dashboard.
A Minimum Balance of $2
Your account must have at least $2 in credit to run models through the Console. You can add credit from the Billing page.
If your balance drops below $2, the Run button will be disabled. Top up your account to continue using the Console.
Console Layout Overview
When you open a model in the Console (for example, Skytells / TrueFusion), the page is organized into several distinct areas. Here's a complete walkthrough:
Breadcrumb Navigation
At the very top of the page, a breadcrumb trail shows your location:
Home > Dashboard > Console > [Model Name]Click any segment to navigate back to that level.
Model Header
Directly below, a prominent header displays:
- Model avatar and name — e.g.,
Skytells / TrueFusion - Model type badge — appears in the top-right corner (e.g.,
IMAGE,TEXT,AUDIO,VIDEO) - Back arrow — click
←to return to the Console model list
Model Info Badges
A row of badges provides critical details at a glance:
| Badge | What It Tells You |
|---|---|
| ✓ Official | This model is built and maintained by Skytells |
| ⓘ About | Links to the model's documentation and details page |
| ✓ Operational | The model is online and accepting requests. If it shows "Degraded" or "Down", expect issues |
| 💳 $0.03 / image | The cost per unit of output — varies by model (per image, per token, per second, etc.) |
| 🖥 H100 | The GPU hardware the model runs on (e.g., H100, A100, T4) |
| 🌐 Public | Visibility — "Public" means anyone can use it; "Private" means restricted to your organization |
Top Controls
Below the badges, three controls sit side by side:
| Control | Description |
|---|---|
| Model dropdown | Switch to a different model without leaving the Console (e.g., switch from TrueFusion to another model) |
| API Key field | Your API key is pre-filled and masked with dots. Click the 👁 eye icon to reveal it. This is the key used for all Console requests |
| ▶ Run button | Executes the model with your current inputs. Results appear in the Output panel within seconds |
Tab Navigation
Each model's Console page has four main tabs. These tabs let you move between running the model, inspecting its schema, browsing examples, and reading documentation — all in one place.
| Tab | Icon | What It Shows |
|---|---|---|
| Playground | ▶ | The interactive runner — this is where you input parameters and execute the model |
| API | 📋 | Full schema browser — input/output parameter definitions, types, constraints, and defaults |
| Examples | ✦ | Curated input/output pairs — see what good prompts look like and what the model produces |
| README | 📖 | Model documentation — usage notes, capabilities, limitations, and changelog |
The Playground — In Detail
The Playground tab is the heart of the Console. It's a fully interactive environment split into two panels: Input on the left and Output on the right.
Input Panel (Left Side)
The input panel is where you construct your request. It offers five different views, and you can switch between them at any time using the tabs at the top of the panel:
The Form view renders every model parameter as a visual form field. This is the default view and the best starting point for everyone — especially beginners.
- Text fields for string parameters (e.g.,
prompt) - Dropdowns for enum parameters (e.g.,
aspect_ratiowith options like1:1,16:9,4:3) - Sliders for numeric parameters (e.g.,
number_of_imageswith min/max constraints) - Toggles for boolean parameters (e.g.,
prompt_optimizeron/off) - Required fields are clearly marked with a red asterisk
- Descriptions appear below each field explaining what it does
- Advanced Options — click to expand and reveal additional, optional parameters
You don't need to know JSON, APIs, or programming. Just fill in the fields and click Run.
The JSON view shows the raw request payload as editable JSON. Useful for developers who want precise control over the input structure, or for pasting in a payload from another source.
The Node.js view shows an auto-generated code snippet that reproduces your current form inputs as a Node.js/TypeScript API call using the Skytells SDK. Copy this directly into your project.
The Python view shows the equivalent Python code snippet using the Skytells Python client. Same inputs, ready to paste into your Python project.
The HTTP view shows the raw cURL command for the request — including headers, URL, and JSON body. Useful for debugging, sharing with teammates, or using from any language.
Example: TrueFusion Image Model Parameters
When using the TrueFusion image generation model, the Form view shows:
| Parameter | Type | Description | Default | Constraints |
|---|---|---|---|---|
prompt | string | Text prompt for image generation | — | required |
aspect_ratio | dropdown | Image aspect ratio | 1:1 | 1:1, 16:9, 4:3, 3:2, 2:3, 3:4, 9:16, 21:9 |
number_of_images | slider | How many images to generate | 1 | min: 1, max: 9 |
prompt_optimizer | toggle | Automatically enhance your prompt for better results | true | — |
The prompt field is the primary input and always visible. Additional parameters like aspect ratio, image count, and prompt optimizer are under Advanced Options — click to expand them.
Output Panel (Right Side)
After clicking ▶ Run, the model processes your input and results appear in the output panel. The output panel has three tabs that let you inspect the result in different ways:
| Tab | What It Shows |
|---|---|
| 👁 Preview | A rich, visual rendering of the model's output — the format adapts to the output type (see below) |
| JSON | The raw JSON response from the API — every field, metadata, and URL |
| >_ Logs | Execution logs including timing, request ID, and debug information |
Before a model has been run, the Preview tab shows a placeholder: "Preview will appear here after running the model."
Output Preview Types
One of the most powerful features of the Console is its intelligent output preview. The Preview tab automatically detects the output type and renders it with the appropriate viewer — so you always see results in their native format, not as raw JSON blobs.
| Output Type | What the Preview Shows |
|---|---|
| Images | Generated images rendered inline at full resolution. Multiple images display in a grid. Click to enlarge. |
| Text | Formatted text output with syntax highlighting for code, markdown rendering for prose |
| Audio | Built-in audio player with play/pause, seek, and download controls |
| Video | Inline video player with playback controls, frame-by-frame seeking |
| Structured data | Formatted tables or JSON trees for structured outputs (e.g., classification results, extracted entities) |
| Files | Download links for generated files (PDFs, CSVs, etc.) |
This means a designer generating images sees a visual gallery, a developer working with text sees formatted output, and a researcher analyzing structured data sees clean tables — all without touching any code.
Browsing the API Schema
Switch to the API tab to explore a model's full schema. This is like built-in API documentation for every model on Skytells.
Sidebar Navigation
The left sidebar in the API tab has five sections:
| Section | What It Contains |
|---|---|
| Playground | Quick link back to the interactive runner |
| Schema | Detailed input/output parameter definitions — the technical spec for the model |
| API Reference | Endpoint URLs, authentication headers, and request format for this specific model |
| Examples | Curated input/output pairs showing real usage |
| README | Full model documentation |
Schema Browser
The Schema view has two sub-tabs:
- Input schema — every accepted parameter displayed as a table with columns for Name, Type, Description, Default, and Constraints. Toggle between Table and JSON views.
- Output schema — the structure of the response payload so you know exactly what to expect
This is especially useful for understanding a model's capabilities before integrating it. You can see every parameter, whether it's required, what values are valid, and what the defaults are — all without reading external documentation.
Pricing in the Console
Each model's Console page shows transparent pricing information so you know exactly what a run will cost before you execute:
- Official model badge — indicates the model uses standard Skytells pricing based on computational resources and inference time
- Cost per unit — shown in the badge row (e.g.,
$0.03 / image) - Cost breakdown — a pricing section shows the output cost and gives a concrete estimate (e.g., "generating 100 images should cost around $3")
- Learn more link — navigates to the full pricing page for the model
Always check the cost badge before running a model. Pricing varies by model — some charge per image, per token, per second of compute, or per API call.
Walkthrough: Your First Console Run
Here's a step-by-step guide to running your first model in the Console:
Open the Console
Go to skytells.ai/dashboard/console and select a model — for example, TrueFusion for image generation.
Verify Your API Key
Your API key should be pre-filled in the top bar. If it's not, paste your key into the API Key field. Make sure you have at least $2 in credit.
Enter Your Prompt
In the Playground tab, type a description into the Prompt field. For TrueFusion, try something like:
A serene Japanese garden with cherry blossoms and a stone bridge, soft morning light
Adjust Parameters (Optional)
Click Advanced Options to fine-tune the output:
- Set Aspect Ratio to
16:9for a widescreen image - Increase Number of Images to
4to compare variations - Leave Prompt Optimizer enabled to let the model enhance your prompt
Click Run
Click the ▶ Run button. The model processes your request and results appear in the Output panel within seconds.
View Results
Switch between Preview (visual output), JSON (raw response), and Logs (timing/debug info). If you're happy with the result, switch to the Node.js or Python tab on the input side to grab the code and use it in your application.
Tips for Getting the Most Out of the Console
- Start with the Form view — it validates inputs, shows required fields, and prevents malformed requests
- Use the code tabs to bridge from experimentation to production — prototype in the form, copy the generated Node.js/Python/cURL code into your app
- Check the Examples tab before writing your own prompts — see what inputs produce great results for each model
- Compare outputs by running the same prompt with different parameters (e.g., different aspect ratios or image counts)
- Monitor the Logs tab for timing, request IDs, and debug information if something doesn't look right
- Switch models instantly using the dropdown — no need to navigate away from the Console
- Use the Schema tab to understand what a model accepts before you build around it
How is this guide?