# Dataset Preparation (https://docs.segmind.com/docs/fine-tuning/dataset-preparation)
Deprecated. How fine-tuning datasets were packaged as a ZIP and uploaded, with guidelines for Flux Dev, Flux Pro, Fast Flux, and Flux Kontext.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
Before fine-tuning, prepare your dataset as a **ZIP file**. Then upload it to a **public URL** or via the Segmind **data upload endpoint**.
***
## Upload Endpoints [#upload-endpoints]
* **Flux Dev** → [Upload here](/docs/fine-tuning/apis/flux#4-get-fine-tune-data-upload-pre-signed-url)
* **Flux Kontext** → [Upload here](/docs/fine-tuning/apis/flux-kontext#4-get-fine-tune-data-upload-pre-signed-url)
* **Fast Flux** → [Upload here](/docs/fine-tuning/apis/fast-flux#4-get-fine-tune-data-upload-pre-signed-url)
* **Flux Pro** → [Upload here](/docs/fine-tuning/apis/flux-pro#4-get-fine-tune-data-upload-pre-signed-url)
⚠️ Use **public or private upload** depending on your model.
***
## Pipeline-Specific Guidelines [#pipeline-specific-guidelines]
### 🔹 Flux Dev [#-flux-dev]
* Upload 10–20 images in a ZIP.
* Select a `trigger_word` → model learns to associate this word with your subject/style.
* Captions: Auto-generated or custom `.txt` per image.
* Example: `img_0.jpg` → `img_0.txt`.
* Image resolution: \~1024×1024 (larger images will be resized).
* Style LoRAs: Use images highlighting distinctive features, keep style consistent.
* Character LoRAs: Show subject in different settings/expressions.
* Avoid different haircuts, ages, or excessive hand-face overlaps.
📌 **Reference Dataset:** Coming soon.
***
### 🔹 Flux Pro [#-flux-pro]
* At least 5 high-quality images.
* Supported: JPG, JPEG, PNG, WebP.
* Optional `.txt` files with same name as images.
* Example: `sample.jpg` → `sample.txt`.
* Package all into a single ZIP.
📌 **Reference Dataset:** Coming soon.
***
### 🔹 Fast Flux [#-fast-flux]
* Upload 10–20 images in a ZIP.
* Select a `trigger_word`.
* Captions: Auto-generated or custom `.txt` per image.
* Example: `img_0.jpg` → `img_0.txt`.
* Image resolution: \~1024×1024.
* Style LoRAs: Use varied subjects, keep style consistent.
* Character LoRAs: Avoid hair/age variations & hand-face overlaps.
📌 **Reference Dataset:** Coming soon.
***
### 🔹 Flux Kontext [#-flux-kontext]
* Paired images (`INDEX_start.ext` and `INDEX_end.ext`).
* `INDEX.txt` optional (edit instructions).
* Use zero-padded indexes (`01`, `02`, …).
📌 **Reference Dataset:** [Kontext Fine-Tune Samples](https://github.com/segmind/kontext-finetune-datasets/)
# Fine-Tuning (Deprecated) (https://docs.segmind.com/docs/fine-tuning)
The Segmind fine-tuning service is deprecated and no longer accepts new training jobs. Existing fine-tuned models remain available for inference.
The Segmind Fine-Tuning service has been deprecated and is no longer available for new training jobs. Existing fine-tuned models will continue to be accessible for inference until further notice.
If you have questions about your existing fine-tuned models, please reach out via our [Discord community](https://discord.com/invite/G5t5k2JRN6).
# Inference Guide (https://docs.segmind.com/docs/fine-tuning/inference-guide)
Deprecated. How to run inference on an existing fine-tuned model once its status is AVAILABLE, across Flux Dev, Flux Kontext, Fast Flux, Flux Pro, and Qwen.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
After fine-tuning completes and status is `AVAILABLE`, your model is ready for inference.
***
## Flux Dev [#flux-dev]
* **Model URL:** `https://segmind.com/models/`
* **Get model\_name:** From `slug` in [response](/docs/fine-tuning/apis/flux#sample-response-1).
* **API Details:** `https://segmind.com/models//api`
***
## Flux Kontext [#flux-kontext]
* **Universal model:** `https://segmind.com/models/flux-kontext-finetuned`
* **API Details:** `https://segmind.com/models/flux-kontext-finetuned/api`
* **Differentiate by:** `finetune_id` (from [response](/docs/fine-tuning/apis/flux-kontext#sample-response)).
***
## Fast Flux [#fast-flux]
* **Universal model:** `https://segmind.com/models/flux-dev-finetuned`
* **API Details:** `https://segmind.com/models/flux-dev-finetuned/api`
* **Differentiate by:** `finetune_id` (from [response](/docs/fine-tuning/apis/fast-flux#sample-response)).
***
## Flux Pro [#flux-pro]
* **Available universal models:**
* `https://segmind.com/models/flux-pro-finetuned`
* `https://segmind.com/models/flux-pro-fill-finetuned`
* `https://segmind.com/models/flux-pro-canny-finetuned`
* `https://segmind.com/models/flux-pro-depth-finetuned`
* `https://segmind.com/models/flux-pro-1.1-ultra-finetuned`
* **API Details:**
* `https://segmind.com/models/flux-pro-finetuned/api`
* `https://segmind.com/models/flux-pro-fill-finetuned/api`
* `https://segmind.com/models/flux-pro-canny-finetuned/api`
* `https://segmind.com/models/flux-pro-depth-finetuned/api`
* `https://segmind.com/models/flux-pro-1.1-ultra-finetuned/api`
* **Differentiate by:** `finetune_id` (from [response](/docs/fine-tuning/apis/flux-pro#sample-response)).
***
## Qwen [#qwen]
* **Universal model:** `https://segmind.com/models/qwen-image-finetuned`
* **API Details:** `https://segmind.com/models/qwen-image-finetuned/api`
* **Differentiate by:** `finetune_id` (from [response](/docs/fine-tuning/apis/qwen#sample-response)).
# Pricing (https://docs.segmind.com/docs/fine-tuning/pricing)
Deprecated. Historical Segmind fine-tuning pricing, charged per second by GPU type, with estimated cost and training time for 1000 steps.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
### Segmind Fine-Tuning Pricing [#segmind-fine-tuning-pricing]
Our fine-tuning service offers flexible pricing based on model type and GPU used.
#### 🔹 Flux [#-flux]
Charged **per second** based on the GPU selected:
| GPU Type | Description | Cost per Second | Est. Cost (1000 steps) | Est. Time (1000 steps) |
| ------------------ | -------------------- | --------------- | ---------------------- | ---------------------- |
| NVIDIA\_A100\_40GB | Balanced performance | $0.0020 | \~$6 | \~50m |
| NVIDIA\_H100 | Fastest training | $0.0043 | \~$8 | \~32m |
| NVIDIA\_L40S | Cost-efficient | $0.0014 | \~$5 | \~55m |
#### 🔹 Flux Kontext [#-flux-kontext]
Charged **per second** using **NVIDIA\_H100**:
| GPU Type | Description | Cost per Second | Est. Cost (1000 steps) | Est. Time (1000 steps) |
| ------------ | ---------------- | --------------- | ---------------------- | ---------------------- |
| NVIDIA\_H100 | Fastest training | $0.0043 | \~$6 | \~22m |
#### 🔹 Flux Pro [#-flux-pro]
Charged **per training job**, based on total steps:
| Number of Steps | Cost (Credits) |
| --------------- | -------------- |
| Fewer than 150 | 3 |
| 150 to 500 | 6 |
| More than 500 | 9 |
**Example:** Training with 1000 steps will cost **9 credits** and take approximately **39 minutes** (falls under "More than 500" tier).
#### 🔹 Fast Flux [#-fast-flux]
Charged **per second** using **8x Nvidia H100**:
| GPU Type | Description | Cost per Second | Est. Cost (1000 steps) | Est. Time (1000 steps) |
| -------------- | ------------------- | --------------- | ---------------------- | ---------------------- |
| 8x Nvidia H100 | Ultra-Fast training | $0.0153 | \~$2 | \~1m54s |
#### 🔹 Qwen [#-qwen]
Charged **per second** using **NVIDIA\_H100**:
| GPU Type | Description | Cost per Second | Est. Cost (1000 steps) | Est. Time (1000 steps) |
| ------------ | ---------------- | --------------- | ---------------------- | ---------------------- |
| NVIDIA\_H100 | Fastest training | $0.0043 | \~$7 | \~29m |
***
**Note:** Estimated costs and times for 1000 steps are based on analysis of recent training jobs and may vary depending on dataset complexity and training parameters.
# Fine tuning GPU options (https://docs.segmind.com/docs/fine-tuning/which-gpu)
Deprecated. Finetune jobs could be run with different GPUs, affecting speed, price and quality.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
#### Sample Comparison [#sample-comparison]
**Overview:**
In this exercise, we compare the performance and cost-effectiveness of three different model training pipelines: A100 (Balanced), H100 (Fast), and L40S (Low Cost). The training was conducted using the following parameters:
* Dataset: 10MB zip file
* Steps: 500
```
Training Configuration
{
"resolution": 1024,
"repeats": 100,
"learning_rate": 0.0004,
"lr_scheduler": "constant",
"optimizer_type": "Adafactor",
"num_train_epochs": 500,
"steps": 500,
"gradient_accumulation_steps": 2,
"center_crop": false,
"lora_rank": 32,
"noise_offset": 0,
"max_grad_norm": 0,
"bucket_steps": 64,
"weight_decay": 0.01,
"relative_step": false,
"auto_caption": false,
"content_or_style": "balanced",
"batch_size": 2,
"linear": 16,
"linear_alpha": 16,
"prompt": "driving a F1 car",
"iterations": 300,
"captioning": true,
"priority": "QUALITY"
}
```
Comparison Table:
| Pipeline Name | Characteristics | Charge Rate (/s) | # of Seconds | Total Cost |
| ------------- | --------------- | ---------------- | ------------ | ---------- |
| A100 | Balanced | $0.002 | 1868.67 | $3.74 |
| H100 | Fast | $0.0043 | 1085.85 | $4.67 |
| L40S | Low Cost | $0.0014 | 2532.14 | $3.54 |
***
**Insights:**
1. A100 (Balanced):
1. Offers a balanced performance with moderate cost and time.
2. Suitable for scenarios where a trade-off between speed and cost is acceptable.
2. H100 (Fast):
1. Significantly faster but at a higher charge rate.
2. Ideal for time-sensitive tasks where speed is prioritized over cost.
3. L40S (Low Cost):
1. Lowest cost option but takes the longest time to complete.
2. Best suited for non-urgent tasks where cost efficiency is more important.
# Authentication (https://docs.segmind.com/docs/get-started/authentication)
How to authenticate with Segmind: sign in with Google, Microsoft, Discord or a one-time email link, which host serves the account API, JWT bearer tokens, and API keys for server-to-server calls.
## Segmind Cloud Authentication Documentation [#segmind-cloud-authentication-documentation]
### Overview [#overview]
This document details the authentication methods supported by Segmind Platform:
* OAuth 2.0 social login (Google, Microsoft, Discord)
* Bearer token authentication using JWT
* API key authentication for server-to-server communication
Social logins provide a seamless and secure authentication experience by leveraging existing accounts from trusted providers, eliminating the need for users to create and remember additional credentials.
JSON Web Tokens (JWT) are compact, URL-safe tokens that enable secure information transmission between parties, containing encoded JSON payloads that can include user data and permissions.
### Which host to call [#which-host-to-call]
Three origins are involved, and they are not interchangeable. Sending an account or auth
request to the console origin is the most common cause of an unexpected `404`.
| Origin | What it serves |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `https://platform.segmind.com` | The console you sign in to. Pages such as `/api-keys`, `/cost-analytics`, `/generations` and `/profile` live here. It does **not** serve the account API. |
| `https://cloud.segmind.com/api` | The account and authentication API — sign-in, token refresh, and API key management. Every endpoint on this page is rooted here. |
| `https://api.segmind.com` | The inference API you call with `x-api-key` to run models. |
### OAuth Authentication [#oauth-authentication]
#### Supported Providers and Scopes [#supported-providers-and-scopes]
| Provider | Required Scopes |
| --------- | ------------------------------- |
| Google | `email`, `profile` |
| Microsoft | `user.read`, `profile`, `email` |
| Discord | `identify`, `email`, `guilds` |
### Signing in to the console [#signing-in-to-the-console]
### Open the sign-in page [#open-the-sign-in-page]
Go to [platform.segmind.com/auth/login](https://platform.segmind.com/auth/login). The card
reads **Welcome back**, over a looping video background.
### Choose how to sign in [#choose-how-to-sign-in]
**Continue with Google**, **Continue with Discord** or **Continue with Microsoft** hands you to
that provider and back. The buttons are briefly disabled while the page's verification check
loads.
### Or use an email link [#or-use-an-email-link]
**Continue with Email** swaps the buttons for an address field. Enter your address and choose
**Send login link**, then open the link from your inbox. **Other options** goes back to the
providers.
Sign-in is protected by an invisible verification check. Each attempt uses its own single-use
token, so retrying a failed sign-in always starts a fresh check.
#### Notices you might see [#notices-you-might-see]
Failures appear as a short message inside the card rather than on a separate error page.
| Notice | What happened |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| We couldn't complete that sign-in. Please try again. | The provider callback arrived without its OAuth state. Start the sign-in again. |
| We couldn't verify that request. Please try signing in again. | The verification check did not pass. |
| Your session has expired. Please log in again. | The session timed out; sign in again. |
| Security check failed. Please try again. | The verification token could not be issued in the browser. Retry, and check that no extension is blocking it. |
### OAuth Login Process [#oauth-login-process]
1. Redirect users to our OAuth login page:
```
https://platform.segmind.com/auth/login
```
2. Choosing a provider sends the browser to the authorization endpoint for that provider, where
`{provider}` is `google`, `discord` or `azure` (Microsoft):
```
https://cloud.segmind.com/api/login/{provider}
```
3. The provider authenticates the user and returns them to Segmind, which then redirects the
browser back to the console:
```
https://platform.segmind.com/auth/callback
```
4. The session is established as an HTTP-only secure cookie. The browser navigation itself
returns no token body — to read the session, call:
```bash
curl "https://cloud.segmind.com/api/auth/profile" \
--cookie "your-session-cookie"
```
which responds with:
```json
{
"access_token": "eyJhbGciOiJIUzI1NiIs...",
"refresh_token": "eyJhbGciOiJIUzI1NiIs...",
"username": "Ada Lovelace",
"email": "you@example.com"
}
```
Because the session lives in a cookie rather than a redirect fragment, there is no token to
capture from the callback URL.
### Signing in with an email link [#signing-in-with-an-email-link]
Alongside the three providers, an account can sign in with a one-time link sent by email — the
**Continue with Email** option on the sign-in page.
```bash
curl -X POST "https://cloud.segmind.com/api/auth/login/email/request" \
-H "Content-Type: application/json" \
-d '{
"email": "you@example.com",
"token": ""
}'
```
A successful request responds with a `message`, by default *"Check your email for the login
link"*. The emailed link is single-use. A failure responds with `error` or `message`, by
default *"Failed to send login email"*.
### Bearer Token Authentication [#bearer-token-authentication]
#### Using Bearer Tokens [#using-bearer-tokens]
Include the JWT token in your API requests using the Authorization header:
```bash
curl -X GET "https://cloud.segmind.com/api/auth/profile" \
-H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..."
```
#### Token Format [#token-format]
Our JWTs include:
* `jti`: Unique identifier for the JWT
* `exp`: Token expiration timestamp
* `iat`: Token issue timestamp
* `nbf`: Token not valid before timestamp
* `identity`: Email of the token user
#### Token Renewal [#token-renewal]
To refresh an expired access token:
```bash
curl -X POST "https://cloud.segmind.com/api/auth/refresh-token" \
-H "Authorization: Bearer {refresh_token}"
```
### API Key Authentication [#api-key-authentication]
#### Overview [#overview-1]
API keys provide server-to-server authentication for automated workflows. Include them in the `x-api-key` request header.
#### API Key Format [#api-key-format]
* Prefix: `SG_` on every key
* Followed by 16 hexadecimal characters, so a key is 19 characters in total
* Example shape: `SG_0123456789abcdef`
#### Using API Keys [#using-api-keys]
Include the API key in your requests:
```bash
curl "https://api.segmind.com/v1/get-user-credits" \
-H "x-api-key: YOUR_API_KEY"
```
That endpoint returns your credit balance and is the cheapest way to confirm a
key works — it runs no model and costs nothing. See
[Account and Billing APIs](/docs/platform/account-and-billing-apis).
#### API Key Management [#api-key-management]
These are the calls the console itself makes on the
[API Keys page](https://platform.segmind.com/api-keys). They authenticate as your signed-in
session, not with an API key, so the console is usually the easier way to manage keys. For
server-to-server work, call the [AI Gateway](https://api.segmind.com) with `x-api-key` instead.
List your keys:
```bash
curl "https://cloud.segmind.com/api/auth/get-api-keys" \
-H "Authorization: Bearer {your_access_token}"
```
Generate a new API key. `token` is the sign-in page's verification token, which is why key
creation is a console action rather than an automatable one. `name` and `expiry_date` are
optional:
```bash
curl -X POST "https://cloud.segmind.com/api/auth/generate-api-key" \
-H "Authorization: Bearer {your_access_token}" \
-H "Content-Type: application/json" \
-d '{
"token": "",
"name": "Production API Key"
}'
```
Rename a key:
```bash
curl -X PUT "https://cloud.segmind.com/api/auth/rename-api-key" \
-H "Authorization: Bearer {your_access_token}" \
-H "Content-Type: application/json" \
-d '{ "api_key": "SG_0123456789abcdef", "name": "Staging key" }'
```
Restrict which models a key may call. Send `model_access` even when it is `null`, which clears
the restriction — omitting the field is rejected rather than treated as "unrestricted":
```bash
curl -X PUT "https://cloud.segmind.com/api/auth/api-key-model-access" \
-H "Authorization: Bearer {your_access_token}" \
-H "Content-Type: application/json" \
-d '{ "api_key": "SG_0123456789abcdef", "model_access": null }'
```
A `200` confirms the policy is live. A `202` means it was saved but the gateway is still
serving the previous policy until the key is next re-authenticated — read the `cache_purged`
flag rather than treating any 2xx as done.
Revoke an API key. The key travels in the body, not the path:
```bash
curl -X DELETE "https://cloud.segmind.com/api/auth/delete-api-key" \
-H "Authorization: Bearer {your_access_token}" \
-H "Content-Type: application/json" \
-d '{ "api_key": "SG_0123456789abcdef" }'
```
### Security Guidelines [#security-guidelines]
#### Token Lifecycle [#token-lifecycle]
* Access tokens expire after 1 hour
* Refresh tokens expire after 30 days
* API keys don't expire but should be rotated regularly
#### Rate Limits [#rate-limits]
* Authentication endpoints: 5 requests/minute per IP
* Token refresh: 10 requests/hour per user
* API endpoints: Varies by subscription tier
#### Best Practices while using the platform [#best-practices-while-using-the-platform]
1. **Secure Storage**
* Never expose API keys in client-side code
* Use environment variables for key storage
* Rotate API keys periodically
2. **Error Handling**
* Implement retry logic with exponential backoff
* Handle token expiration gracefully
* Watch for unexpected activity in [Cost Analytics](https://platform.segmind.com/cost-analytics), which can filter by API key and break spend down per key, and in [Generations](https://platform.segmind.com/generations), which lists every request made from the workspace. See [Monitoring](/docs/serverless-api/monitoring).
### Error Responses [#error-responses]
Common authentication errors:
```json
{
"error": "invalid_token",
"error_description": "Token has expired",
"status_code": 401
}
```
| Status Code | Error | Description |
| ----------- | --------------------- | -------------------------------- |
| 401 | `invalid_token` | Token is invalid or expired |
| 401 | `invalid_api_key` | API key is invalid |
| 403 | `insufficient_scope` | Token lacks required permissions |
| 429 | `rate_limit_exceeded` | Too many requests |
### Code Examples [#code-examples]
#### Python [#python]
```python
import requests
class SegmindClient:
"""Calls the AI Gateway with an API key — the path to use for
server-to-server work."""
def __init__(self, api_key):
self.base_url = "https://api.segmind.com/v1"
self.headers = {"x-api-key": api_key}
def get_credits(self):
"""Cheapest way to confirm a key works: runs no model, costs nothing."""
response = requests.get(
f"{self.base_url}/get-user-credits",
headers=self.headers
)
response.raise_for_status()
return response.json()
```
#### Node.js [#nodejs]
```javascript
const axios = require('axios');
class SegmindClient {
constructor({ apiKey }) {
this.baseUrl = 'https://api.segmind.com/v1';
this.headers = {
'Content-Type': 'application/json',
'x-api-key': apiKey,
};
}
// Cheapest way to confirm a key works: runs no model, costs nothing.
async getCredits() {
const response = await axios.get(`${this.baseUrl}/get-user-credits`, {
headers: this.headers,
});
return response.data;
}
}
```
### Support [#support]
For authentication issues or questions:
* Email: [support@segmind.com](mailto:support@segmind.com)
* Documentation: [https://docs.segmind.com](https://docs.segmind.com)
* Status page: [https://status.segmind.com](https://status.segmind.com)
# Overview (https://docs.segmind.com/docs/get-started)
Make your first Segmind API request in a few minutes. Get an API key, call a model from cURL, Python, or JavaScript, and find your next steps.
This page gets you to a working API call. The request below runs a model on
the AI Gateway; add your own API key to try it yourself.
## Make your first request [#make-your-first-request]
```bash
curl -X POST "https://api.segmind.com/v1/fast-flux-schnell" \
-H "x-api-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
--output output.jpg \
-d '{
"prompt": "A wallpaper of a sports car with \"Flux\" written on it, motion blur, side view",
"steps": 4,
"seed": 1184522,
"aspect_ratio": "1:1"
}'
```
```python
import requests
api_key = "YOUR_API_KEY"
url = "https://api.segmind.com/v1/fast-flux-schnell"
data = {
"prompt": "A wallpaper of a sports car with 'Flux' written on it, motion blur, side view",
"steps": 4,
"seed": 1184522,
"aspect_ratio": "1:1",
}
response = requests.post(url, json=data, headers={"x-api-key": api_key})
response.raise_for_status()
with open("output.jpg", "wb") as f:
f.write(response.content)
```
```javascript
import { writeFile } from 'node:fs/promises';
const apiKey = 'YOUR_API_KEY';
const url = 'https://api.segmind.com/v1/fast-flux-schnell';
const response = await fetch(url, {
method: 'POST',
headers: {
'x-api-key': apiKey,
'Content-Type': 'application/json',
},
body: JSON.stringify({
prompt:
"A wallpaper of a sports car with 'Flux' written on it, motion blur, side view",
steps: 4,
seed: 1184522,
aspect_ratio: '1:1',
}),
});
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
await writeFile('output.jpg', Buffer.from(await response.arrayBuffer()));
```
**The response body is the image**, not JSON — these examples write it to
`output.jpg`. Run the cURL one without `--output` and you get a few hundred
kilobytes of JPEG in your terminal.
We highly recommend reading the [Quickstart](/docs/get-started/quickstart)
before going further.
## Explore the platform [#explore-the-platform]
## Start building [#start-building]
* [Generate an image](https://www.segmind.com/models/ideogram-2a-txt-2-img)
* [Generate a video](https://www.segmind.com/models/veo-2)
* [Generate a voiceover](https://www.segmind.com/models/orpheus-3b-0.1)
* [Build a product-photo workflow](https://www.segmind.com/pixelflows/ai-product-background-generator)
* [Set up Dedicated Endpoints](https://platform.segmind.com/endpoints)
**Join our [Discord](https://discord.com/invite/G5t5k2JRN6) community.** Stay
up to date, ask billing or pricing questions, and get support from fellow
developers.
# Key Concepts (https://docs.segmind.com/docs/get-started/key-concepts)
Definitions for the terms used across Segmind: models, latency, prompts, tokens, weights, base models, modality, fine-tuning, and the PixelFlow GUI.
### Key Concepts [#key-concepts]
**Models**
Model is a type of machine learning model that is trained to generate new data, such as text, images, audio, or video, based on the patterns and relationships it has learned from a training dataset. To see the list of all public models on Segmind, go to [segmind.com/models](https://segmind.com/models) and filter by models.
Segmind offers a combination of **third-party models**, accessed through direct integrations with partner APIs, and **self-hosted models**, which are deployed and managed on GPUs controlled by Segmind across various cloud providers.
**Latency**
Segmind is designed to deliver **best-in-class inference latency**, powered by a highly optimized serving infrastructure. Our inference engine ranks among the **fastest globally**, ensuring quick and reliable generation across all supported models.
The **latency metrics** displayed on each model’s page represent **average values across all users**. Actual latency for your requests may vary depending on factors such as input parameters, the GPU type used, and real-time server load.
For **billing**, Segmind measures the exact **GPU processing time** used to execute your request, ensuring you only pay for the actual compute resources consumed.
**PixelFlow GUI**
Pixelflow is a node based tool that gives developer and creators the ability to access a myriad of open-sourced models and seamlessly string them together to create highly tailored AI workflows.
**PixelFlow APIs**
Workflows created on PixelFlow GUI can be converted into APIs for simpler calling from your application. You can mark the inputs and outputs to a workflows to convert them into PixelFlow APIs. See the [PixelFlow API reference](/docs/pixelflow/api-reference) for the request shape and how to call a published workflow.
**Playground**
Playgrounds allow you to use a model or a PixelFlow via a simple user interface. This is a simple form interface to give in the inputs and view the outputs without using an API key.
**Fine-tuning**
Fine-tuning refers to taking a pre-trained image model and training it further on a specific dataset, so it specialises for a particular subject, style or task.
Segmind's fine-tuning service covered the Flux family and Qwen. It **no longer accepts new training jobs** — existing fine-tuned models remain available for inference. See the [fine-tuning overview](/docs/fine-tuning).
**Prompts**
Prompts are textual inputs or instructions provided to generative AI models like text-to-image, image-to-image, and language models. For text-to-image models, prompts describe the desired visual content, guiding the generation of images. In image-to-image models, prompts specify the desired modifications or transformations to an existing image. Language models use prompts as context or starting points for generating human-like text.
Effective prompting is crucial, as the quality and specificity of prompts significantly influence the model's output. Prompt engineering involves carefully crafting prompts to elicit the desired responses, often requiring experimentation and iterative refinement for optimal results.
**Tokens**
Tokens are the basic units of text that large language models (LLMs) process and generate, typically subword units like words, punctuation, or word pieces. LLMs are charged per token because tokenizing inputs, generating outputs, and the overall computational cost scale with the number of tokens.
Longer inputs/outputs and larger models require processing more tokens, consuming more resources. Charging per token allows providers to account for the variable computational demands based on the input/output length and model size for each request. It creates a scalable pricing model tied to the actual resources consumed for running these complex models.
**Weights**
Weights refer to the numerical parameters of the deep neural network that encode the mapping between text prompts and generated images. LoRA (Low-Rank Adaptation) and other fine-tuning techniques aim to specialize or adapt these weights for specific domains or tasks without modifying the entire pre-trained model. LoRA adds a small set of task-specific weights on top of the base model weights during fine-tuning. This allows efficient customization while preserving the general knowledge from the original training. Other techniques like prompt tuning or full fine-tuning update more weights for increased specialization. Ultimately, these methods optimize a subset of weights to encode new knowledge while leveraging the robustness of the pre-trained weights, enabling efficient domain adaptation of large generative models.
**Base model**
A base model for a weight file refers to the initial, pre-trained model that serves as the foundation for further fine-tuning or adaptation through techniques like LoRA or prompt tuning.
**Modality**
Modality refers to the different types or forms of data that a system can process. Common modalities include: Text, Image, Audio and Video. Segmind supports the following model types:
| Modality | What it does |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Text to Image** | Creates images from a written description. Understands the meaning of the text and generates a matching image. Examples: SSD-1B, SDXL, SD 1.5. |
| **Image to Image** | Creates, edits or manipulates an image from an input image plus guidance. Covers inpainting, super-resolution, style transfer and similar. Examples: Stable Diffusion inpainting and outpainting, IP-Adapters, ControlNets. |
| **LLM** | Trained on large amounts of text to understand and generate language — translation, summarisation, question answering, generation. Examples: Llama, GPT, Claude. |
| **vLLM** | An LLM that also takes visual input, trained on text and images together, so it can describe or reason about a picture. Examples: CLIP, LLaVA. |
| **Text to Speech** | Converts written text into natural-sounding speech, including tone, pitch and emotion. Used for voice assistants, accessibility and narration. |
| **Text to Video** | Generates a short video clip from a written description, synthesising motion and scene to match the prompt. |
| **Image to Video** | Animates one or more still images into a video, adding motion or extending the scene over time. |
| **Speech to Text** | Transcribes spoken audio into written text, from a recording or in real time. |
# Models (https://docs.segmind.com/docs/get-started/models)
Browse the Segmind model catalogue, filter by modality and price, and open any model to run it or read its API reference.
Every model Segmind serves is listed in one place. Open **Models** from the
left nav of the console, or go straight to
[segmind.com/models](https://www.segmind.com/models).
## Reading a model card [#reading-a-model-card]
Each card carries the things you usually decide on before opening anything:
| On the card | What it tells you |
| ----------------- | ------------------------------------------------------------------------------------------------------- |
| **Modality tag** | `Text To Image`, `Image To Video`, `LLM` and so on — see [key concepts](/docs/get-started/key-concepts) |
| **Average price** | the typical cost of one run, so you can compare before committing |
| **Description** | one line on what the model is for |
| **Latency** | how long a run typically takes |
| **Added** | how recently it appeared, which is how you spot new arrivals |
**Filter & Sort** narrows the list by modality and orders it by price or
latency. The search box matches on name.
Selecting a card opens the model's own page, where you can run it from the
playground without writing any code, and read the exact parameters it accepts.
## Running a model [#running-a-model]
Once you know the slug — it is in the model's URL — you can call it directly:
```bash
curl -X POST "https://api.segmind.com/v1/" \
-H "x-api-key: $SEGMIND_API_KEY" \
-H "Content-Type: application/json" \
--output output.jpg \
-d '{"prompt": "a lighthouse at dusk"}'
```
See [Quickstart](/docs/get-started/quickstart) for a complete first request, and
the [AI Gateway reference](/docs/serverless-api) for parameters, error codes and
the async API.
The catalogue is also available programmatically. `segmind.models.list()` in the
[Python SDK](/docs/sdks/python#segmindmodelslist) returns every model with its
slug, modality, average cost, latency and parameter schema — useful for building
your own picker, or for checking whether a slug you depend on is still current.
## Importing your own model [#importing-your-own-model]
Importing a LoRA of your own is **not currently reachable from the console** —
there is no entry point for it on the models page. If you need a custom or
private model hosted on Segmind, contact
[support@segmind.com](mailto:support@segmind.com).
# Playground (https://docs.segmind.com/docs/get-started/playground)
Run any Segmind model in the browser: the compose dock, one-click settings, up to three generations at once, the session strip, and editing the raw request as JSON.
Every model page has a playground. It is the fastest way to find out what a
model does before you write a line of code, and it calls exactly the same API
your integration will — so a result you get here is a result you can reproduce.
Open [segmind.com/models](https://www.segmind.com/models), pick a model, and you
land on its **Playground** tab. **History**, **API** and **Pricing** sit
alongside it, and the estimated time for one run is shown on the right.
## The compose dock [#the-compose-dock]
Everything you need to start a run is in one panel that stays put while you
work.
| Control | What it does |
| ------------------------ | ----------------------------------------------------------------------------------------------------------- |
| **Prompt** | The main text input. The placeholder is written for the model in front of you, so it is worth reading once. |
| **Expand prompt editor** | Opens the prompt fullscreen — the one to use for scene-length prompts and scripts. |
| **Ask Pixxe** | Hands your prompt to an assistant that rewrites it, and can suggest parameter values to match. |
| **Image input list** | Attaches reference images. Filled tiles show the filename, so you can tell several references apart. |
| **More input options** | The inputs that do not fit on the face of the dock. |
Two controls reshape the workspace itself: drag the divider between the dock and
the canvas to **resize either side**, and use **Maximize dock** or **Move inputs
to the bottom** when a model has more parameters than fit comfortably beside the
output.
### Settings are pills, not dropdowns [#settings-are-pills-not-dropdowns]
The common enum and boolean parameters render as pills under the prompt —
aspect ratio, size, output format, and whatever else the model exposes.
Selecting one opens a short list with a tick against the current value and a
**Clear** option to fall back to the model's default. It is one click to change,
and the current value is readable without opening anything.
## Running [#running]
Press **Generate**. The run goes through the same
[asynchronous](/docs/serverless-api/async-inference) path the API uses, which is
what makes the next three things possible.
**Up to three generations run at once.** Fire a second and a third while the
first is still going; they run in parallel. At the limit the Generate button is
disabled and explains why — *"Up to 3 generations can run at once. Wait for one
to finish."* — rather than silently ignoring the click.
**The session strip tracks them all.** A row of chips labelled **This session**
appears above the canvas as soon as you start a generation, one chip per run,
each counting up while it works and turning into a thumbnail when it lands.
Select any finished chip to bring that result back on screen. The strip stays
hidden until there is something to put in it.
**A run survives the page.** Navigate away and come back, or refresh mid-run,
and the playground reconnects to the job and picks up where it left off — the
chips keep counting from where they were. You do not need to keep the tab still
to keep a long generation.
## Reading the output [#reading-the-output]
The canvas renders the result in its native form, with a download control
anchored to it:
* **Images** appear at full size; a request that returns several arrives as a
gallery.
* **Video** plays at its true aspect ratio — portrait 9:16 fills the player
properly rather than being letterboxed into landscape.
* **Multi-clip output**, such as a job that returns a set of short clips, shows
a main preview plus a filmstrip of the whole set, each clip playable and
downloadable on its own.
* **3D output** from image-to-3D models is rendered in a viewer rather than
dumped as raw `.ply` or `.splat` data.
## Editing the request as JSON [#editing-the-request-as-json]
**Edit request as JSON** opens the exact payload the playground is about to
send. Change anything in it — including parameters the form does not surface —
and the form updates to match. A validator under the editor reads **Valid JSON**
or **Invalid JSON** as you type, and **Format** and **Minify** tidy the body.
This is the quickest way to try an advanced parameter before committing it to
code, and the JSON you end up with is the JSON you can paste into your own
request.
**Get API code** does the other half of the job: it hands you the same request
as a runnable snippet. The model's **API** tab has the full reference, with
synchronous and asynchronous examples per language.
## Restricted models [#restricted-models]
If your team's admin has restricted a model, it carries a **Restricted** badge
with a lock icon and the Generate button is disabled — on the model page, in
PixelFlow, and in search. You find out before you compose a prompt rather than
after you press Generate. See [Teams](/docs/platform/teams) for who can set
this.
## The classic layout [#the-classic-layout]
**Switch to classic interface** returns the playground to its previous layout,
and the choice is remembered in your browser. Use it if you prefer the older
arrangement while the current design settles.
Playground runs are billed exactly like API calls and appear in
[Generations](/docs/serverless-api/monitoring) alongside them, tagged with
**Web** as their source. If you are comparing spend, that filter is what
separates experimenting from production traffic.
## Next steps [#next-steps]
Take the request you just built and run it against the API.
The submit-and-poll contract the playground uses under the hood.
# Quickstart (https://docs.segmind.com/docs/get-started/quickstart)
Make your first Segmind API request in minutes. Learn the basics of the platform.
This guide walks you through creating an account, getting an API key, and
making your first inference request.
### Create a free account [#create-a-free-account]
Head over to [segmind.com](https://segmind.com) and sign up for a free
account. You can continue with Google, Discord or Microsoft, or have a one-time
sign-in link emailed to you — see [Authentication](/docs/get-started/authentication).
### Try a model in the playground [#try-a-model-in-the-playground]
Open any [model page](https://segmind.com/models) and run it from the
in-browser playground. Tweak the prompt and parameters to see how the model
behaves before integrating it into your code.
### Create an API key [#create-an-api-key]
The Segmind AI Gateway uses API keys for authentication. Sign in to your
account and head to the
[API Keys page](https://platform.segmind.com/api-keys) on the dashboard
to create one.
Treat your API key like a password. Don't commit it to source control or
expose it in client-side code.
### Make your first request [#make-your-first-request]
Authenticate by including your API key in the `x-api-key` header.
```bash
curl -X POST "https://api.segmind.com/v1/fast-flux-schnell" \
-H "x-api-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
--output output.jpg \
-d '{
"prompt": "a futuristic city skyline at sunset, cinematic",
"steps": 4,
"aspect_ratio": "1:1"
}'
```
The response body **is the image**, so `--output` is not optional — without it
curl prints a few hundred kilobytes of JPEG into your terminal.
```python
# pip install "segmind>=1.1.0" · export SEGMIND_API_KEY="YOUR_API_KEY"
import segmind
result = segmind.run("fast-flux-schnell", prompt="a futuristic city skyline at sunset, cinematic")
print(result["output"]) # URL to the generated image
```
See the [Python SDK](/docs/sdks/python) for async jobs, polling control, and LLM chat.
```python
import requests
api_key = "YOUR_API_KEY"
url = "https://api.segmind.com/v1/fast-flux-schnell"
data = {
"prompt": "a futuristic city skyline at sunset, cinematic",
"steps": 4,
"aspect_ratio": "1:1",
}
response = requests.post(url, json=data, headers={"x-api-key": api_key})
response.raise_for_status()
with open("output.jpg", "wb") as f:
f.write(response.content)
```
```javascript
import { writeFile } from 'node:fs/promises';
const apiKey = 'YOUR_API_KEY';
const url = 'https://api.segmind.com/v1/fast-flux-schnell';
const response = await fetch(url, {
method: 'POST',
headers: {
'x-api-key': apiKey,
'Content-Type': 'application/json',
},
body: JSON.stringify({
prompt: 'a futuristic city skyline at sunset, cinematic',
steps: 4,
aspect_ratio: '1:1',
}),
});
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
await writeFile('output.jpg', Buffer.from(await response.arrayBuffer()));
```
### Next steps [#next-steps]
* Use the [Python SDK](/docs/sdks/python) to skip hand-rolled HTTP — one
`segmind.run()` call submits, polls, and returns the result.
* Long-running models (video, upscaling, LLMs) should use the
[Async Inference (V2) API](/docs/serverless-api/async-inference) for better
reliability.
* Browse the [Model Hub](https://segmind.com/models) to discover what's
available.
* Learn about [PixelFlow](https://www.segmind.com/pixelflows) for visual,
multi-step workflows.
# Support (https://docs.segmind.com/docs/get-started/support)
How to get support from Segmind team and community.
### Community Support [#community-support]
If you run into any issues accessing or using our APIs or PixelFlow, you can reach out to our team and the larger community on [discord server](https://discord.gg/pUKXaXJN8W) and post your queries in the respective channels.
Start with `#ai-support-bot` to ask our support bot. If you are unable to resolve your queries, drop in to `#platform-support` or `#billing-support` to get help from any of the team members.
### Dedicated Support [#dedicated-support]
Scale accounts get a dedicated support channel on discord, created automatically when you subscribe, and we email you the invite link. It is read by our engineers rather than a bot, and carries a one business day response target.
If you are on a Scale plan and cannot see your channel, reach out in the `#platform-support` channel on discord and we will set it up.
# Workflow API Reference (https://docs.segmind.com/docs/pixelflow/api-reference)
Call a published PixelFlow workflow over REST: submit to POST /workflows/v2/{slug}, poll the status URL, and fetch results — with cURL, Python, and JavaScript examples.
Published workflows are served from Segmind's async API. The lifecycle is **submit → poll → fetch**: submitting returns immediately with a request ID and URLs to poll; the result is ready when status reaches `COMPLETED`.
This is the same async contract used by Segmind's
[async model inference](/docs/serverless-api/async-inference), and the same
authentication: your API key in an **`x-api-key`** header. The gateway does not
accept the key as a bearer token — sending it in `Authorization` returns `401`
regardless of the endpoint. See [authentication](/docs/get-started/authentication).
## Submit a request [#submit-a-request]
```
POST https://api.segmind.com/workflows/v2/{slug}
x-api-key: SG_YOUR_API_KEY_HERE
Content-Type: application/json
```
The body is a JSON object with the **key names** you gave your workflow's input nodes when [publishing](/docs/pixelflow/publish-as-api):
```json
{
"prompt": "a lighthouse at dusk, dramatic sky",
"style": "photographic"
}
```
**Response** — the request is queued and you get back where to check on it:
```json
{
"request_id": "0b7f1d9c-...",
"status": "QUEUED",
"poll_url": "https://api.segmind.com/v2/requests/0b7f1d9c-.../status",
"status_url": "https://api.segmind.com/v2/requests/0b7f1d9c-.../status",
"response_url": "https://api.segmind.com/v2/requests/0b7f1d9c-..."
}
```
## Poll for status [#poll-for-status]
```
GET {poll_url}
x-api-key: SG_YOUR_API_KEY_HERE
```
```json
{
"status": "PROCESSING",
"request_id": "0b7f1d9c-...",
"metrics": { "time_in_queue_ms": 312 }
}
```
`status` moves through `QUEUED` → `PROCESSING` → `COMPLETED` (or `FAILED`). Poll every few seconds; longer-running workflows (video models, large fan-outs) warrant a longer interval.
## Fetch the result [#fetch-the-result]
When status is `COMPLETED`, fetch the response:
```
GET {response_url}
x-api-key: SG_YOUR_API_KEY_HERE
```
```json
{
"status": "COMPLETED",
"output": "[{\"keyname\": \"image\", \"value\": {...}}]",
"images": [
{ "url": "https://...", "content_type": "image/png", "file_size": "482133" }
],
"timings": { "total_ms": 8421 },
"metrics": {}
}
```
* **`output`** — a JSON-*stringified* array of `{keyname, value}` pairs, one per named [output node](/docs/pixelflow/nodes/output-nodes). Parse it to get your named outputs.
* **`images`** / **`video`** / **`audio`** — generated media as hosted URLs with content types. Video outputs may include `last_frame_url` when the model supports returning the final frame.
* **`timings`** / **`metrics`** — execution timings and usage metrics.
* On failure, `status` is `FAILED` and **`error`** describes what went wrong.
## Full example [#full-example]
```bash
# 1. Submit
curl -X POST "https://api.segmind.com/workflows/v2/" \
-H "x-api-key: $SEGMIND_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt": "a lighthouse at dusk"}'
# 2. Poll until COMPLETED
curl -X GET "" \
-H "x-api-key: $SEGMIND_API_KEY"
# 3. Fetch the result
curl -X GET "" \
-H "x-api-key: $SEGMIND_API_KEY"
```
```python
import os, time, json, requests
api_key = os.environ["SEGMIND_API_KEY"]
headers = {"x-api-key": api_key}
# 1. Submit
submit = requests.post(
"https://api.segmind.com/workflows/v2/",
headers=headers,
json={"prompt": "a lighthouse at dusk"},
).json()
# 2. Poll until COMPLETED
while True:
status = requests.get(submit["poll_url"], headers=headers).json()
if status["status"] in ("COMPLETED", "FAILED"):
break
time.sleep(3)
# 3. Fetch the result
result = requests.get(submit["response_url"], headers=headers).json()
outputs = {o["keyname"]: o["value"] for o in json.loads(result["output"])}
print(outputs)
```
```javascript
const apiKey = process.env.SEGMIND_API_KEY;
const headers = { 'x-api-key': apiKey };
// 1. Submit
const submit = await fetch(
"https://api.segmind.com/workflows/v2/",
{
method: "POST",
headers: { ...headers, "Content-Type": "application/json" },
body: JSON.stringify({ prompt: "a lighthouse at dusk" }),
},
).then((r) => r.json());
// 2. Poll until COMPLETED
let status;
do {
await new Promise((r) => setTimeout(r, 3000));
status = await fetch(submit.poll_url, { headers }).then((r) => r.json());
} while (status.status !== "COMPLETED" && status.status !== "FAILED");
// 3. Fetch the result
const result = await fetch(submit.response_url, { headers }).then((r) =>
r.json(),
);
const outputs = Object.fromEntries(
JSON.parse(result.output).map((o) => [o.keyname, o.value]),
);
console.log(outputs);
```
## Errors [#errors]
| Code | Meaning |
| ----- | ----------------------------------------------------------------------------- |
| `401` | Missing or invalid API key — check the `x-api-key` header. |
| `404` | Unknown workflow slug — confirm the slug from your publish dialog. |
| `4xx` | Invalid input — a required key name is missing or a value has the wrong type. |
## See also [#see-also]
# Getting Started (https://docs.segmind.com/docs/pixelflow/getting-started)
Create your first AI workflow in PixelFlow: open the library, add input, model, and output nodes, connect them, and run — all in under ten minutes.
This page takes you from a fresh Segmind account to your first completed workflow run. For a deeper, screenshot-by-screenshot tutorial, see [Build your first workflow](/docs/pixelflow/guides/build-your-first-workflow).
## Prerequisites [#prerequisites]
You need a Segmind account with credits. Every model node consumes credits when it runs — the estimated cost is shown on each node before you run it. Sign up at [platform.segmind.com](https://platform.segmind.com).
## Open the workflow library [#open-the-workflow-library]
Head to **PixelFlow → Library** at [platform.segmind.com](https://platform.segmind.com). The library lists all your workflows with thumbnail previews. From here you can create, rename, duplicate, or delete workflows.
## Create a workflow — or clone a template [#create-a-workflow--or-clone-a-template]
### Start from scratch or a template [#start-from-scratch-or-a-template]
Click **New workflow** to open a blank canvas, or browse [templates](/docs/pixelflow/templates) and clone one — templates are pre-built workflows you can copy into your workspace and customize.
### Add nodes [#add-nodes]
Use the sidebar to add an **Input** node, search for a **model** by name (e.g. an image-generation model), and add an **Output** node. See [node types](/docs/pixelflow/nodes) for what's available.
### Connect them [#connect-them]
Drag from a node's output port to the next node's input port. Connected ports light up.
### Run it [#run-it]
Type a prompt into your input node and click **Run**. Nodes execute in order, showing live status. When the run finishes, the output node displays the result.
## View your results [#view-your-results]
Output nodes render results in place — images appear as a gallery, video and audio get players, and text is displayed inline. Generated assets are also saved to your [asset gallery](/docs/pixelflow/the-editor#the-sidebar) for reuse in other workflows.
## Where to go next [#where-to-go-next]
# PixelFlow: Visual AI Workflow Builder (https://docs.segmind.com/docs/pixelflow)
Build AI workflows on a visual canvas — chain image, video, audio, and LLM models without code, then publish any workflow as a production-ready API.
PixelFlow is Segmind's visual AI workflow builder. Drag models onto a canvas, connect them into a pipeline, and run the whole thing with one click — no code, no GPU setup, no infrastructure. When your workflow is ready, publish it as a REST API and call it from any application.
## What is PixelFlow? [#what-is-pixelflow]
PixelFlow is a node-based editor for generative AI. Every workflow is a graph: **input nodes** take your prompts and files, **model nodes** call any model in Segmind's catalog — image, video, audio, and language models — and **output nodes** display the results. Edges carry data between them.
Because every node is a hosted model running on Segmind's cloud, there is nothing to install and no GPU to rent. You pay per model call with the same credits used across the Segmind platform.
## What can you build? [#what-can-you-build]
* **Multi-step image pipelines** — generate an image, upscale it, swap a background, and brand it in one run.
* **Text-to-image APIs** — wire a prompt input to an image model and [publish it as an API](/docs/pixelflow/publish-as-api) your app can call.
* **LLM chains** — connect language models with [chat history](/docs/pixelflow/guides/llm-chat-history) for conversational agents, or use an LLM to write prompts for an image model.
* **Batch and parallel processing** — [fan out](/docs/pixelflow/guides/fan-out-and-parallel) one output across many model runs and collect the results.
* **Multi-modal workflows** — combine image, video, audio, and text models in a single graph.
## How it works [#how-it-works]
1. **Build** — add nodes from the sidebar, connect them on the canvas, and configure each model's parameters in a form generated from its schema. See [the editor](/docs/pixelflow/the-editor).
2. **Run** — execute a single node or the whole workflow. Watch progress live, inspect logs, and [pin completed nodes](/docs/pixelflow/guides/pinning-and-caching) so they don't re-run while you iterate.
3. **Publish** — turn the workflow into a versioned REST endpoint with one click. Submit requests, poll for status, and fetch results from your own code. See the [API reference](/docs/pixelflow/api-reference).
## PixelFlow vs. the AI Gateway [#pixelflow-vs-the-ai-gateway]
| | PixelFlow | [AI Gateway](/docs/serverless-api) |
| --------------- | -------------------------------------- | ---------------------------------- |
| Best for | Multi-step pipelines, visual iteration | Single-model calls from code |
| Interface | Visual canvas | REST API |
| Chaining models | Built in — connect nodes | You orchestrate in your code |
| Output | Run in browser or publish as one API | One API call per model |
Use the AI Gateway when you need a single model in your stack. Use PixelFlow when the value is in the *combination* of models — and you want the whole pipeline behind a single endpoint.
## Next steps [#next-steps]
# Key Concepts (https://docs.segmind.com/docs/pixelflow/key-concepts)
The PixelFlow mental model: workflows, nodes, edges, runs, templates, published versions, pinned outputs, credits, and teams — defined in one place.
A quick reference for the terms used throughout PixelFlow and these docs.
## Workflow [#workflow]
A workflow (sometimes called a *graph*) is the unit of work in PixelFlow: a set of nodes connected by edges that together describe a pipeline. Workflows live in your [library](https://platform.segmind.com/pixelflow/library), auto-save as you edit, and can be shared, duplicated, exported as templates, or published as APIs.
## Nodes and edges [#nodes-and-edges]
**Nodes** are the building blocks — each one is an input, a model call, an output, a utility function, or a sticky note. **Edges** connect an upstream node's output port to a downstream node's input port and carry data between them. One output can feed multiple inputs.
See [node types](/docs/pixelflow/nodes) for the full catalog.
## Runs [#runs]
A run is one execution of your workflow. You can run the whole graph or a single node — running a node executes only that node and the upstream nodes it depends on. Node status (idle, in‑progress, success, error) is shown live on the canvas, and each model node reports its execution time and cost.
## Pinned outputs [#pinned-outputs]
Pinning a node caches its last successful output: on the next run the node is skipped and its cached result is reused — until you unpin it, change its parameters, or change something upstream. Pinning saves time and credits while you iterate. See [pinning and caching](/docs/pixelflow/guides/pinning-and-caching).
## Templates [#templates]
Templates are reusable workflow snapshots. Segmind publishes a [gallery of templates](/docs/pixelflow/templates) you can clone into your workspace, and you can export your own workflows as templates to share a starting point with others.
## Publishing and versions [#publishing-and-versions]
Publishing turns a workflow into a REST API. Each publish creates a new immutable **version** (v1, v2, …) with its own slug, so callers aren't affected while you keep editing. Inputs and outputs you've named with a **key name** become the API's request and response fields. See [publish as an API](/docs/pixelflow/publish-as-api) and the [API reference](/docs/pixelflow/api-reference).
## Slugs [#slugs]
A slug is the URL-safe identifier of a published workflow — it's what you call in `POST /workflows/v2/{slug}`. Slugs are generated when you publish.
## Credits [#credits]
Model nodes consume Segmind credits when they run, just like direct [AI Gateway](/docs/serverless-api) calls. Each model node shows an estimated cost before you run it. Credits and billing are managed in your [account](/docs/platform/pricing-and-billing).
## Teams and sharing [#teams-and-sharing]
Workflows can be shared with individual users by email or with your [team](/docs/platform/teams). Shared workflows appear in the recipient's library. See [sharing and collaboration](/docs/pixelflow/guides/sharing-and-collaboration).
# Publish a Workflow as an API (https://docs.segmind.com/docs/pixelflow/publish-as-api)
Turn any PixelFlow workflow into a production REST API: name your inputs and outputs, publish a version, test it in the console, and call it from your code.
Any workflow can become a REST endpoint. Callers send your named inputs as JSON, Segmind runs the graph in the cloud, and they get your named outputs back — your whole pipeline behind one API call.
### Name your inputs [#name-your-inputs]
Give each [input node](/docs/pixelflow/nodes/input-nodes) that callers should control a **key name** — that becomes the JSON field name in API requests. An input named `prompt` is called with `{"prompt": "..."}`. Inputs without key names keep their canvas values.
The field is **API Key Name**, at the bottom of the node under the **Advanced** disclosure, alongside the **Use as API Input** checkbox. If you don't see an Advanced section, switch the top bar's mode toggle from **Creative** to **Pro** — Creative mode hides those controls. See [input nodes](/docs/pixelflow/nodes/input-nodes#finding-the-advanced-controls).
### Name your outputs [#name-your-outputs]
Do the same for [output nodes](/docs/pixelflow/nodes/output-nodes): each key-named output becomes a field in the API response.
### Publish [#publish]
Publish from the cloud icon in the editor's top bar — it's unlabelled, but its tooltip reads **Publish as API**. Confirm in the dialog that follows.
The dialog itself doesn't show your endpoint. Once the workflow is published, open the **API Info** panel to get the endpoint URL, the request and response contract derived from your named nodes, and ready-to-copy code samples (cURL, Python, JavaScript).
### Test it [#test-it]
Use the built-in test panel to fill in your inputs, send a real request, and inspect the response — without leaving the console.
## Versions [#versions]
Each publish creates a new immutable version — v1, v2, and so on. Published versions keep serving exactly what you published, so you can keep editing the workflow freely and publish again when ready. The version is shown beside the API status in the editor.
## Working with image arrays [#working-with-image-arrays]
If an image input is connected to a parameter that accepts an array, callers can pass an **array of image URLs** to process multiple images in one request:
```json
{
"image_list": [
"https://example.com/image1.png",
"https://example.com/image2.png",
"https://example.com/image3.png"
]
}
```
This pairs naturally with [fan-out](/docs/pixelflow/guides/fan-out-and-parallel): the array fans out inside the workflow and each image is processed in parallel.
## Calling your API [#calling-your-api]
Published workflows run **asynchronously**: submit a request, poll for status, fetch the result. Full request/response shapes and code samples are in the [API reference](/docs/pixelflow/api-reference).
Published-workflow runs consume credits from your account like any other model usage — see [pricing and billing](/docs/platform/pricing-and-billing).
# Templates (https://docs.segmind.com/docs/pixelflow/templates)
Start from working AI workflow templates: browse the PixelFlow gallery, clone any template into your workspace, and customize it — no blank-canvas problem.
Templates are pre-built, working workflows you can clone and make your own — the fastest way past the blank canvas.
## Browsing templates [#browsing-templates]
Open **PixelFlow → Templates** to browse the gallery. Each template shows a preview and description of what the pipeline does — image pipelines, LLM chains, multi-modal workflows, and more.
## Cloning a template [#cloning-a-template]
Open a template and click **Clone**. A copy lands in your [library](https://platform.segmind.com/pixelflow/library) as a regular workflow — yours to edit, run, share, and [publish](/docs/pixelflow/publish-as-api). The original template is unaffected.
## Customizing [#customizing]
A cloned template is a normal workflow. Typical first edits:
* Swap a model node for a different model from the catalog
* Change [input nodes](/docs/pixelflow/nodes/input-nodes) and their key names to fit your API
* Add or remove steps — upscalers, captioners, [utilities](/docs/pixelflow/nodes/utility-nodes)
## Publishing your own templates [#publishing-your-own-templates]
Built something worth sharing? [Export your workflow as a template](/docs/pixelflow/guides/sharing-and-collaboration#export-as-a-template). Template submissions are reviewed before they appear in the public gallery.
# The Editor (https://docs.segmind.com/docs/pixelflow/the-editor)
Tour the PixelFlow editor: the canvas, model search, asset gallery, logs panel, node configuration, run controls, auto-save, and undo/redo.
Everything in PixelFlow happens in the editor — the canvas where you assemble, run, and debug workflows.
## The canvas [#the-canvas]
The canvas is an infinite surface for your graph. Scroll to move around it — a trackpad's two-finger scroll pans, a mouse wheel zooms — and use the canvas toolbar's **zoom in**, **zoom out**, **pan**, and **fit view** controls to frame a large workflow. Dragging on empty canvas draws a selection box rather than panning. Nodes can be dragged anywhere; edges re-route automatically.
## The sidebar [#the-sidebar]
The sidebar is your toolbox:
* **Add nodes** — quick-add buttons for [Input](/docs/pixelflow/nodes/input-nodes), [Model](/docs/pixelflow/nodes/model-nodes), [Output](/docs/pixelflow/nodes/output-nodes), [Notes](/docs/pixelflow/nodes/notes-nodes), and [Utility](/docs/pixelflow/nodes/utility-nodes) nodes.
* **Model search** — search Segmind's full model catalog by name and add any model to the canvas.
* **Asset gallery** — every image, video, and audio file you've uploaded or generated, ready to reuse as inputs across workflows.
* **Logs** — a live stream of execution events for debugging runs.
## Configuring nodes [#configuring-nodes]
Selecting a model node opens its parameter form, generated from the model's schema — prompts, dimensions, seeds, guidance, and whatever else the model accepts. Fields can hold literal values or take their value from an incoming connection.
You can also reference upstream node outputs inside text fields with template expressions like `{{ input_1 }}` or `{{ model_1.images[0] }}` — useful for composing prompts from multiple sources.
Every node has an action bar (copy, delete, add a note) and an editable title. Model nodes display an **estimated cost per run** so you know what a run will consume before you start it.
## Running workflows [#running-workflows]
There are two ways to run:
* **Run workflow** executes the entire graph in dependency order.
* **Run node** — the ▶ in a node's hover action bar — executes that one node against its upstream's existing output, so you can test a step without paying for the whole pipeline. It does not run the upstream for you: if an upstream node has no output yet, the run is refused and the logs panel says so. Run the workflow once first, then iterate on single nodes.
Node status is shown live: idle, in‑progress, success, or error, with execution times per node and a progress bar for the run. Use the **logs panel** to inspect what happened, and the **stop** button to abort a run in progress.
Iterating on one part of a workflow? [Pin](/docs/pixelflow/guides/pinning-and-caching) finished nodes so re-runs skip them and reuse their cached output.
## Auto-save and version conflicts [#auto-save-and-version-conflicts]
Workflows save automatically as you edit — there's no save button. The title bar shows the current state: **Saving**, **Saved**, or **Save failed**.
Every save is stamped with a version number. If the same workflow is edited from two places at once (two tabs, or a teammate via [sharing](/docs/pixelflow/guides/sharing-and-collaboration)), the second save is **rejected** rather than overwriting the first — the title bar shows **Save failed** and *Failed to save changes* appears in the logs panel.
A rejected save is not retried, and the edits in that tab are not merged or recovered. Reload the page to pick up the current version, then redo them. Keep one editor open per workflow.
## Undo and redo [#undo-and-redo]
Standard undo/redo applies to graph edits — adding, moving, connecting, and deleting nodes — so you can experiment freely.
## Next steps [#next-steps]
# Account and Billing APIs (https://docs.segmind.com/docs/platform/account-and-billing-apis)
Check your Segmind credit balance programmatically with the get-user-credits endpoint, authenticated by your API key.
Account endpoints live on the same gateway as the model APIs,
`https://api.segmind.com/v1`, and take the same API key.
## Authentication [#authentication]
Send your key in the `x-api-key` header. You can create and revoke keys in the
console under **Developer → API Keys** — see
[Account and Developer Settings](/docs/platform/settings).
```shell
-H 'x-api-key: YOUR_API_KEY'
```
This is the same key you use for [model requests](/docs/serverless-api), so a
key that works for inference works here.
## Get your credit balance [#get-your-credit-balance]
```shell
curl 'https://api.segmind.com/v1/get-user-credits' \
-H 'x-api-key: YOUR_API_KEY'
```
```json
{
"credits": 0.0,
"free-credits": 0.0184921035
}
```
| Field | Meaning |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `credits` | Your spendable balance. This is the figure to read for "how much do I have left" and the one that matches the **Credits Balance** shown on the console dashboard. |
| `free-credits` | Also returned, and reported separately from `credits`. |
Both are returned as numbers, not strings, and at full precision rather than
rounded to cents — expect several decimal places, since a single request can
cost a fraction of one.
### Responses [#responses]
| Status | When | Body |
| ------ | ----------------------------------------------------------- | -------------------------------------------------------------------- |
| `200` | Success | `{"credits": …, "free-credits": …}` |
| `401` | No key sent at all | `{"error": "Missing Authorization or x-api-key in header"}` |
| `401` | Key sent but invalid or expired | `{"error": "Unauthorized. API key is invalid or may have expired…"}` |
| `404` | Authenticated, but no balance record exists for the account | `{"error": "No credits found for the user"}` |
The two `401`s are worth telling apart: the first means your header never
arrived — usually a client that drops unknown headers on redirect — while the
second means the key itself was rejected. Only the second is worth regenerating
a key over.
The invalid-key message ends by suggesting where to check your keys, and the
address it gives is an older console one. The current page is
**Developer → API Keys** at `platform.segmind.com/api-keys`.
## Reading your balance without a second call [#reading-your-balance-without-a-second-call]
You rarely need this endpoint in a loop, because **a synchronous model request
already tells you what it cost and what you have left.** A `v1` response carries
the accounting in its headers:
| Header | Holds |
| --------------------------- | ------------------------------------------------------------------------------------------------ |
| `x-cost` | what this request was charged |
| `x-remaining-credits` | your balance after it |
| `x-request-id` | the request id, the same one [Generations](/docs/serverless-api/monitoring#generations) lists |
| `x-generation-time` | how long the model itself took, in seconds |
| `x-seed-value` | the seed used, where the model reports one — see [Random seed](/docs/serverless-api/random-seed) |
| `x-rate-limit-reset-at-utc` | when your current rate-limit window resets |
Headers are how `v1` reports this because the response body is the output
itself — an image, not JSON. On [`v2`](/docs/serverless-api/async-inference) the
same figures arrive in the `metrics` object instead, as `cost` and
`remaining_credits`.
So for metering, read `x-cost` and `x-remaining-credits` off the request you
already made, and keep this endpoint for the times you want a balance without
running anything.
Checking your balance does not cost credits, and it reads the same balance the
gateway checks before running a model. A model request is refused when that
balance is below the **cost of the model you are calling** — not only when it
reaches zero — and comes back as `406` with an `Insufficient credits` error
naming both your balance and what the call needed.
## Related [#related]
* [Pricing and billing](/docs/platform/pricing-and-billing) — how credits are
priced and consumed.
* [Teams](/docs/platform/teams) — balances are per workspace, so switching teams
changes which balance you are reading.
# Platform (https://docs.segmind.com/docs/platform)
Manage your plan, billing, teams, and developer settings.
This section covers everything around your Segmind account — what you are
charged and how to top up, running a team, your profile and API keys, refunds,
the referral program, and the weekly [changelog](/docs/platform/release-notes).
# Pricing and Billing (https://docs.segmind.com/docs/platform/pricing-and-billing)
How Segmind charges for model APIs: per GPU-second or per generation, how GPU type affects cost, plus subscription plans and how billing works.
## Model API pricing [#model-api-pricing]
Model usage is charged either **per GPU-second** or **per generation**. Which
one applies is on each model's pricing tab — for example
[gpt-image-1 pricing](https://www.segmind.com/models/gpt-image-1/pricing).
### Per GPU-second [#per-gpu-second]
Requests are charged on **GPU processing time**, measured per second, so each
request costs according to how much GPU compute it consumes.
Models are hosted across a range of **GPUs** (A100, H100, L40S) and cloud
providers, so **price varies by model** depending on the underlying hardware.
Models on higher-end GPUs cost more per second but finish faster.
Each model's page carries its **price**, **GPU type**, and **expected generation
speed** — for example
[z-image-turbo pricing](https://www.segmind.com/models/z-image-turbo/pricing).
### Per generation [#per-generation]
Credits are deducted per generation. Parameters such as the number of seconds of
video or the output resolution can change the price of a single generation, so
check the model's pricing page for exact figures.
To see what you have actually been charged, use **Generations** for what you ran,
**Cost Analytics** for what it cost over time, and **Billing → Transaction
History** for individual charges and credits. All three are in the left nav.
## Billing logic [#billing-logic]
Segmind **reserves** credits before a model runs, against an estimate based on
the model and its expected processing time. That reservation is what stops a
request starting that you cannot afford — a call is refused outright when your
balance is below the cost of the model you are calling.
The reservation itself is internal. What you can observe on your balance is
simpler:
| While the request is | Your balance |
| -------------------- | ------------------------------------------------- |
| **running** | unchanged — there is no temporary dip to wait out |
| **completed** | drops **once**, by the actual cost of that run |
| **failed** | unchanged — nothing is charged |
The amount finally deducted is the **actual** cost, which can be lower than the
estimate that was reserved. You are never charged the estimate.
**Key point:** if a request fails for any reason — invalid parameters, server
errors, timeouts, content moderation — nothing is charged. This holds whether
the request was rejected before the model started or failed part-way through: a
failed asynchronous result comes back with timings but **no cost field at all**.
You only pay for requests that return a successful response.
For the exact figure on a given call, read `x-cost` from a synchronous response
or `metrics.cost` from an asynchronous one, rather than diffing your balance.
See [Account and Billing APIs](/docs/platform/account-and-billing-apis) for
reading your balance programmatically, and
[Cost Analytics](/docs/serverless-api/monitoring#cost-analytics) for totals over
time.
## PixelFlow pricing [#pixelflow-pricing]
Running a PixelFlow workflow costs the **sum of its parts** — the cost of
running each model in the workflow.
## Subscription plans [#subscription-plans]
Plans are billed monthly and include a credit allowance. Full details, including
storage and support terms, are on the [pricing page](https://www.segmind.com/pricing).
| Plan | Price | Monthly credits |
| -------------- | ------------- | ------------------- |
| **Flexible** | Pay as you go | — (top up from $10) |
| **Pro** | $39/month | $50 |
| **Business** | $99/month | $99 |
| **Scale** | $599/month | $599 |
| **Enterprise** | Custom | Custom |
On **Pro** the credits are worth more than the subscription — $39 buys $50 of
credits. On Business and Scale the allowance matches the price.
## Adding credits [#adding-credits]
Every account starts on the **Flexible** plan, shown as *Free Plan* in the
console until you subscribe. You can start with a top-up of as little as $10.
**Billing** in the left nav gives you three things:
* **Recharge** — add any dollar amount with a card. **Change Plan** switches
subscription tier.
* **Auto-recharge** — save a card and top up automatically whenever your balance
falls below a threshold you set, so requests don't start failing mid-run.
* **Transaction History** — every charge and credit, filterable by category and
date range.
Join our [Discord](https://discord.gg/Mf6QfkvFcs) with any billing questions.
# Referrals and Affiliates (https://docs.segmind.com/docs/platform/referrals)
Earn $10 in credits for every person you refer who spends $10 or more on Segmind, up to $100, plus details of the Segmind Affiliate Program.
Refer someone to Segmind and you both get credits. You earn **$10 in credits**
per successful referral, for up to **ten referrals** — a maximum of **$100**.
## Get your referral link [#get-your-referral-link]
Go to **Settings → Affiliates** in the console. Your link is generated for you
and looks like `https://www.segmind.com/invite/`.
The same page tracks your referrals: a **Total Signups** count and a table of
the people who used your link, each with their current **status**. You need to
accept the **Terms and Conditions** on this page to take part.
## How a referral pays out [#how-a-referral-pays-out]
### Share your link [#share-your-link]
Send it to someone who does not already have a Segmind account.
### They sign up through it [#they-sign-up-through-it]
They create an account using your link and a valid email address. Signing up
this way also earns them sign-up credits.
### They spend $10 or more [#they-spend-10-or-more]
Your $10 lands once the person you referred makes **a single payment of $10 or
more** — a recharge, a subscription, or a dedicated API setup.
It has to be **one** payment of $10 or more, not $10 of spending added up across
several smaller ones. A referral whose payments never individually cross that
line does not pay out.
Credits can take a few hours to appear in your account. Each referral pays out
once, and the bonus stops after your tenth.
## Segmind Affiliate Program [#segmind-affiliate-program]
The affiliate program is **not self-serve**. Revenue share is enabled per
account, for approved partners only — signing up or sharing your referral link
does not enrol you. Apply through the
[Creator Program](https://www.segmind.com/creator-program), or email
[contact@segmind.com](mailto:contact@segmind.com).
Approved affiliate partners earn a **10–25% revenue share** on everyone they
refer, for the referred user's first **12 months** — counted from the date that
user signed up, not from when they first paid.
| Partnership tier | Qualified users invited in 30 days | Revenue share |
| ---------------- | ---------------------------------- | ------------- |
| Mega | 5 to 25 | 10% |
| Giga | 25 to 100 | 20% |
| Tera | More than 100 | 25% |
Qualified users are those who signed up through your referral link and have paid
more than $5 to Segmind.
Once you are an approved affiliate partner, the Affiliates page also reports the
revenue share you have earned. The minimum withdrawal amount is $100, and only
one withdrawal request can be open at a time.
To join, apply through the
[Creator Program](https://www.segmind.com/creator-program) or email
[contact@segmind.com](mailto:contact@segmind.com). For general questions, find
us on [Discord](https://discord.gg/Mf6QfkvFcs).
# Refund Policy (https://docs.segmind.com/docs/platform/refund-policy)
We understand that circumstances can change, and we aim to keep our refund process clear, fair, and transparent.
## 1. How to Request a Refund [#1-how-to-request-a-refund]
To initiate a refund request, email
[support@segmind.com](mailto:support@segmind.com) and include the following
information:
* Your account email address
* Transaction details (date, amount, and what was purchased: credits or a subscription)
* The reason for your refund request
* Whether you are requesting a full or partial refund
You can find the date, amount and category of every charge under **Billing →
Transaction History** in the console — see
[Pricing and billing](/docs/platform/pricing-and-billing).
Our team will review your request based on the refund categories outlined below.
## 2. Refund Categories [#2-refund-categories]
Refund eligibility and processing depend on what was purchased and how it was used.
### A. Credit Purchase Refunds [#a-credit-purchase-refunds]
This category applies to users who have purchased a specific amount of credits.
**Eligibility**
* You may request a full or partial refund for credits that have **not yet been used**.
* Refund requests must be submitted **before the unused credits expire**.
* Refund requests must be sent by email to [support@segmind.com](mailto:support@segmind.com).
**Process**
* We will verify your unused and unexpired credit balance.
* If approved, a refund will be processed for the eligible amount, minus any applicable transaction fees.
* Your remaining credit balance will be adjusted accordingly.
### B. Subscription Refunds [#b-subscription-refunds]
This category applies to refunds for monthly or multi-month subscription payments.
**Eligibility**
* Refunds are generally determined based on the amount of **unused credits** associated with the subscription period.
* The subscription must be active or recently canceled at the time of the request.
* Refund requests must be submitted before the unused credits expire.
**Process**
* We will verify your subscription status and total credits used.
* If eligible, your subscription will be canceled immediately upon processing the refund.
* The refund amount will be calculated based on unused and unexpired credits.
* A manual refund will be issued for the approved amount, minus any applicable transaction fees.
* Your account's credit balance will be adjusted to reflect the refunded amount.
## 3. How credit expiry works [#3-how-credit-expiry-works]
Eligibility above depends on credits being unused **and** unexpired, so it helps
to know how both are tracked.
Credits are held in **batches**, one per purchase or grant, and a batch can
carry its own expiry date. When you spend credits, the batch **closest to
expiring is drawn down first**, so your oldest credits are always used before
newer ones.
Once a batch passes its expiry date it is removed and your balance drops by that
amount. Expired credits cannot be refunded, which is why a request has to reach
us while the credits are still live.
Your current balance is shown as **Credits Balance** on the
[Billing](https://platform.segmind.com/billing) page, and you can read it
programmatically with the
[credits endpoint](/docs/platform/account-and-billing-apis).
## 4. Final Authority [#4-final-authority]
Segmind reserves the **final right to approve or deny any refund request** based
on the validity, usage, and expiration status of the remaining credits.
## 5. Processing Time [#5-processing-time]
We aim to process all refund requests as quickly as possible. Once approved, you
will receive a confirmation email. Please note that it may take several business
days for the refunded amount to appear in your account, depending on your bank
or payment provider.
# Account and Developer Settings (https://docs.segmind.com/docs/platform/settings)
Find your account and developer settings in the Segmind console: profile, API keys, webhooks, and how to request account deletion.
Account and developer settings live in two sections at the bottom of the
console's left nav. Clicking either one swaps the nav for that section's pages.
| Nav | Contains |
| ------------- | ---------------------------------------------------------------------------------- |
| **Settings** | **Profile**, [Teams](/docs/platform/teams), [Affiliates](/docs/platform/referrals) |
| **Developer** | **API Keys**, **Webhooks** |
## Profile [#profile]
**Settings → Profile** shows your **Account Information** — the username and
email on the account — and the controls for deleting it.
## API keys and webhooks [#api-keys-and-webhooks]
**Developer → API Keys** is where you create and revoke the keys used to
authenticate API requests. See the
[AI Gateway docs](/docs/serverless-api) for how to send one.
**Developer → Webhooks** is where you register endpoints to be called when a job
changes state, so you don't have to poll for results. The
[Webhooks page](/docs/serverless-api/webhooks) covers the payload and the events
that fire.
## Delete your account [#delete-your-account]
Account deletion is irreversible. It cancels your team memberships and stops
your API keys from working.
Go to **Settings → Profile** and click **Delete your account**. You will be
asked to confirm, and you can optionally say why you are leaving.
Deleting is a **request**, not an instant action. Once submitted it is processed
in the background, and the Profile page then shows the request's **reason**,
**when it was requested**, and its **status** as it moves from `REQUESTED`
through `IN_PROGRESS` to completion.
Two things will stop a request going through:
* **A negative credit balance.** If your account has due credits you are asked
to settle the balance first. Top up on the [Billing](/docs/platform/pricing-and-billing)
page, then try again.
* **An existing request.** Only one deletion request can be open at a time; a
second is rejected and tells you the status of the one already in flight.
You do **not** need to leave or hand over your teams first — processing the
request deactivates your team memberships for you.
Deleting your account is not the same as deleting a team. A team outlives the
member who leaves it; see [Teams](/docs/platform/teams) for transferring
ownership and deleting a team.
# Teams (https://docs.segmind.com/docs/platform/teams)
Group work into Segmind teams, switch between workspaces, invite members with Admin or Member roles, and track team usage.
A **team** is a shared workspace. Everyone in a team works against the same
credit balance and the same Pixelflow library, so a team is the unit you use to
collaborate and to keep one project's spend separate from another's.
Every account starts with a **Personal** workspace. Any teams you create or are
invited to appear alongside it, and you are always working inside exactly one of
them at a time.
## Switch workspaces, or create a team [#switch-workspaces-or-create-a-team]
Your current workspace is shown at the **bottom left** of the console. Click it
to open the switcher.
The switcher lists every workspace you belong to with the plan it is on, and a
checkmark against the one you are in.
Switching workspaces changes what the rest of the console shows you — your
Pixelflows, generations, credits and billing all follow the workspace you are
currently in.
## Create a team [#create-a-team]
Click **+ New team** in the switcher. A name field opens in place, below the
list of workspaces.
Type a name and click **Create team**. Two things happen straight away:
* You become the team's **Owner**, so you get the management page and every
admin control on it.
* The console **switches you into the new team**, so the workspace shown at the
bottom left changes. Anything you build next belongs to that team, not to your
Personal workspace — switch back first if that is not what you want.
A new team starts on the **Free plan** with you as its only member.
## See the teams you belong to [#see-the-teams-you-belong-to]
Go to **Settings → Teams** in the left nav.
Each row shows the team's **Name**, your **Role** in it, and your **Status**.
Select a team to open its management page.
## Roles [#roles]
Segmind stores two roles — **Admin** and **Member** — and derives a third,
**Owner**, from whoever holds the team's billing.
| Role | Can do |
| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Owner** | Everything an Admin can, plus transfer billing ownership and delete the team. There is exactly one Owner: the member who holds the team's billing. |
| **Admin** | Manage members — invite, change roles, remove — and set per-member limits. |
| **Member** | Work in the team: build and run Pixelflows against the shared balance. No access to the management page. |
Because Owner is tied to billing rather than being a role you can assign, you
change it by **transferring ownership** to another member, not by editing their
role.
## Manage a team [#manage-a-team]
Opening a team from the Teams list takes you to its management page.
The **Members** table lists everyone in the team:
| Column | Shows |
| ---------- | ------------------------------------------------------------------------ |
| **Email** | the member's address |
| **Role** | Owner, Admin or Member |
| **Access** | which models they may use — `All access` unless you have restricted them |
| **Budget** | their spend cap, or `—` for no limit |
| **Status** | whether the membership is active |
| **Joined** | the date they accepted |
From here you can **rename the team** with the pencil beside its name, change a
member's role, remove a member, or **delete the team**.
### Invite a member [#invite-a-member]
**Invite member** takes an email address and a role, and lets you set that
person's limits *with the invitation* — so they apply from the moment it is
accepted, rather than needing a second pass once they join.
Both extras are optional and collapsed by default:
* **Model restrictions** — leave it on **All models**, or narrow it to a subset.
* **Spend limits** — a **Daily**, **Weekly** and **Monthly** cap in dollars.
Leave a field empty for no limit on that period, and you can set one period
without setting the others.
### Restrict models for the whole team [#restrict-models-for-the-whole-team]
Below the members table, **Model Provider Restrictions for Team** is a
**blocklist** applied to every member of the workspace: checked models are
blocked for everyone. Providers are listed with a count of how many of their
models are currently blocked, and each expands to the individual models. There
is a search box for finding a provider or model directly.
This is separate from the per-member restrictions set on an invite — the team
blocklist applies to everybody, including admins.
Management is admin-only. If you open a team you are only a Member of, the page
reads **"You do not have access to this"** and invites you to ask an admin for
access. Ask an existing Admin or the Owner to promote you.
Per-member budgets and model restrictions do not apply to the Owner.
## Track team usage [#track-team-usage]
Usage is per-workspace, so switch into the team first, then use:
* **Generations** — what has been run in this workspace.
* **Cost Analytics** — what it cost, broken down over time.
* **Billing** — the workspace's credit balance and plan.
All three are in the left nav.
# SDKs (https://docs.segmind.com/docs/sdks)
Official client libraries for the Segmind platform. Submit inference, poll for results, chat with LLMs, and upload files — without hand-rolling HTTP and polling loops.
The official client libraries for building on Segmind. They handle
authentication, the async submit-and-poll loop, error mapping, and file uploads
for you, so calling a model is a single function call.
## Available SDKs [#available-sdks]
## What the SDKs cover today [#what-the-sdks-cover-today]
Model inference on the [AI Gateway](/docs/serverless-api) — running any model,
LLM chat, and [file uploads](/docs/serverless-api/segmind-storage) — is fully
wrapped.
[Published PixelFlow workflows](/docs/pixelflow/publish-as-api) are **not usable
from the SDK yet.** The Python package exposes a `segmind.pixelflows` namespace,
but every method on it raises `AttributeError` in **1.1.0** — that is a known
defect on our side, not a mistake in your code. Call published workflows over
REST until a fix ships: it is the same submit-poll-fetch contract the SDK already
uses for models. See the [Workflow API Reference](/docs/pixelflow/api-reference).
## Prefer raw HTTP? [#prefer-raw-http]
The SDKs are a convenience layer — every model is reachable over plain HTTP.
See the [API Reference](/docs/serverless-api) for the v1 sync and
[v2 async](/docs/serverless-api/async-inference) endpoints.
# Python SDK (https://docs.segmind.com/docs/sdks/python)
Run any Segmind model from Python. Async-by-default run(), explicit sync run_sync(), submit/poll handles for long jobs, and a normalized LLM chat() — all over the v2 async gateway.
The Segmind Python SDK is a thin client over the [AI Gateway](/docs/serverless-api).
As of **1.1.0** it is **async-by-default**: `run()` submits to the
[v2 async API](/docs/serverless-api/async-inference), polls for you, and
returns the finished result. A blocking v1 call is still available as
`run_sync()`.
## Install [#install]
```bash
pip install "segmind>=1.2.0"
```
**1.1.0 is a breaking release.** `run()` is now **async** (v2). The old
blocking behaviour moved to `run_sync()`, and `run_async()` was **removed**
— call `run()` instead. If you're upgrading from 1.0.x, see
[Migrating from 1.0.x](#migrating-from-10x).
Set your API key once via the environment:
```bash
export SEGMIND_API_KEY="YOUR_API_KEY"
```
The SDK reads `SEGMIND_API_KEY` automatically. Grab a key from the
[API Keys page](https://platform.segmind.com/api-keys).
## Sync vs. async — which to use? [#sync-vs-async--which-to-use]
* **`run()` (async, default)** — submits to v2, polls, and returns the result.
Best for anything that can take more than a few seconds, and the right
default for almost all models. Has a built-in **600 s** deadline.
* **`run_sync()` (sync)** — a single blocking v1 HTTP call. Fine for fast
models (\< 60 s) when you want the raw bytes back immediately. v1 is in
maintenance mode.
* **`submit_async()` (handle)** — submit now, poll later with your own
deadline and cadence. Use this for **long video/LLM jobs** that may exceed
600 s, for fire-and-forget patterns, or to fan out many requests in
parallel.
## Quick start [#quick-start]
```python
import segmind
# Submit to v2, poll until COMPLETED, return the result body.
result = segmind.run("seedream-4.5", prompt="a red rose on a wooden table")
print(result["output"]) # URL to the generated image
```
```python
import segmind
# Single blocking v1 call — returns a raw httpx.Response.
response = segmind.run_sync("seedream-4.5", prompt="a red rose on a wooden table")
with open("rose.jpg", "wb") as f:
f.write(response.content)
```
## API [#api]
### `segmind.run(slug, **params) -> dict` [#segmindrunslug-params---dict]
Async by default. Submits to `POST /v2/{slug}`, polls until the request reaches
`COMPLETED`, and returns the final response body as a `dict`. Polls every
**1 s** with a **600 s** deadline.
```python
result = segmind.run("seedream-4.5", prompt="a sunset over the ocean")
print(result["output"])
```
`run()` forwards **every** keyword to the model body, so it does **not**
accept `timeout` or `interval` arguments (a model could legitimately have a
param named `timeout`). For a custom deadline or poll cadence, use
[`submit_async()`](#segmindsubmit_asyncslug-params---asyncjob) +
`job.wait(timeout=…, interval=…)`.
### `segmind.run_sync(slug, **params)` [#segmindrun_syncslug-params]
Synchronous, single blocking call to `POST /v1/{slug}`. Returns the raw
`httpx.Response` — use `.content` for binary output (images, audio) or
`.json()` for structured responses.
```python
response = segmind.run_sync("sdxl1.0-newreality-lightning", prompt="a cyberpunk city")
with open("city.jpg", "wb") as f:
f.write(response.content)
```
### `segmind.submit_async(slug, **params) -> AsyncJob` [#segmindsubmit_asyncslug-params---asyncjob]
Submits a v2 request and returns an [`AsyncJob`](#asyncjob) handle immediately,
without waiting for the result. Use it to control the poll deadline/cadence, to
keep the `request_id`, or to run other work while the job processes.
```python
job = segmind.submit_async("seedance-2.0", prompt="a sunset timelapse")
print(job.request_id) # e.g. "2c7f59ea-13f1-402c-9353-915a2b5a2124"
result = job.wait(timeout=600) # block until done
```
### `AsyncJob` [#asyncjob]
The handle returned by `submit_async()`.
| Attribute / method | Returns | Description |
| ------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------- |
| `.request_id` | `str` | Unique id for the submitted request. |
| `.status_url` | `str` | Lightweight status endpoint (no payload). |
| `.response_url` | `str` | Full result endpoint. |
| `.status()` | `dict` | Current status body without blocking. `status` is one of `QUEUED`, `PROCESSING`, `COMPLETED`, `FAILED`. |
| `.result()` | `dict` | Final response body. Only meaningful once `COMPLETED`. |
| `.wait(timeout=600.0, interval=1.0)` | `dict` | Block until a terminal state and return the result. Raises `InferenceFailed` / `InferenceTimeout`. |
```python
import time
import segmind
job = segmind.submit_async("seedance-2.0", prompt="a sunset timelapse")
# Manual polling, if you want it:
while job.status()["status"] not in ("COMPLETED", "FAILED"):
time.sleep(2)
result = job.result()
```
## Error handling [#error-handling]
`run()` and `AsyncJob.wait()` raise on failure:
| Exception | Raised when | Attributes |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
| `InferenceFailed` | The request reached `FAILED`. | `.detail` (server error string), `.status_body` (raw status payload) |
| `InferenceTimeout` | `wait()` exceeded its `timeout` before a terminal state. The job may still be running server-side — re-fetch to recover. | `.request_id`, `.elapsed_s` |
| `SegmindError` | Base class — transport/auth errors (401/404/5xx). | `.status`, `.detail` |
```python
import segmind
from segmind import InferenceFailed, InferenceTimeout
try:
result = segmind.run("seedream-4.5", prompt="a red rose")
except InferenceFailed as e:
print(f"Model failed: {e.detail}")
except InferenceTimeout as e:
print(f"Still running after {e.elapsed_s:.0f}s — request {e.request_id}")
```
## Worked examples [#worked-examples]
### Fast image model [#fast-image-model]
For a quick image model the defaults are all you need — `run()` typically
returns after a single poll.
```python
import segmind
result = segmind.run("seedream-4.5", prompt="a red rose on a wooden table, studio lighting")
print(result["output"]) # https://images.segmind.com/generations/...jpeg
```
### Slow video model [#slow-video-model]
Video generation can run for several minutes. Because `run()` caps the wait at
600 s, use `submit_async()` and pass a larger `timeout` (and a slower
`interval` to reduce poll traffic):
```python
import segmind
from segmind import InferenceFailed, InferenceTimeout
job = segmind.submit_async("seedance-2.0", prompt="a sunset timelapse over the ocean")
print(f"Submitted {job.request_id}")
try:
result = job.wait(timeout=900, interval=5) # up to 15 min, poll every 5s
print(result["output"]) # URL to the generated video
except InferenceTimeout as e:
print(f"Not done after {e.elapsed_s:.0f}s — poll {job.status_url} later")
except InferenceFailed as e:
print(f"Failed: {e.detail}")
```
For truly long-running or fire-and-forget jobs, register a
[webhook](/docs/serverless-api/webhooks) instead of polling — you'll be
notified when the result is ready.
## LLM chat [#llm-chat]
For text/LLM models, `chat()` returns a normalized `ChatResponse` with a
provider-agnostic `.text`. It's async-by-default like `run()`, with
`chat_sync()` and `submit_chat()` counterparts.
```python
import segmind
reply = segmind.chat("gpt-5.5", prompt="Write a haiku about the sea")
print(reply.text)
```
`ChatResponse` exposes `.text`, `.json()`, `.tool_calls`, `.usage`, and `.raw`.
Streaming is not supported by the gateway. See the
[v2 async reference](/docs/serverless-api/async-inference#llm--text-models) for
the underlying response shape.
## Beyond inference [#beyond-inference]
`run()` and `chat()` are the SDK's main event, but it also ships a handful of
namespaces that wrap the account-level APIs. They are useful and, until now,
undocumented.
### `segmind.models.list()` [#segmindmodelslist]
Every model on the platform, in one call. This is the only place the catalog is
available programmatically — there is no REST endpoint for it.
```python
import segmind
catalog = segmind.models.list()["Inference Model Information List"]
print(len(catalog))
print(catalog[0]["slug"], catalog[0]["type"])
```
Each entry carries `slug`, `title`, `type` (`imageToVideo`, `textToImage`, …),
`description`, `average_cost`, `latency`, `parameters_schema`, and flags such as
`is_new` and `is_depreciated`. Filtering on `is_depreciated` is the cheapest way
to check whether a slug you depend on is on its way out.
### `segmind.generations` [#segmindgenerations]
Your own request history — the same data behind
[Generations](/docs/serverless-api/monitoring#generations) in the console.
```python
page = segmind.generations.list(page=1)
print(page["total_records"], page["total_pages"], page["per_page"])
for row in page["data"]:
print(row["model_name"], row["created_at"], row["generation_url"])
# or the newest few for one model
segmind.generations.recent("p-image")
```
`list()` is paginated and returns `total_records`, `total_pages`,
`current_page`, `per_page`, `has_next`, `has_previous` and `data`. `recent()`
takes a model slug and returns `data` with `request_id`, `generation_url`,
`created_at` and `status`.
### `segmind.files.upload(file_paths)` [#segmindfilesuploadfile_paths]
Uploads local files and returns reusable URLs — the
[Segmind Storage](/docs/serverless-api/segmind-storage) API, with the base64
encoding done for you.
```python
result = segmind.files.upload(["portrait.jpg"])
url = result["file_urls"][0]
segmind.run("some-image-to-image-model", image=url)
```
Takes a list, returns one URL per file in the same order. The size and
pixel-count limits are the same as the underlying API.
### `segmind.webhooks` [#segmindwebhooks]
Manage webhook registrations without going through the console.
| Call | Does |
| ------------------------------------------------------- | ----------------------------------------------- |
| `webhooks.get()` | list your registrations — `[]` if you have none |
| `webhooks.add(webhook_url, event_types)` | register an endpoint |
| `webhooks.update(webhook_id, webhook_url, event_types)` | change one |
| `webhooks.delete(webhook_id)` | remove one |
| `webhooks.logs(webhook_id)` | delivery history for one registration |
See [Webhooks](/docs/serverless-api/webhooks) for the event names.
### `segmind.pixelflows` [#segmindpixelflows]
Run [published PixelFlow workflows](/docs/pixelflow/publish-as-api) without
hand-rolling the submit/poll HTTP calls. With the default `poll=True` it
submits, polls, and returns the final result; with `poll=False` it returns
immediately with the `request_id` and `poll_url`.
```python
import segmind
result = segmind.pixelflows.run(
workflow_id="your-workflow-id",
data={"Text_Prompt": "Generate an infographic"},
poll=True, # wait for completion
poll_interval=5, # seconds between status checks
max_wait_time=600, # give up after 10 minutes
)
# Or split submit and poll:
submitted = segmind.pixelflows.run(workflow_id="your-workflow-id", data={...}, poll=False)
status = segmind.pixelflows.get_status(poll_id=submitted["request_id"])
result = segmind.pixelflows.poll(poll_id=submitted["request_id"], max_wait_time=600)
```
The result mirrors the [Workflow API](/docs/pixelflow/api-reference) response
shapes (`QUEUED` / `PROCESSING` / `COMPLETED` / `FAILED`).
Polling (`poll=True`, `get_status()`, `poll()`) requires **segmind ≥ 1.2.0**
— in 1.1.0 every polling path raised `AttributeError`.
**`accounts` and `finetune` are client-only.** There are no module-level
`segmind.accounts` / `segmind.finetune` shortcuts — reaching for them raises
`AttributeError`. Both work through an explicit client:
`SegmindClient().accounts.current()` returns your account record, and
`SegmindClient().finetune` exposes the fine-tuning API (`submit`, `list`,
`details`, `upload_presigned_url`, `access_update`, `file_download`) — see
[Fine-tuning](/docs/fine-tuning) for the underlying endpoints. Credit balance
is still simplest over [REST](/docs/platform/account-and-billing-apis).
## Migrating from 1.0.x [#migrating-from-10x]
1.1.0 flips the default verb to async. Update calls as follows:
| 1.0.x | 1.1.0 |
| ------------------------------- | --------------------------------------------- |
| `segmind.run(slug, ...)` (sync) | `segmind.run_sync(slug, ...)` |
| `segmind.run_async(slug, ...)` | `segmind.run(slug, ...)` |
| — | `segmind.submit_async(slug, ...)` (unchanged) |
`run_async()` was removed with no alias — importing or calling it raises an
error. There is no behavioural change to `submit_async()`.
## See also [#see-also]
* [API Reference · Async Inference (V2)](/docs/serverless-api/async-inference) — the HTTP endpoints the SDK calls.
* [Webhooks](/docs/serverless-api/webhooks) — get notified instead of polling.
* [Authentication](/docs/get-started/authentication) — API keys and headers.
# Async Inference (V2) (https://docs.segmind.com/docs/serverless-api/async-inference)
Submit inference requests asynchronously and poll for results. Ideal for long-running models like video generation, image upscaling, and LLMs.
The V2 async API lets you submit a request, get a `request_id` immediately,
and poll for the result when it's ready. No long-lived HTTP connections.
**Sync (v1) vs. async (v2).** The v1 sync API (`POST /v1/{slug}`) returns the
output in a single blocking response and is in maintenance mode — fine for
fast models that finish in a few seconds. Use **v2 async** for anything that
can take longer than \~10 s (video, upscaling, LLMs), or whenever you want
explicit control over the request deadline. Prefer not to manage the polling
loop yourself? The [Python SDK](/docs/sdks/python) wraps all of this in a
single `segmind.run()` call.
## Quick start [#quick-start]
### 1. Submit a request [#1-submit-a-request]
```bash
curl -X POST "https://api.segmind.com/v2/seedream-4.5" \
-H "x-api-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "a red rose on a wooden table, studio lighting",
"aspect_ratio": "1:1",
"seed": 123
}'
```
**Response:**
```json
{
"request_id": "2c7f59ea-13f1-402c-9353-915a2b5a2124",
"status": "QUEUED",
"poll_url": "https://api.segmind.com/v1/requests/2c7f59ea-...",
"status_url": "https://api.segmind.com/v2/requests/2c7f59ea-.../status",
"response_url": "https://api.segmind.com/v2/requests/2c7f59ea-..."
}
```
| Field | Description |
| -------------- | -------------------------------------------- |
| `request_id` | Unique identifier for this request |
| `status` | Always `QUEUED` on submit |
| `poll_url` | V1 poll endpoint (backward compatible) |
| `status_url` | Lightweight status check (no output payload) |
| `response_url` | Full result endpoint (output + metadata) |
### 2. Check status (lightweight) [#2-check-status-lightweight]
Use `status_url` for efficient polling — it returns only status and metrics,
no output payload.
```bash
curl "https://api.segmind.com/v2/requests/2c7f59ea-.../status" \
-H "x-api-key: YOUR_API_KEY"
```
**While processing:**
```json
{
"status": "QUEUED",
"request_id": "2c7f59ea-...",
"status_url": "https://api.segmind.com/v2/requests/2c7f59ea-.../status",
"response_url": "https://api.segmind.com/v2/requests/2c7f59ea-...",
"metrics": {}
}
```
**When done:**
```json
{
"status": "COMPLETED",
"request_id": "2c7f59ea-...",
"metrics": {
"cost": 0.04,
"inference_time": 13.06,
"queue_time": 0.3,
"total_time": 13.36,
"remaining_credits": 92.86
}
}
```
See [Metrics](#metrics) for what each field means.
### 3. Fetch the result [#3-fetch-the-result]
Once status is `COMPLETED`, fetch the full result from `response_url`.
```bash
curl "https://api.segmind.com/v2/requests/2c7f59ea-..." \
-H "x-api-key: YOUR_API_KEY"
```
**Image result:**
```json
{
"status": "COMPLETED",
"images": [
{
"url": "https://images.segmind.com/generations/a1b2c3d4-.../e17ba.jpeg",
"content_type": "image/jpeg",
"file_size": "868446"
}
],
"output": "https://images.segmind.com/generations/a1b2c3d4-.../e17ba.jpeg",
"seed": "123",
"prompt": "a red rose on a wooden table, studio lighting",
"timings": { "inference": 13.06 },
"metrics": {
"cost": 0.04,
"inference_time": 13.06,
"queue_time": 0.3,
"total_time": 13.36,
"remaining_credits": 92.86
}
}
```
## Metrics [#metrics]
Every status (`status_url`) and result (`response_url`) response for a request
that reached `COMPLETED` (and, where available, `FAILED`) carries a `metrics`
object. Fields are best-effort — a field is omitted when it isn't applicable
(e.g. `cost`/`remaining_credits` on an unbilled or failed request).
| Field | Unit | Description |
| ------------------- | ------- | -------------------------------------------------------------------------------------------- |
| `cost` | credits | Credits charged for this inference. Matches the `X-Cost` header returned by the v1 sync API. |
| `remaining_credits` | credits | Your account balance after this inference was billed. |
| `inference_time` | seconds | Time the model spent processing (excludes time spent queued). |
| `queue_time` | seconds | Time the request waited in the queue before a worker picked it up. |
| `total_time` | seconds | End-to-end time, `queue_time + inference_time`. |
| `retry_count` | count | Number of times the request was retried by a worker. Present only when a retry occurred. |
`cost` lets you track per-request spend on the async API, the same way the
`X-Cost` response header works on the v1 sync API.
## Response formats by modality [#response-formats-by-modality]
The result shape depends on what the model produces.
### Image models [#image-models]
```json
{
"status": "COMPLETED",
"images": [{ "url": "...", "content_type": "image/jpeg", "file_size": "..." }],
"output": "https://...",
"seed": "123",
"prompt": "...",
"timings": { "inference": 13.06 },
"metrics": {
"cost": 0.04,
"inference_time": 13.06,
"queue_time": 0.3,
"total_time": 13.36,
"remaining_credits": 92.86
}
}
```
### Video models [#video-models]
```json
{
"status": "COMPLETED",
"video": {
"url": "...",
"content_type": "video/mp4",
"file_name": "output.mp4",
"file_size": 5757619
},
"output": "https://..."
}
```
### LLM / text models [#llm--text-models]
```json
{
"status": "COMPLETED",
"output": "The generated text...",
"reasoning": null,
"partial": false,
"error": null
}
```
The `output` field is always present across all modalities for backward
compatibility.
## Status values [#status-values]
| Status | Description |
| ------------ | -------------------------------------- |
| `QUEUED` | Request accepted, waiting for a worker |
| `PROCESSING` | A worker has picked up the request |
| `COMPLETED` | Inference finished, result available |
| `FAILED` | Inference failed (see `error` field) |
## Polling guidance [#polling-guidance]
Poll the `status_url` until `status` is `COMPLETED` or `FAILED`, then fetch the
full body from `response_url`.
* **Interval:** default to **1 s** between polls. For known-slow models (long
video, long-running LLMs) back off to 5–10 s to cut request volume.
* **Timeout:** use an overall deadline of **≤ 600 s** for most models. Raise it
for slow video models, or avoid polling entirely with
[webhooks](/docs/serverless-api/webhooks) for fire-and-forget jobs.
* Use the lightweight `status_url` (not `response_url`) while polling — it skips
the output payload.
## Idempotency [#idempotency]
Each `POST /v2/{slug}` creates a **new** `request_id`. The submit is the only
step worth retrying: if a submit returns a 5xx, **retry the submit** (you'll get
a fresh `request_id`). Never retry by re-POSTing after a successful submit — that
starts a second billable job. Polling (`GET`) is always safe to retry.
A grounded request adds a top-level `grounding` object to this result — see
[Web Search Grounding](/docs/serverless-api/web-search-grounding).
## Where the output lives [#where-the-output-lives]
`output` and every entry in `images` point at **`images.segmind.com`**. If you
run behind an egress allowlist, a firewall, or a Content Security Policy, that
is the host to allow — the API host alone is not enough to fetch a result.
**The output URL is public.** It needs no API key — anything that has the link
can fetch the file. The link is long and unguessable, so treat it the way you
would any unlisted share link: fine to pass to your own frontend, not a
substitute for access control.
## Result expiry [#result-expiry]
Two different things expire on two different clocks, and it is worth keeping
them apart:
| | How long it lasts | What happens after |
| ------------------------------------------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------- |
| **The request record** — everything under `/v1/requests/{id}` and `/v2/requests/{id}` | temporary | all three poll endpoints return `404` |
| **The output file** — the URL in `output` and `images[].url` | kept under the [storage policy](/docs/serverless-api/logging) | the link stops resolving |
The request record is the short-lived one. **The output file outlives it** — a
result URL keeps working after the request that produced it has stopped being
pollable.
**Save the output URL when you fetch the result.** The polling window is not
a guarantee and is not something to design around — once the request record
expires you cannot recover the URL from the API, even though the file itself
is still there. Treat the poll endpoints as a delivery mechanism, not as
storage.
## Error handling [#error-handling]
**Failed requests** return HTTP `422` on V2 endpoints. Timing metrics may still be
present, but billing fields (`cost`, `remaining_credits`) are omitted since nothing
was charged:
```json
{
"status": "FAILED",
"error": "Prompt is Mandatory and must be string",
"metrics": { "inference_time": 0.007, "queue_time": 0.23, "total_time": 0.24 }
}
```
**Not found** returns HTTP `404`:
```json
{
"error": "Request 00000000-... not found"
}
```
## Endpoints summary [#endpoints-summary]
| Endpoint | Method | Description |
| -------------------------- | ------ | -------------------------------------- |
| `/v2/{model}` | POST | Submit async request |
| `/v2/requests/{id}/status` | GET | Lightweight status + metrics |
| `/v2/requests/{id}` | GET | Full result (when `COMPLETED`) |
| `/v1/requests/{id}` | GET | Legacy poll (status + output combined) |
## Full Python example [#full-python-example]
The [Python SDK](/docs/sdks/python) does the submit-and-poll loop for you —
`result = segmind.run("seedream-4.5", prompt="...")`. The raw example below
shows what happens under the hood if you'd rather call the API directly.
```python
import requests
import time
API_KEY = "YOUR_API_KEY"
BASE = "https://api.segmind.com"
# Submit
resp = requests.post(
f"{BASE}/v2/seedream-4.5",
headers={"x-api-key": API_KEY},
json={"prompt": "a beautiful sunset", "aspect_ratio": "16:9"},
)
data = resp.json()
request_id = data["request_id"]
print(f"Submitted: {request_id}")
# Poll
while True:
status = requests.get(
f"{BASE}/v2/requests/{request_id}/status",
headers={"x-api-key": API_KEY},
).json()
if status["status"] in ("COMPLETED", "FAILED"):
break
time.sleep(2)
# Fetch result
if status["status"] == "COMPLETED":
result = requests.get(
f"{BASE}/v2/requests/{request_id}",
headers={"x-api-key": API_KEY},
).json()
print(f"Image URL: {result['images'][0]['url']}")
print(f"Inference time: {result['timings']['inference']}s")
```
## See also [#see-also]
* [Python SDK](/docs/sdks/python) — `segmind.run()` / `submit_async()` instead of hand-rolled polling.
* [Webhooks](/docs/serverless-api/webhooks) — get notified when a result is ready.
* [Rate limits](/docs/serverless-api/rate-limits) and [API error codes](/docs/serverless-api).
# API Reference (https://docs.segmind.com/docs/serverless-api)
Authenticate with an x-api-key header and call any model on the Segmind AI Gateway over REST, with cURL and Python examples.
## Authentication [#authentication]
### Create an API key [#create-an-api-key]
The Segmind AI Gateway uses API keys for authentication. To create one, sign in
to your account and head to the
[API Keys page](https://platform.segmind.com/api-keys) on the dashboard.
### Use the API [#use-the-api]
Pass your API key in the `x-api-key` request header.
An image model returns **the image bytes as the response body**, not JSON — so
write the response to a file rather than printing it.
Example cURL request:
```bash
curl -X POST "https://api.segmind.com/v1/fast-flux-schnell" \
-H "x-api-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
--output output.jpg \
-d '{
"prompt": "a futuristic city skyline at sunset, cinematic",
"steps": 4,
"aspect_ratio": "1:1"
}'
```
Example Python request:
```python
import requests
api_key = "YOUR_API_KEY"
url = "https://api.segmind.com/v1/fast-flux-schnell"
data = {
"prompt": "a futuristic city skyline at sunset, cinematic",
"steps": 4,
"aspect_ratio": "1:1",
}
response = requests.post(url, json=data, headers={"x-api-key": api_key})
response.raise_for_status()
with open("output.jpg", "wb") as f:
f.write(response.content)
```
## Finding a model's parameters [#finding-a-models-parameters]
Every model takes a different request body. To see the one you need, open the
model's page and click the **API** tab — for example
[sdxl1.0-newreality-lightning](https://www.segmind.com/models/sdxl1.0-newreality-lightning/api).
It lists every parameter the model accepts, along with example code.
## Endpoints [#endpoints]
**Base URL**
`POST https://api.segmind.com/...`
**Version 1 (v1)**
Some endpoints that typically complete their requests within 60 seconds are on version 1. For example: `https://api.segmind.com/v1/sdxl1.0-newreality-lightning`
**Version 2 (v2)**
We created v2 to serve APIs that typically take longer than 60 seconds to process.
## API error codes [#api-error-codes]
The status codes you are most likely to see from the gateway:
| Code | Status | Meaning | Billed? |
| ------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| **200** | OK | Request completed successfully and output was produced. | Yes |
| **400** | Bad Request | The request could not be processed — a malformed body, a missing required field, or an operation the model does not support. | No |
| **401** | Unauthorized | Authentication failed. Check your API key. | No |
| **403** | Forbidden | The model exists, but your account or team is not permitted to call it. | No |
| **404** | Not Found | No such model endpoint, or no such request ID. | No |
| **405** | Method Not Allowed | Wrong HTTP verb — the model routes take `POST`. **Returns HTML, not JSON.** | No |
| **406** | Not Acceptable | **Most often a missing or wrong `Content-Type`.** Also: your balance is below the model's cost, a parameter value was rejected up front, or a team spend limit has been reached. | No |
| **422** | Unprocessable | On v2, the inference itself failed. | No |
| **429** | Too Many Requests | Rate limit exceeded. Retry after a short delay. | No |
| **500** | Server Error | An internal server error occurred during processing. | No |
A few of these are easy to misread, so they are worth spelling out:
* **The most common `406` has nothing to do with credits.** Send a request with
no `Content-Type`, or one that is not `application/json` or
`multipart/form-data`, and you get `406` with *"Invalid content type"*. Some
HTTP clients omit the header when a body is passed as a plain string, so this
is easy to hit by accident and easy to misdiagnose as a billing problem.
* **`406` also covers credits and limits.** Your balance being below the
model's cost, a parameter value rejected before the model runs — an
unsupported `duration` or `resolution`, say — and a member hitting a
[team spend limit](/docs/platform/teams#invite-a-member), which returns a
message naming the period and the cap.
* **Not every bad parameter is a `406`.** Values are checked up front only where
the model declares a fixed set; anything else reaches the model and fails
during generation, which surfaces as a `500`. So a `500` on a request you have
only just changed is worth re-reading as a parameter problem before assuming
the platform is broken.
* **`405` is the one response that is not JSON.** Every other error returns
`{"error": …}`; a wrong verb returns an HTML error page. A client that calls
`.json()` on every response without checking the status will throw here rather
than report the real problem.
* **`403` is a permission decision, not a bad request.** Retrying will not help;
the model is restricted for your team, or it is private to another account.
See [model restrictions](/docs/platform/teams#restrict-models-for-the-whole-team).
* **`422` on v2 means the job ran and failed**, not that your request body was
wrong — the response carries a `status` of `FAILED` and an `error` describing
what went wrong. See
[Async inference](/docs/serverless-api/async-inference#error-handling).
**Billing note:** you are charged only for requests that return HTTP 200. Every
error response rolls the credit reservation back in full. See
[Billing logic](/docs/platform/pricing-and-billing#billing-logic) for how the
reservation system works.
# Logging (https://docs.segmind.com/docs/serverless-api/logging)
What Segmind logs for usage and billing, the data we never store, and how long files are held temporarily during model fine-tuning.
### Overview [#overview]
At Segmind, we value your privacy and ensure that the information we log is strictly for operational and billing purposes. This document outlines what data we collect, how we use it, and our policies regarding the storage of your data.
### What We Log [#what-we-log]
1. **Usage and Billing Metrics**:
* We log basic information to help us calculate usage and billing metrics. This includes:
* **Time of Inference**: The exact date and time each inference is run.
* **Inference Duration**: The time taken to run each inference.
2. **Prompt and Settings**:
* For better user experience and caching, Segmind stores the prompt and any associated configuration parameters that are inputs to a model. This allows us to optimize performance and ensure smooth operation. No images/videos/audio files are stored.
* **Outputs**: Segmind stores outputs for 7 days after inference, post which all outputs are automatically deleted. This is the output **file** at its result URL — the request record you poll on the async endpoints expires well before this, so save the URL when you fetch it. See [Result expiry](/docs/serverless-api/async-inference#result-expiry).
### Data We Do Not Store [#data-we-do-not-store]
1. **Model Inference Data**:
* Segmind does not store any input images, videos, or audio files associated with any run for model inferencing. Your data remains transient and is processed only for the duration of the inference.
### Temporary Storage for Model Fine-Tuning [#temporary-storage-for-model-fine-tuning]
1. **Fine-Tuning Images**:
* Images required for fine-tuning a model are stored for a limited amount of time to complete the fine-tuning process.
* These images can be deleted upon request. Please contact our support team if you wish to have them removed from our servers.
# Model Catalog (https://docs.segmind.com/docs/serverless-api/model-catalog)
Every model currently on the Segmind AI Gateway — 672 models with their API slugs, grouped by task. Regenerated automatically from the live catalog.
{/* AUTO-GENERATED — do not edit by hand.
Regenerate with: node scripts/generate-model-catalog.mjs
The model-catalog-sync workflow keeps it current and opens a PR
when the live catalog has changed. */}
Every model on the [AI Gateway](/docs/serverless-api), with the slug you pass
to `https://api.segmind.com/v1/` (or [`/v2` for async](/docs/serverless-api/async-inference)) and to
[`segmind.run()`](/docs/sdks/python) in the Python SDK — 672
models, regenerated automatically from the live catalog.
**Checking availability programmatically?** This page is a snapshot; the
authoritative source is the live catalog itself. Call
[`segmind.models.list()`](/docs/sdks/python) or `GET`
`https://api.spotprod.segmind.com/inference-model-information/list` — each
entry carries `slug`, `is_depreciated`, and the full `parameters_schema`.
An AI assistant answering "does Segmind support model X?" should prefer that
call over any static list, this one included.
**Browsing as a human?** [segmind.com/models](https://www.segmind.com/models)
is the searchable catalog with previews, parameters, and pricing.
## Recently added [#recently-added]
Model slugs for recently added on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
sarvam-bulbul-v3-tts — Text-to-speech in 11 Indian languages with 37 voices. (added 2026-09)
p-video-edit — Edit video from a text prompt, keep original motion. (added 2026-09)
gemini-omni-1.1 — Text-to-video with synchronized native audio, up to 4K. (added 2026-08)
gemini-omni-1.1-video-extend — Extend short video clips into longer seamless scenes. (added 2026-08)
gemini-omni-1.1-video-edit — Edit videos with a text prompt, subject preserved. (added 2026-08)
lyria-3-pro — Full-length text-to-music songs with vocals and lyrics. (added 2026-08)
lyria-3 — Generate 30-second songs with vocals from text or images. (added 2026-08)
gemini-3.7-flash — Fast multimodal LLM for coding, agents, and long-document analysis. (added 2026-08)
kokoro-82m — Text-to-speech with 54 multilingual voices. (added 2026-08)
whisper-large-v3 — Transcribe speech-to-text in 99 languages with timestamps. (added 2026-08)
wan3.0-video — Generate 30-second 1080p video with native audio. (added 2026-08)
wan2.6-i2v-flash — Animate photos into 15-second 1080p video with native audio. (added 2026-08)
grok-imagine-image-2 — Text-to-image and image editing with crisp, legible text. (added 2026-08)
ltx-2.5-pro — Generate 1080p video with native audio and multi-shot scenes. (added 2026-08)
ltx-2.5-fast — Text-to-video and image-to-video with native audio, up to 4K. (added 2026-08)
qwen-image-3 — Generate and edit legible in-image text, up to 2K. (added 2026-08)
seedream-5-pro-layer-decomposition — Split any image into editable transparent PNG layers. (added 2026-08)
bria-extract-object — Extract any named object into a transparent PNG cutout. (added 2026-08)
seedance-2.5 — Generate cinematic multi-shot AI videos up to 30 seconds with synchronized native audio from text, images, or… (added 2026-08)
flux-3-draft-enhance — Upscale AI video drafts to Full-HD with native audio. (added 2026-08)
flux-3-extend-video — Extend clips into seamless video continuations with synchronized audio. (added 2026-08)
flux-3-image-to-video — Animate images into 20-second clips with synchronized native audio. (added 2026-08)
flux-3-text-to-video — Cinematic text-to-video with native lip-synced audio, up to 20s. (added 2026-08)
qwen-3.8-max — Multimodal reasoning and agentic coding with 1M-token context. (added 2026-08)
grok-imagine-video-1.5-reference-to-video — Character-consistent video from up to 7 reference images. (added 2026-08)
```
## this is first creation [#this-is-first-creation]
Model slugs for this is first creation on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
Image-shakil — This is Demo creation
```
## Audio & speech synthesis [#audio--speech-synthesis]
Model slugs for audio & speech synthesis on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
ace-step-music — ACE-Step generates high-quality music rapidly, enhancing the creative process for developers and artists worl…
chatterbox-tts — Chatterbox transforms text into rich, natural speech with adjustable emotional expressiveness for diverse app…
chatterbox-turbo-tts — Ultra-fast, human-quality TTS with emotional expression.
dia — Dia by Nari Labs is an advanced open-weights TTS model that brings scripts to life with natural speech, emoti…
dubbing — Instantly dubs audio and video into 29 languages while preserving each speaker's original voice.
elevenlabs-dialogue — Immersive, emotionally expressive multi-speaker audio dialogue.
gemini-2.5-flash-tts — Fast, lifelike text-to-speech with expressive emotional tones.
gemini-2.5-pro-tts — Human-like speech synthesis with rich expressive emotional depth.
gemini-3.1-flash-tts — Expressive, controllable TTS with 70+ language support.
grok-tts — Convert text to speech in 20 languages with five voices.
kokoro-82m — Text-to-speech with 54 multilingual voices.
lyria-2 — Lyria 2 by Google DeepMind is an advanced model that generates high-fidelity 48kHz stereo instrumental music…
lyria-3 — Generate 30-second songs with vocals from text or images.
lyria-3-pro — Full-length text-to-music songs with vocals and lyrics.
meta-musicgen-medium — MusicGen: Transform text into music with AI. Create unique, high-quality audio from simple descriptions. Expe…
myshell-tts — MyShell's Voice Cloning and Text to Speech - Transform your audio content with realistic, personalized voices…
openvoice — OpenVoice is a versatile voice cloning model that supports multiple languages and offers precise tone replica…
orpheus-3b-0.1 — Orpheus TTS is an open-source text-to-speech (TTS) system powered by the Llama 3B language model, designed fo…
sam-audio-large — Isolate any described sound from mixed audio tracks.
sarvam-bulbul-v3-tts — Text-to-speech in 11 Indian languages with 37 voices.
seed-audio-1.0 — Generate full audio scenes: dialogue, music, effects, voice cloning.
seed-speech-tts — Natural multilingual text-to-speech and voiceovers from text.
sonilo-text-to-audio — Commercial-safe music and sound effects from text prompts.
sound-generation — Eleven Labs' Sound Generation API provides a robust development tool for programmatically generating audio co…
tts-eleven-labs — ElevenLabs TTS transforms text into captivating, human-like speech for diverse applications.
veena-max-tts — VeenaMAX transforms text into expressive, real-time speech across multiple Indian languages for seamless comm…
veena-tts — Veena transforms text into high-fidelity, expressive speech in Hindi and English for real-time applications.
```
## Audio to audio [#audio-to-audio]
Model slugs for audio to audio on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
elevenlabs-audio-isolation — Extract clear speech from noisy audio and video.
sts-eleven-labs — Eleven Labs Speech-to-Speech offers AI-powered voice conversion for content creators, media professionals, an…
```
## Image editing & transformation [#image-editing--transformation]
Model slugs for image editing & transformation on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
ai-product-photo-editor — AI Product Photo Editor leverages advanced image-based ML techniques to generate high-quality product visuals…
ai-product-photography — Elevate your product imagery with our AI-powered photography model. Create stunning, professional-quality pho…
alle-v2 — IDM+Faceswap
aura-flow — Largest completely open sourced flow-based generation model that is capable of text-to-image generation
automatic-mask-generator — Automatic Mask Generator is a powerful tool that automates the creation of precise masks for inpainting
become-image — Turn any image of a face into artwork using Stable Diffusion Controlnet and IPAdapter
bg-removal — This model removes the background image from any image
bg-removal-v2 — This model removes the background image from any image
bria-blur-background — Bria AI Image Editing API v2 enables precise and context-aware image manipulation for stunning visual outcome…
bria-enhance-image — Bria AI creates precise, high-quality image enhancements and manipulations for diverse creative applications.
bria-erase-foreground — Seamlessly removes foreground subjects and regenerates backgrounds for flawless image editing.
bria-eraser — AI object removal with seamless context-aware inpainting.
bria-expand-image — Bria Expand enables precise image manipulation and enhancement with generative AI, trained exclusively on lic…
bria-extract-object — Extract any named object into a transparent PNG cutout.
bria-fibo-image-edit — Edit images with structured JSON, masks, and multi-image references.
bria-gen-fill — Bria AI enables precise generative image editing for seamless creative enhancements and transformations.
bria-increase-resolution — Seamlessly upscale and manipulate images while preserving the highest fidelity and safety standards.
bria-lifestyle-shot-by-image — Transforms ordinary product images into stunning, marketing-ready visuals for eCommerce success.
bria-lifestyle-shot-by-text — Transform isolated product images into dynamic lifestyle scenes with AI-driven contextual realism.
bria-product-cutout — Automates precise product cutouts and background removal for professional eCommerce imagery at scale.
bria-product-packshot — Transform product photos into professional, market-ready images with intelligent enhancements and background…
bria-product-shadow — Bria Product Shadow enhances product images with realistic shadows for professional eCommerce presentations.
bria-remove-background — Effortlessly extract backgrounds with unmatched precision, powered by models trained exclusively on licensed…
bria-replace-background — Transform images through advanced background editing and generative content creation for diverse applications.
caricature-style — Transform everyday photos into lively, whimsical caricature illustrations that highlight individual features…
clarity-upscaler — High resolution creative image Upscaler and Enhancer. A free Magnific alternative.
clarityai-creative-upscaler — Creative image upscaling with fine detail enhancement.
clarityai-crystal-upscaler — Upscale images up to 200x with enhanced detail and vibrancy.
clarityai-flux-upscaler — Transform low-resolution images into stunning high-quality visuals.
codeformer — CodeFormer is a robust face restoration algorithm for old photos or AI-generated faces.
consistent-character — Create images of a given character in different poses
consistent-character-with-pose — Create images of a given character in different poses
esrgan — ERGAN is an Image Super-Resolution (upscaler) model that enhances images with stunning, high-quality upscalin…
expression-editor — Expression Editor uses reference images to accurately generate new images with desired expressions. Perfect f…
face-detailer — Restore characters' faces to their original glory with Face Detailer. Enhance facial details, eliminate disto…
face-to-many — Turn a face into 3D, emoji, pixel art, video game, claymation or toy
face-to-sticker — Turn a face into a sticker
faceswap-comic — FaceSwap Comic v1 is an AI-powered face swapping model designed to blend real faces into illustrated or carto…
faceswap-moonfrog-v3 — Take a picture/gif and replace the face in it with a face of your choice. You only need one image of the desi…
faceswap-v2 — Take a picture/gif and replace the face in it with a face of your choice. You only need one image of the desi…
faceswap-v3 — Face Swap V3 is a cutting-edge tool that empowers you to seamlessly swap faces in images. With customizable f…
faceswap-v3-multifaceswap — Faceswap V3 Multifaceswap enables realistic face swapping in images, preserving lighting and expressions for…
faceswap-v4 — Segmind FaceSwap v4 enables fast and precise face or head swapping between images with customizable options f…
faceswap-v5 — Ultra-fast face and head swapping in images.
flux-2-flex — Consistent-style photorealistic images using reference inputs.
flux-2-klein-4b — Sub-second photorealistic image generation and editing.
flux-2-klein-9b — Ultra-fast photorealistic image generation on consumer GPUs.
flux-2-max — Photorealistic images with maximum consistency and fine detail.
flux-2-pro — High-quality photorealistic images with cross-output consistency.
flux-canny-dev — Open-weight edge-guided image generation. Control structure and composition using Canny edge detection.
flux-canny-pro — Professional edge-guided image generation. Control structure and composition using Canny edge detection
flux-controlnet — Flux ControlNets is a collection of models that gives you precise control over image generation. By integrati…
flux-depth-dev — Open-weight depth-aware image generation. Edit images while preserving spatial relationships.
flux-depth-pro — Professional depth-aware image generation. Edit images while preserving spatial relationships.
flux-fill-dev — Open-weight inpainting model for editing and extending images. Guidance-distilled from FLUX.1 Fill Dev
flux-fill-pro — Professional inpainting and outpainting model with state-of-the-art performance. Edit or extend images with n…
flux-img2img — Flux Image-To-Image model by Black Forest Labs is an advanced deep learning tool designed for transforming im…
flux-inpaint — Flux Inpainting is a powerful image editing tool designed to effortlessly edit and enhance your images. It's…
flux-ipadapter — Flux IP Adapter is a cutting-edge AI model that lets you to create stunning, customized images. With its adva…
flux-kontext-dev — FLUX.1 Kontext [dev] creates coherent and editable images by integrating text and visual cues for iterative d…
flux-kontext-max — FLUX.1 Kontext [max] transforms textual descriptions into stunning, high-fidelity images with seamless typogr…
flux-kontext-pro — FLUX.1 Kontext Pro transforms text prompts into high-quality, customized images with remarkable efficiency an…
flux-krea-dev — FLUX.1 Krea generates stunning, photorealistic images with fine-tuned aesthetic control for diverse creative…
flux-pulid — Flux PuLID: Customize AI-generated images with your unique identity. Seamlessly integrate faces into text-to-…
flux-redux-dev — Open-weight image variation model. Create new versions while preserving key elements of your original.
flux-redux-schnell — Fast, efficient image variation model for rapid iteration and experimentation.
focus-outpaint — Fooocus Outpainting transforms ordinary images into extraordinary works of art by seamlessly expanding their…
fooocus — Fooocus enables high-quality image generation effortlessly, combining the best of Stable Diffusion and Midjou…
gpt-image-1-edit — Edit and compose images using natural language with GPT Image 1 Edit, OpenAI’s powerful inpainting and multi-…
gpt-image-1-edit-mini — Affordable text-driven image generation and editing.
gpt-image-1.5-edit — Precise image editing via natural language instructions.
grok-imagine-image — Text-to-image generation and editing, up to 2K resolution.
grok-imagine-image-2 — Text-to-image and image editing with crisp, legible text.
heygen-generate-look — Change avatar outfits and backgrounds while keeping the same face.
hidream-l1-fast — HiDream-I1 is a next-generation, open-source image generative foundation model designed for text-to-image syn…
higgsfield-soul-2 — Generate fashion-editorial photorealistic photos from text or reference.
higgsfield-text2image-soul — SOUL AI transforms text into stunning, customizable visuals with unparalleled style control and precision.
hyperswap-image-faceswap-by-facefusion-labs — High-quality face swapping built for real production workflows.
ic-light — Prompts to auto-magically relight your images.
icon-overlay — icon overlay
ideogram-2a-img-2-img — Ideogram Image to Image: Transform your images with ease! Enhance, modify, or create entirely new visuals usi…
ideogram-3-reframe — Ideogram 3.0's Reframe effortlessly adapts images to diverse formats, enhancing visual content creation for a…
ideogram-3-remix — Ideogram 3 Remix enables versatile image transformation, enhancing creativity through customizable design ite…
ideogram-3-replace-background — Effortlessly replace backgrounds in images, enhancing visual storytelling and creativity with precision and s…
ideogram-character — Achieve perfect character consistency across multiple generations from a single reference image.
ideogram-img-2-img — Ideogram Image to Image: Transform your images with ease! Enhance, modify, or create entirely new visuals usi…
ideogram-reframe — Transform your images with Ideogram Reframe! Easily reframe square images to your chosen resolution.
ideogram-turbo-img-2-img — Transform images instantly with Ideogram Turbo Image to Image! Fast AI for quick edits & creative remixes.
ideogram-v4-remix — Restyle any image into posters with legible in-image text.
idm-vton — Best-in-class clothing virtual try on in the wild
illusion-diffusion-hq — Monster Labs QrCode ControlNet on top of SD Realistic Vision v5.1
image-01 — Generate high-fidelity images from text with precise control & stunning quality with Minimax Image-01.
infinite-you — InfiniteYou generates high-fidelity portraits preserving identity while aligning with creative text prompts.
inpaint-mask-maker — Real-Time Open-Vocabulary Object Detection
insta-depth — InstantID aims to generate customized images with various poses or styles from only a single reference ID ima…
instantid — InstantID aims to generate customized images with various poses or styles from only a single reference ID ima…
ip-sdxl-depth — IP Adapter Depth XL is built on the SDXL framework. This model integrates the IP Adapter and Depth preprocess…
kling-3-image2image — Transform images into photorealistic, production-ready visuals.
kling-o1 — Text-to-video creation with precise AI-driven motion control.
kolors — Kolors is a cutting-edge text-to-image model that bridges language and visual art. Transform your textual ide…
luma-uni-1 — Reasoning-first text-to-image and natural-language image editing.
luma-uni-1-max — Generate and edit images from plain-text instructions.
magic-eraser — LaMA Object Removal- AI Magic Eraser
material-transfer — Transfer a material from an image to a subject
multi-image-kontext-max — FLUX.1 Kontext [max] creates stunning, photorealistic images from text prompts and input images seamlessly.
multi-image-kontext-pro — Transform text into stunning, professional-grade images with precise editing capabilities.
nano-banana-2 — Fast photorealistic images — ideal for marketing and ads.
nano-banana-2-lite — Generate and edit 1K images in about four seconds.
nano-banana-pro — High-fidelity images with accurate multilingual text rendering.
nomos-upscaler — This upscaling model is ideal for enhancing amateur to professional photos, excelling with subjects like cats…
ominicontrol — OminiControl is an innovative framework that optimizes Diffusion Transformer models for versatile image gener…
omni-zero — Omni-Zero: A diffusion pipeline for zero-shot stylized portrait creation.
p-image-edit — Multi-image editing with AI-guided precision and control.
p-image-try-on — Dress photos in multiple garments with photorealistic virtual try-on.
pulid-base — Novel tuning-free ID customization method for text-to-image generation.
qwen-image-edit — Transform images effortlessly through semantic context and pixel-perfect appearance changes.
qwen-image-edit-fast — Qwen-Image-Edit enables precise bilingual image editing for seamless localization and professional content cr…
qwen-image-edit-plus — Multi-image editing with precise text-guided transformations.
qwen-image-edit-plus-add-people — Generate realistic multi-character scenes with natural interactions.
qwen-image-edit-plus-blend-it — Product placement into backgrounds with precise lighting match.
qwen-image-edit-plus-eigen-banana — Precise text-guided image transformation and creative editing.
qwen-image-edit-plus-eraser — Remove unwanted objects while preserving realistic backgrounds.
qwen-image-edit-plus-face-to-portrait — Cropped face into full identity-preserving portrait photo.
qwen-image-edit-plus-group-photo — Merge individual portraits into realistic group photos.
qwen-image-edit-plus-multi-lora — Multi-image editing with superior identity and style control.
qwen-image-edit-plus-multiple-angle — Transform image perspective with natural language prompts.
qwen-image-edit-plus-next-scene — Create cinematic sequences with seamless visual continuity.
qwen-image-edit-plus-product-photography — Transform white-background products into immersive lifestyle scenes.
qwen-image-edit-plus-relight — Advanced image relighting using natural language prompts.
qwen-image-edit-plus-remove-lighting — Remove artificial lighting effects and restore natural tones.
qwen-image-edit-plus-texture-apply — Apply precise textures to images using natural language.
qwen-image-edit-plus-texture-extract — Extract seamless, tileable textures from photographs.
runway-gen4-image — Runway's Gen-4 Image API enables precise, multimodal image generation for innovative creative and technical a…
sam-img2img — The Segment Anything Model (SAM) produces high quality object masks from input prompts such as points or boxe…
sam-v2-image — SAM v2, the next-gen segmentation model from Meta AI, revolutionizes computer vision. Building on SAM's succe…
sam3-image — Precise object segmentation and tracking in images.
sd1.5-controlnet-canny — This model corresponds to the ControlNet conditioned on Canny edges.
sd1.5-controlnet-depth — This model corresponds to the ControlNet conditioned on Depth estimation.
sd1.5-controlnet-openpose — This model corresponds to the ControlNet conditioned on Human Pose Estimation.
sd1.5-controlnet-scribble — This model corresponds to the ControlNet conditioned on Scribble images.
sd1.5-controlnet-softedge — This model corresponds to the ControlNet conditioned on Soft Edge.
sd1.5-img2img — This model uses diffusion-denoising mechanism as first proposed by SDEdit, Stable Diffusion is used for text-…
sd1.5-outpaint — Stable Diffusion Outpainting can extend any image in any direction
sd2.1-faceswapper — Take a picture/gif and replace the face in it with a face of your choice. You only need one image of the desi…
sd3-med-canny — Stable Diffusion 3 (SD3) Medium Canny ControlNet uses Canny edge detection to provide fine-grained control ov…
sd3-med-pose — Stable Diffusion 3 (SD3) Pose ControlNet is a large generative image model tailored for generating images bas…
sd3-med-tile — SD3 Medium Tile ControlNet is a large generative image model designed for generating detailed images based on…
sdxl-controlnet — SDXL ControlNet gives unprecedented control over text-to-image generation. SDXL ControlNet models Introduces…
sdxl-img2img — SDXL Img2Img is used for text-guided image-to-image translation. This model uses the weights from Stable Diff…
sdxl-openpose — This model leverages SDXL to generate the images with ControlNet conditioned on Human Pose Estimation.
seedream-4 — Seedream 4.0 generates high-resolution, professional-grade visuals with superior text rendering for impactful…
seedream-4.5 — Photorealistic image generation with precise text understanding.
seedream-5-pro-layer-decomposition — Split any image into editable transparent PNG layers.
seedream-v5-lite-image-to-image — Transform images intelligently with detailed text prompts.
seg-swap — Swap Objects Instantly. The Segmind SegSwap v0.1 model enables dynamic and precise image editing by allowing…
segfit-v1.1 — Segmind's Fashion and Immersive Try-on model. SegFIT offers effortless AI virtual try-on from just a product…
segfit-v1.2 — SegFit v1.2 creates hyper-realistic virtual try-on images, transforming fashion retail engagement and convers…
segfit-v1.3 — SegFit v1.3 enables hyper-realistic virtual try-ons, enhancing online fashion retail experiences without phys…
segmind-relighting — Prompts to auto-magically relight your images.
segmind-relighting-v2 — Transform images with customizable, photorealistic lighting for unparalleled visual creativity and authentici…
segmind-scenecraft-v01 — SceneCraft transforms plain or existing product images into visually rich, photorealistic scenes. Whether sta…
skin-contrast-upscaler — Enhances skin detail in images while preserving background quality for professional photography and art.
smart-banner-resizer — Recompose one image into multiple ad and banner sizes.
ssd-depth — This model leverages SSD-1B to generate the images with ControlNet conditioned on Depth Estimation
ssd-img2img — This model uses SSD-1B to generate images by passing a text prompt and an initial image to condition the gene…
storydiffusion — Story Diffusion turns your written narratives into stunning image sequences.
style-transfer — Style & Composition Transfer with Stable Diffusion IP Adapter
superimpose — Superimpose model lets you to create captivating visuals by seamlessly overlaying one image on top of another…
superimpose-v2 — Superimpose V2 elevates image editing! Seamlessly layer images with background removal, precise positioning,…
supir — SUPIR restores and enhances images to stunning, photo-realistic quality with advanced AI techniques.
text-overlay — Elevate your visuals withText Overlay Model. Easily add customized text to any image, perfect for social medi…
topaz-image-upscale — Topaz Labs image upscale is an industry-leading AI photo upscaler designed to increase the resolution of phot…
transparent-background-maker — Transform your images with Transparent Background Maker. Quickly remove backgrounds using AI technology, supp…
utility-image-mask — Build / refine binary masks from JSON-described shapes (rect/polygon/ellipse). Optional dilate/erode/feather/…
utility-image-transform — Apply an ordered pipeline of resize / crop / rotate / flip in a single call. Replaces the four separate tools.
w2imgsd1.5-img2img — Create beautifully designed words using Segmind’s word to image for your marketing purposes
```
## Image generation [#image-generation]
Model slugs for image generation on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
675ed494b9-thejagstudio-LordSwaminaryan —
9c54110684-frank-chieng-sdxl_lora_architecture_siheyuan —
acn-0effee052a — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
aio-fg-full-fc1d87eafb — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Aladdin5k-701ba0d580 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
alexV2-2a5661e8ef — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
AlexV2-655afc6166 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
alexV2FastFlux-e99e4b5aa1 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
alice-in-wonderland-ab7255451b — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ANIME-GEN-V4-9dae59678b — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
anlora-e8d79af2af — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ap-fc0862b464 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
arlora-9ceba116a8 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
armp-13752d05df — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
artificialguybr-ClayAnimationRedmond — Clay Animation Redmond based on SDXL 1.0, excels at creating mesmerizing clay animation images with unparalle…
Asherflex-c25117ed67 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
awf-66afd16a65 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
awmcn-617fbb4446 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
awp-29909cf89b — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Ayalora-5ff7f8f2fd — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
b0445a2335-ostris-watercolor_style_lora_sdxl —
background-eraser — Background Eraser helps in flawless background removal with exceptional accuracy.
baiqiang-8812bdefb9 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Balloonblowing-d8d4c47115 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
bed-and-chair-combined-8dd2e74338 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
bizhen-3683a8e947 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
bria-fibo-generate — Generate photorealistic images with structured JSON prompt control.
bria-text-to-image — Bria 3.2 AI transforms natural language into stunning visuals for diverse creative applications — with Base,…
bria-text-to-vector-graphics — Bria Vision enables high-quality text-to-image and text-to-vector graphic generation for versatile commercial…
c42bf9a66d-joachimsallstrom-aether-bubbles-foam-lora-for-sdxl —
cf-6ccbc88846 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
cfoly-c65493430d — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
chillpixel-blacklight-makeup-sdxl-lora — Blacklight Makeup SDXL LoRA is fine-tuned to generate makeup designs that are not only visually striking but…
chroma — Chroma is an open-source, 8.9B parameter text-to-image model (based on FLUX.1-schnell) designed for diverse a…
cloth-finetune-flux-91b5cc1278 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
crazy-8eae969efe — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ctmn-806488193b — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Delibrate_V2-8dbc3ba5a9 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
dianying-549c4441a6 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Dinaone-ExteriorFloor-c404fe7cc8 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
djwx-635a3531b4 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
dminhk-dog-example-sdxl-lora — Dog Example SDXL LoRA, a specialized AI model within the Stable Diffusion XL framework, uniquely trained to e…
doctor-dolittle-0018c78851 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
dslora-b6e9a6e529 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
dw_bedroom_1_5k-71b62c19fb — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
dw_bedroom_2k-559dc9f020 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
egyptian-d9f4de37d4 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fast-flux-schnell — Fast Flux.1 Schnell by Segmind is an optimized text-to-image model designed for developers needing faster ima…
fb4ab6b705-naphatmanu-sdxl-lora-index-modern-luxury-1 —
felora-94021b7888 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fg_v2-5a5c3da2b3 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fg-individual-15-5b442665e9 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fg15k-4879e3ca32 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fg5kFull-2fffd1e2b0 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fgResize5k-b2981fb7b8 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
flux-1.1-pro — Flux Pro 1.1 is a cutting-edge image generation tool offering exceptional speed, quality, and customization.…
flux-1.1-pro-ultra — Create stunning visuals effortlessly with Flux 1.1 Pro Ultra. Experience unparalleled image quality and speed.
flux-dev — Flux Dev is a 12 billion parameter rectified flow transformer capable of generating images from text descript…
flux-dev-finetuned — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
flux-hanurama-22f3d043c0 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
flux-pixar-27334bad28 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
flux-pro — Flux Pro is a state-of-the-art image generation with top of the line prompt following, visual quality, image…
flux-realism-lora — Flux Realism Lora with upscale, developed by XLabs AI is a cutting-edge model designed to generate realistic…
flux-schnell — Flux Schnell is a state-of-the-art text-to-image generation model engineered for speed and efficiency.
Flux-Turbo-1b4d78be3f — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Flux-Turbo-37e8b8f594 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fluxanimals-05320abd47 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fluxdbb-a972e916ef — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
FluxPixar-30c83df57d — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
FluxTurbo-f28792fc23 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fulora-f3df2e804d — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
fylora-fb68c65109 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Gen-v2-5c9cdcda8e — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Ghibil-27c901962a — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
goofyai-cyborg_style_xl — Cyborg Style SDXL specializes in generating cyborg-themed artwork based on science fiction and futuristic aes…
gpt-image-1 — Create high-quality AI-generated images from text prompts using OpenAI's GPT Image 1 model. Ideal for product…
gpt-image-1-mini — High-quality image generation from text, fast and affordable.
gpt-image-1.5 — Stunning photorealistic images with exceptional instruction-following.
gpt-image-2 — Generate photorealistic images with legible multilingual text and 2K output.
gvrizzo-lora-sdxl-notion-illustration —
haosc-610e769fa8 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ideogram-2a-txt-2-img — Create captivating designs, realistic images & innovative logos with Ideogram 2a text-to-image.
ideogram-3 — Ideogram 3.0 revolutionizes content creation with photorealistic text-to-image generation and diverse aesthet…
ideogram-4 — Generate 2K posters and logos with accurate text rendering.
ideogram-turbo-txt-2-img — Create stunning images in seconds with Ideogram Turbo Text to Image. Fast AI model for quick ideation & text…
ideogram-txt-2-img — Ideogram Text to Image: Turn your ideas into stunning visuals instantly with this powerful AI tool. Create ca…
ideogram-v4-fast — Generate posters and logos with accurate in-image text.
imagen — Imagen 3 is Google DeepMind's highest quality text-to-image model. Generates detailed images with enhanced li…
imagen-4 — Imagen 4 is Google’s most advanced AI image generation model, creating detailed, photorealistic or abstract i…
imagen-4-fast — Fast photorealistic image generation for bulk and iteration.
imagen-4-ultra — Photorealistic images with native 2K resolution and precise text.
jayashri710-sdxl-khuze-nocrop-1e-4-1200 —
jayashri710-sdxl-lora-khuze-1e-4-1200-512x512images —
jdq-396bb5a145 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Jenny1-6546baecae — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
juggernaut-lightning-flux — Juggernaut Lightning Flux: Blazing fast (<300ms!) & powerful inference with enhanced visuals.
juggernaut-pro-flux — Juggernaut Pro FLUX: Create stunningly realistic AI images with unprecedented detail and sharpness.
jzzs-a0fc97d5df — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
jzzsd-ef9fd76525 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
KappaNeuro-punk-collage — Punk Collage Model offers a unique way to create digital collages that resonate with the punk culture's raw e…
kchoi-lora-sdxl-watercolor —
KellyTest-66fbd687a2 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
kling-3-text2image — Photorealistic, print-ready images from text prompts.
liangnv-b2e39c7ec4 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
M-EdenRock-bed-2d45decb6a — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
M-HubbaArmChair-and-M-RicochetFabric-bed-18fed2c922 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
M-HubbaArmChair-fff004d426 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
M-RicochetFabric-bed-9180ccb8f7 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Marimekko-mrk3903-1e8cab847c — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
meizhuang-2ae6bc0009 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
minimaxir-sdxl-ugly-sonic-lora — SDXL Ugly Sonic LoRA excels at generating quirky and iconic version of one of the most beloved movie characte…
minimaxir-sdxl-wrong-lora — SDXL Wrong LoRA is engineered with a focus on delivering images of higher detail, color saturation and vibran…
mnsh-86fb5b8ef4 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
mnzs-b5e1ea1473 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
multi-lora — SDXL Model with multiple LoRa loading support.
nano-banana — Gemini Image Editor preserves authentic subject identity while enabling seamless image editing and manipulati…
Narinder-dfac11ecfb — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
nav_007_Krishna-6fce6aad5b — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
nerijs-lego-minifig-xl — LEGO Minifig XL is designed to generate LEGO images and excels in creating detailed and accurate representati…
Norod78-SDXL-StickerSheet-Lora — SDXL StickerSheet LoRA is expertly fine-tuned on a comprehensive collection of sticker images, enabling it to…
ostris-crayon_style_lora_sdxl — Crayon Style - SDXL LoRA is a unique model designed to convert any text prompt into a vibrant, crayon-style d…
ostris-ikea-instructions-lora-sdxl — Ikea Instructions LoRA SDXL model is fine-tuned on IKEA diagrams and specializes in generating clear, concise…
ostris-stained-glass-style-sdxl — Stained Glass Style SDXL is trained extensively on diverse stained glass images and can replicate the essence…
p-image — p-image generates high-quality images from text prompts in seconds, optimizing for speed and fidelity.
p-image-ideogram — Sub-second text-to-image with legible in-image text.
pixar-3d-5ab56ddd76 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
playzippyIramayanakids-7f162e1446 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
prabhas-5f173e43a4 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
quanshen-7d0d5c4bdb — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
qwen-image — Qwen-Image revolutionizes image generation and editing with seamless multilingual text integration and photor…
qwen-image-2512 — Photorealistic image generation with precise text description following.
qwen-image-3 — Generate and edit legible in-image text, up to 2K.
qwen-image-fast — Qwen-Image expertly generates stunning images with complex text integration, especially for Chinese typograph…
ra100-sdxl-lora-lower-decks-aesthetic — SDXL LoRA Lower Decks Aesthetic model, inspired by the unique style of “Star Trek: Lower Decks.” generates ar…
Rama-558043a138 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ramayanaMulti5k-69c1cc4ae9 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ramsrigouthamg-lora-dog-SSD-1B — LoRA Dog SSD-1B specializes in generating photorealistic images of dogs
recraft-v3 — Recraft V3, the latest iteration of Recraft AI, offers a significant advancement in AI-driven image generatio…
recraft-v3-svg — Recraft V3 SVG generates high-quality, customizable vector graphics with precision and ease. Perfect for logo…
reve-2 — Generate and edit 4K images with sharp in-image text.
rxmx-324bd4c1e2 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
SanaAI-542b8dbe01 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
SBIC-Stone-fbcc5912c5 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
sclora-274da0a25f — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
sd1.5-cyberrealistic — The most versatile photorealistic model that blends various models to achieve the amazing realistic images.
sd1.5-edgeofrealism — This model corresponds to the Stable Diffusion Edge of Realism checkpoint for detailed images at the cost of…
sd1.5-epicrealism — This model corresponds to the Stable Diffusion Epic Realism checkpoint for detailed images at the cost of a s…
sd1.5-juggernaut — The most versatile photorealistic model that blends various models to achieve the amazing realistic images.
sd1.5-realisticvision — This model corresponds to the Stable Diffusion Realistic Vision checkpoint for detailed images at the cost of…
sd1.5-reliberate — This model corresponds to the Stable Diffusion Reliberate checkpoint for detailed images at the cost of a sup…
sdxl1.0-colossus-lightning — Colossus Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024…
sdxl1.0-dreamshaper — The SDXL model is the official upgrade to the v1.5 model. The model is released as open-source software.
sdxl1.0-dreamshaper-lightning — DreamShaper Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1…
sdxl1.0-dyanvis-lightning — Dynavis Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024p…
sdxl1.0-juggernaut-lightning — Juggernaut Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 10…
sdxl1.0-newreality-lightning — NewReality Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 10…
sdxl1.0-nightvis-lightning — NightVis Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024…
sdxl1.0-protovis-lightning — ProtoVision Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1…
sdxl1.0-realdream-lightning — RealDream is a sophisticated image generation model utilizing SDXL Lightning architecture. It creates incredi…
sdxl1.0-realdream-pony-v9 — Real Dream Pony V9 is an advanced image generation model based on the Stable Diffusion XL (SDXL) architecture…
sdxl1.0-realism-lightning — Realism Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024p…
sdxl1.0-realvis — The SDXL model is the official upgrade to the v1.5 model. The model is released as open-source software.
sdxl1.0-realvis-lightning — Realvis Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024p…
sdxl1.0-samaritan-3d — Samaritan 3D XL leverages the robust capabilities of the SDXL framework, ensuring high-quality, detailed 3D c…
sdxl1.0-samaritan-lightning — Samaritan Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 102…
sdxl1.0-timeless — The SDXL model is the official upgrade to the v1.5 model. The model is released as open-source software.
sdxl1.0-txt2img — The SDXL model is the official upgrade to the v1.5 model. The model is released as open-source software
sdxl1.0-wildcard-lightning — WildCard Lightning SDXL is a lightning-fast text-to-image generation model. It can generate high-quality 1024…
sdxl1.0-zavychroma — The SDXL model is the official upgrade to the v1.5 model. The model is released as open-source software.
seedream-5-pro — Region-precise image editing with native multilingual text.
seedream-v5-lite-text-to-image — Fast, affordable instruction-following image generation.
segmind-vega — The Segmind-Vega Model is a distilled version of the Stable Diffusion XL (SDXL), offering a remarkable 70% re…
segmind-vega-rt-v1 — Segmind-VegaRT a distilled consistency adapter for Segmind-Vega that allows to reduce the number of inference…
Selfie-Aesthetic-f9c0f409c5 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Selfie-Aesthetic1-9e21b5a57f — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
sf-31e1b1ee3c — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
sheb-b899ceaa9f — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
sheb-b9150b5b83 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Shravya_ai-f44dd1e647 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Simple_Vector_Flux — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
siria-e3fb0ee32f — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
Sita-b382eb5c53 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
softpasty-flux-dev-a4edbd379c — Flux Schnell is a state-of-the-art text-to-image generation model engineered for speed and efficiency.
SpeedyMary-b361f2fd1d — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
ssd-1b — SSD-1B efficiently generates high-quality, diverse images from text prompts in real-time.
stable-diffusion-3-medium-txt2img — Stable Diffusion is a type of latent diffusion model that can generate images from text. It was created by a…
stable-diffusion-3.5-large-txt2img — Stable Diffusion 3.5 Large offers exceptional customizability, efficient performance on consumer hardware, an…
stable-diffusion-3.5-turbo-txt2img — Stable Diffusion 3.5 Turbo offers exceptional customizability, efficient performance on consumer hardware, an…
Test 001 -4b5d788e6c — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
thumbnail-bc5f00ef3c — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
tianmei-e09a3dfa92 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
v6lora-1745486a5e — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
veo-dd69bf026e — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
wan2.7-image — 2K image generation with precise multilingual text rendering.
wan2.7-image-pro — 4K images with chain-of-thought reasoning and multilingual text.
whnm-339c18f951 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
winnie-the-pooh-c3ccfd99b1 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
wxns-9cf0075aee — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
xse-1f865b3596 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
xz-c445d830b2 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
yujia-0d97d92ca5 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
yunxi-aac5d8354b — Flux Schnell is a state-of-the-art text-to-image generation model engineered for speed and efficiency.
z-image-turbo — Photorealistic images in under one second, bilingual text.
zh-66dcb61456 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
zscj-7c64578707 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
zsjz-7ca8eff909 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
zsnh-7634404088 — Flux is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions
```
## Image t o image [#image-t-o-image]
Model slugs for image t o image on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
sd3-med-img2img — Stable Diffusion 3 Medium image-to-image is a cutting-edge AI tool that uses advanced image-to-image technolo…
```
## Image to data [#image-to-data]
Model slugs for image to data on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
utility-image-metadata — Read image metadata: dimensions, format, EXIF (with GPS decoded to decimal), ICC profile name, raw XMP. Retur…
```
## Image to video [#image-to-video]
Model slugs for image to video on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
ai-face-swap — AI Face Swap: Effortlessly replace faces online. Fine-tune swaps with advanced controls for age, gender, and…
cog-video-5b-i2v — CogVideoX image-to-video is a cutting-edge AI model that converts static images into dynamic, high-quality vi…
flux-3-image-to-video — Animate images into 20-second clips with synchronized native audio.
grok-imagine-video-1.5-image-to-video — Animate a still image into 1080p video with synced audio.
grok-imagine-video-1.5-preview — Image-to-video with native synchronized audio, up to 720p.
grok-imagine-video-1.5-reference-to-video — Character-consistent video from up to 7 reference images.
hailuo-02-fast — Transform any static image into a captivating, high-quality video clip effortlessly.
hailuo-2.3 — Hyper-realistic videos from text with fluid character motion.
hailuo-2.3-fast — Professional-quality videos from text and images at speed.
hallo — Hallo lets you create portrait videos from single images.
happyhorse — Cinematic 1080p text-to-video with native audio and lip-sync.
happyhorse-1.1 — Generate cinematic video with synchronized native audio and multilingual lip-sync from text, an image, or ref…
heygen-avatar-iv — Single photo into a lifelike talking avatar video.
higgsfield-image2video — Transform static images into dynamic, motion-rich videos with unparalleled control and creative depth.
higgsfield-speech2video — Transform images and audio into dynamic, lip-synced videos for engaging digital content.
infinite-talk — Full-body animation from images synchronized perfectly to audio.
kling-1.6-image2video — Kling AI 1.6 Image-to-Video is a powerful AI tool that transforms static images into captivating, animated vi…
kling-2 — Kling 2.0 is an advanced AI video generator (5 and 10 seconds) that creates cinematic, dynamic videos from te…
kling-2.1 — Kling 2.1 offers hyper-realistic video generation with improved motion, sharper 1080p visuals, and instant re…
kling-2.5-turbo — Kling AI 2.5 Turbo generates fluid, cinematic videos from text and images, enhancing content creation and sto…
kling-2.6 — Still images into immersive cinematic videos with synchronized audio.
kling-3-pro-image2video — Animated 1080p videos from images with dynamic motion.
kling-3-standard-image2video — Controlled cinematic 1080p videos from starting images.
kling-bloombloom — Kling AI transforms text and images into dynamic, high-quality video content with realistic motion and sound.
kling-dizzydizzy — Kling DizzyDizzy transforms static content into dynamic, high-resolution videos, enhancing engagement and sto…
kling-expansion — Unleash dynamic visuals with Kling Expansion! Effortlessly inflate and stretch elements for surreal and capti…
kling-fuzzyfuzzy — Transform your photos instantly into adorable, plush-toy-like visuals with Kling fuzzyfuzzy effect.
kling-heart-gesture — Express affection visually with Kling AI's heart gesture effect! Input two portraits and instantly create hea…
kling-hug — Create heartwarming videos instantly with Kling hug effect! Generate tender embracing animations.
kling-image2video — Kling AI Image-to-Video is a powerful AI tool that transforms static images into captivating, animated videos…
kling-kiss — Create a heartfelt video in seconds with Kling kiss effect! Input two portraits and instantly generate a kiss…
kling-o1-image-to-video — Physics-driven animations from images for creative storytelling.
kling-o1-reference-image-to-video — Identity-preserving videos from static images with character reference.
kling-o3-image2video — Images to cinematic videos with precise motion control.
kling-squish — Transform your visuals with Kling AI squish effect! Easily compress and distort images/videos for playful, ex…
kling-v1-pro-ai-avatar — Dynamic AI avatars with synchronized speech from image.
kling-v1-standard-ai-avatar — Lifelike AI avatars with precise lip-sync for presentations.
kling-v2-pro-avatar — Talking avatar videos from image and audio, high quality.
kling-v2-standard-avatar — Lifelike video avatars with precise lip synchronization.
live-portrait — Live Portrait animates static images using a reference driving video through implicit key point based framewo…
live-portrait-video-to-video — Experience the magic of Live Portrait’s Video-to-Video Model! Transform your static images into dynamic video…
ltx-2-fast — Fast, high-quality text-to-video generation by Lightricks.
ltx-2-pro — High-quality video generation with advanced motion control.
ltx-2.5-fast — Text-to-video and image-to-video with native audio, up to 4K.
ltx-2.5-pro — Generate 1080p video with native audio and multi-shot scenes.
ltx-video — LTX-Video is the first DiT-based video generation model capable of generating high-quality videos in real-tim…
luma-ray-3-2 — Cinematic text-to-video and image-to-video clips up to 1080p.
minimax-ai — With Video-01 by MiniMax, create high-definition videos at 720p resolution and 25fps, featuring cinematic cam…
minimax-h3-image-to-video — Animate a still image into 2K video up to 15s.
minimax-h3-reference-to-video — Keep characters and products consistent in 2K reference-to-video.
minimax-hailuo-2 — Generate breathtaking 1080P cinematic videos from text or images with ultra-realistic motion and physics.
modify-video — Transform videos seamlessly with high-fidelity generative edits while preserving original actor performances.
motionctrl-svd — Motion Control SVD is an innovative deep learning framework that breathes life into static images. By intelli…
muscle-surge — Instantly add muscle and strength to your videos with Pixverse Muscle Surge effect!
p-video-animate — Transfer video motion and audio onto any still image.
p-video-avatar — Animate any portrait into a lip-synced talking avatar.
p-video-replace — Swap on-screen video characters while preserving motion and audio.
pixverse-4.5-effects — PixVerse 4.5 transforms photos and text into stunning animated videos for impactful storytelling and marketin…
pixverse-4.5-video — Pixverse 4.5 transforms static images and text into dynamic, engaging videos for captivating social media con…
pixverse-5-extend — Seamlessly extend and continue AI-generated videos.
pixverse-5-transition — Seamless AI-generated video transitions between scenes.
pixverse-5-video — Cinematic videos from text and images with photorealism.
pixverse-image2video — Animate your photos effortlessly with Pixverse Image to Video AI! Upload, add motion prompts and styles.
pixverse-mimic — Transfer motion from reference videos onto still images.
pixverse-v6 — 15-second AI videos with native audio and cinematic controls.
ray-flash-2-720p — Generate stunning 720p videos from text with the Luma ray-flash-2-720p model. Faster & cheaper than Ray 2, of…
runway-gen3-alphaturbo — Runway Gen-3 AlphaTurbo is a cutting-edge AI tool that transforms static images into dynamic videos with exce…
runway-gen4-turbo — Generate videos faster and cheaper with Runway Gen-4 Turbo! Create high-quality text, image, and combined vid…
sadtalker — Audio-based Lip Synchronization for Talking Head Video
scail — Professional character animations from reference images.
seedance-1.0-pro-fast — Cinematic videos from text and images at ultra speed.
seedance-1.5-pro — Synchronized video and audio generation for dynamic storytelling.
seedance-2.0 — Cinematic AI videos with native audio and multi-shot narratives.
seedance-2.0-fast — Professional-grade video creation model with native audio, similar to SeeDance 2.0 but faster and cheaper.
seedance-2.0-mini — Fast text-to-video and image-to-video with synchronized audio.
seedance-2.5 — Generate cinematic multi-shot AI videos up to 30 seconds with synchronized native audio from text, images, or…
seedance-pro — Seedance Pro transforms text and images into engaging 720p dynamic videos with cinematic storytelling.
sora-2 — Stunning dynamic videos from detailed text descriptions.
sora-2-pro — Cinematic-quality videos from text with temporal consistency.
svd — Takes image as input and returns a video.
tooncrafter — Create videos from illustrated input images
v-express — V-Express lets you create portrait videos from single images.
veed-fabric-1.0 — Animate any image into a realistic talking video, lip-synced to your audio or generated from a text script.
veo-2-image2video — Discover Google Veo 2, an AI-powered image-to-video model with 4K resolution, realistic motion, and cinematic…
veo-3.1 — Static images into high-quality videos with synchronized audio.
veo-3.1-fast — Transforms static images into dynamic 1080p videos with synchronized audio and natural motion.
video-effects — Transform your videos with diverse video effects. Start creating captivating videos today.
video-faceswap-by-facefusion-labs — Realistic face swapping in videos from a single image.
video-frame-interpolation — FILM synthesizes smooth, high-quality intermediate frames for fluid motion in videos with significant movemen…
video-stitch — Revolutionize your video editing with the Video Stitch Model. Seamlessly stitch clips, add captivating audio,…
video-tryon — Video Tryon is Segmind’s next-generation AI video model for instant virtual try-on, allowing users to visuali…
video-tryon-v2 — Video Tryon is Segmind’s next-generation AI video model for instant virtual try-on, allowing users to visuali…
video-watermark-remover — Remove watermarks from any video instantly with AI.
videofaceswap — Video Faceswap is a powerful tool for creators, filmmakers, and meme enthusiasts. With this innovative techno…
wan-2.2-i2v-fast — Transforms simple text prompts into breathtaking cinematic-quality videos in minutes.
wan-2.2-i2v-flash — Convert a single image into a coherent dynamic video.
wan-2.5-i2v — Wan2.5-Preview creates stunning, high-resolution videos with flawless audio synchronization from multiple inp…
wan-2.6-i2v — Transform images into high-quality videos with audio sync.
wan-animate — Animate characters and replace video subjects seamlessly.
wan2.1-i2v-720p — Create high-quality 720p videos with excellent visual quality and a broad spectrum of motion from static imag…
wan2.6-i2v-flash — Animate photos into 15-second 1080p video with native audio.
wan2.7-i2v — Animate any image into cinematic 1080P video with audio.
wan2.7-r2v — Character-consistent multi-subject videos from reference images.
wan3.0-video — Generate 30-second 1080p video with native audio.
warmth-of-jesus — Experience the viral "Warmth of Jesus" effect on PixVerse! Transform your images into heartwarming videos of…
```
## Image to3d [#image-to3d]
Model slugs for image to3d on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
hunyuan-3d-2 — Hunyuan3D 2.0 enables the creation of high-quality 3D models with intricate details. Produce assets that are…
hunyuan3d-2.1 — Transform 2D images into photorealistic, high-fidelity 3D assets effortlessly.
hunyuan3d-2mv — Hunyuan3D-2mv is finetuned from Hunyuan3D-2 to support multiview controlled shape generation.
sam-3d-body — Reconstruct 3D human body meshes from a single photo.
sam-3d-objects — Single 2D image into detailed 3D object models.
```
## Image understanding [#image-understanding]
Model slugs for image understanding on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
bria-fibo-generate-structured-prompt — Convert complex inputs into structured JSON prompts for generation.
bria-mask-generator — Bria AI Get Masks automatically generates accurate object masks for advanced image editing and enhancement.
bria-prompt-enhancer — Bria AI generates high-quality, commercially safe images tailored to diverse creative needs.
google-translate — Translate effortlessly with the powerful Google Translation AI model.
ideogram-describe — Ideogram describe can effortlessly generate detailed prompts from images. Perfect for refining creations or r…
image-converter — Convert images between formats instantly.
image-resizer — Resize images to any dimension quickly and precisely.
llava-v1.6 — LLaVa translates images into text descriptions & captions.
nsfw-checker — Detect NSFW and other inappropriate content in images. Returns a boolean has_nsfw_concepts flag, an overall N…
sam-v21-hiera-large — Meta's next-gen segmentation model for images and video.
video-speed-change — Speed up or slow down any video precisely.
```
## Inpainting [#inpainting]
Model slugs for inpainting on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
focus-inpaint — Fooocus Inpainting is a powerful image generation model that allows you to selectively edit and enhance image…
inpaint-auto — This model is capable of generating photo-realistic images given any text input, with the extra capability of…
sd1.5-inpainting — Stable Diffusion Inpainting is a latent text-to-image diffusion model capable of generating photo-realistic i…
sdxl-inpaint — This model is capable of generating photo-realistic images given any text input, with the extra capability of…
try-on-diffusion — Outfitting Fusion based Latent Diffusion for Controllable Virtual Try-on
```
## Language models (LLMs) [#language-models-llms]
Model slugs for language models (llms) on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
claude-4-sonnet — Advanced coding and multi-step agentic reasoning model.
claude-4.5-sonnet — Claude Sonnet 4.5 empowers developers with advanced coding and reasoning for complex software solutions.
claude-opus-4.7 — Anthropic's most capable AI model excelling at agentic coding, complex reasoning, and high-resolution vision…
deepseek-chat — DeepSeek V3 combines cutting-edge AI technology with practical usability. Featuring a 671B parameter architec…
deepseek-reasoner — DeepSeek-R1 is a cutting-edge AI reasoning model that combines reinforcement learning with supervised fine-tu…
gemini-2.5-flash — Multimodal AI with transparent reasoning, fast and affordable.
gemini-2.5-flash-lite — Fastest Gemini 2.5 model for high-volume text and vision tasks.
gemini-2.5-pro — Complex multimodal reasoning across diverse inputs and formats.
gemini-3-flash — Frontier-class reasoning and multimodal AI at scale.
gemini-3-pro — Autonomous multimodal AI for complex reasoning and coding.
gemini-3.1-flash-lite — Ultra-fast, affordable LLM for high-volume AI pipelines.
gemini-3.1-pro — Frontier reasoning across text, images, video, and code.
gemini-3.7-flash — Fast multimodal LLM for coding, agents, and long-document analysis.
glm-5.2 — 1M-token open-weight LLM for long-horizon coding.
gpt-4 — GPT-4 outperforms both previous large language models and as of 2023, most state-of-the-art systems (which of…
gpt-4-turbo — GPT-4 outperforms both previous large language models and as of 2023, most state-of-the-art systems (which of…
gpt-4o — GPT-4o (“o” for “omni”) is our most advanced model. It is multimodal (accepting text or image inputs and outp…
gpt-5 — GPT-5 automates complex coding tasks with integrated tools for seamless software development and deployment.
gpt-5-mini — Rapid high-quality AI across text, images, and files.
gpt-5-nano — Ultra-fast LLM responses for real-time AI applications.
gpt-5.1 — Precise code review and developer workflow assistant.
gpt-5.2 — Advanced reasoning with multimodal input for precise tasks.
gpt-5.4 — Most powerful GPT for frontier reasoning and multimodal tasks.
gpt-5.4-mini — Fastest efficient model for coding and computer-use tasks.
gpt-5.4-nano — Flagship-class AI for classification and extraction tasks.
gpt-5.5 — Frontier reasoning and coding with 1M-token context window.
kimi-k2-instruct-0905 — Deep contextual understanding and complex code generation.
llama-v3-8b-instruct — Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrain…
llama-v3p1-70b-instruct — Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrain…
llama-v3p1-8b-instruct — Meta developed and released the Meta Llama 3 family of large language models (LLMs), a collection of pretrain…
llama4-maverick-instruct-basic — Llama 4 Maverick Instruct Basic is a 400B parameter powerhouse with 128 experts for unparalleled text and ima…
llama4-scout-instruct-basic — Unlock powerful multimodal AI with Llama 4 Scout basic, a 17 billion active parameters model offering leading…
minimax-m3 — Reason over 1M-token context for coding and agents.
mixtral-8x22b-instruct — Mistral MoE 8x22B Instruct v0.1 model with Sparse Mixture of Experts. Fine tuned for instruction following.
nemotron-3-ultra — 1M-token reasoning for coding agents and deep research.
o3 — Frontier reasoning model for complex coding, math, and science.
o3-mini — Cost-efficient reasoning model for coding, math, and science.
o4-mini — OpenAI o4-mini enhances decision-making by processing text and images with advanced reasoning capabilities.
qvq-max — Chain-of-thought visual reasoning for math, charts, and diagrams.
qwen-3.8-max — Multimodal reasoning and agentic coding with 1M-token context.
qwen-flash — Fastest low-cost LLM with 1M context for high-volume tasks.
qwen-plus — Mid-tier 1M context LLM for summarization and content tasks.
qwen2-vl-72b-instruct — Qwen2-VL-72B-Instruct is a state-of-the-art multimodal model excelling in image and video understanding, with…
qwen3-coder-flash — High-volume code generation with 1M token context window.
qwen3-coder-plus — Generates, debugs, and refactors entire codebases efficiently.
qwen3-max — 1T-parameter LLM with hybrid reasoning and 262K context.
qwen3-vl-flash — Fast, affordable vision-language model with 262K context OCR.
qwen3-vl-plus — Powerful visual QA and document analysis from images.
qwen3.5-flash — Fast multimodal AI processing text, images, and video affordably.
qwen3.5-plus — Multimodal 1M context AI for image, video, and text.
qwq-plus — Deep chain-of-thought reasoning for math, code, and logic.
```
## Text to embed [#text-to-embed]
Model slugs for text to embed on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
gemini-embedding-001 — MTEB #1 text embeddings for RAG, search, and clustering.
gemini-embedding-2 — Natively multimodal embeddings — text, image, audio, video and PDF mapped into one vector space, with 8 task-…
text-embedding-3-large — Text-embedding-3-large is a robust language model by OpenAI designed for generating high-dimensional text emb…
text-embedding-3-small — Text-embedding-3-small is a compact and efficient model developed for generating high-quality text embeddings…
```
## Transcription [#transcription]
Model slugs for transcription on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
eleven-labs-transcript — Transcribe audio to accurate text in 99 languages with speaker diarization and word-level timestamps.
elevenlabs-dialogue-with-timestamps — Multi-speaker dialogue with expressive timestamps included.
elevenlabs-forced-alignment — Precise audio-text synchronization with word-level timestamps.
elevenlabs-voice-clone — Hyper-realistic voice cloning from short audio samples.
elevenlabs-voice-design — Generate unique synthetic voices without audio samples.
tts-elevenlabs-with-timestamps — Emotionally expressive TTS with word-level timestamp output.
whisper-large-v3 — Transcribe speech-to-text in 99 languages with timestamps.
```
## Video editing [#video-editing]
Model slugs for video editing on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
bria-erase-video — Remove unwanted objects from videos while preserving audio.
bria-increase-video-resolution — Transform your videos with AI-powered upscaling and seamless background removal for professional quality.
bria-video-background-removal-3.0 — Remove video backgrounds with flicker-free, transparent alpha output.
esrgan-video-upscaler — ESRGAN Video Upscaler: Experience sharper, clearer 4k videos with ESRGAN. This AI-powered video upscaler boos…
flux-3-draft-enhance — Upscale AI video drafts to Full-HD with native audio.
flux-3-extend-video — Extend clips into seamless video continuations with synchronized audio.
gemini-omni-1.1-video-edit — Edit videos with a text prompt, subject preserved.
gemini-omni-1.1-video-extend — Extend short video clips into longer seamless scenes.
heygen-video-translate — Translate videos to multiple languages with natural lip-sync.
kling-2.6-pro-motion-control — Transfer motion from videos to animate custom characters.
kling-2.6-standard-motion-control — Precise motion transfer from reference videos to characters.
kling-o1-video-to-video-edit — Edit any video with precise natural language commands.
kling-o1-video-to-video-reference — Video style transfer using reference character images.
kling-o3-video2video-edit — Text-based video editor — swap backgrounds, characters, restyle scenes.
kling-o3-video2video-reference — Swap characters and restyle videos using reference images.
ltx-retake-video — Precise segment-level video edits maintaining full scene continuity.
multi-video-merge — Merge multiple videos into a single combined output.
opus-clips-from-video — Turn long videos into captioned vertical shorts.
p-video-edit — Edit video from a text prompt, keep original motion.
pixverse-lipsync — PixVerse Lipsync expertly synchronizes lip movements to audio for flawless video content creation.
runway-gen4-aleph — Runway Aleph revolutionizes video editing with intelligent automation for seamless object and environment man…
sam-v2-video — SAM v2 Video by Meta AI, allows promptable segmentation of objects in videos.
sam3-video — Real-time video segmentation and multi-object tracking.
sonilo-video-to-video — Add frame-synced AI music and sound effects to video.
sync.so-lipsync-2-pro — Lipsync-2-Pro seamlessly synchronizes lips in videos for instant, high-quality multilingual content creation.
sync.so-react-1 — Edit video actors' emotions with realistic re-expression.
topaz-video-upscale — Topaz Video AI upscales, enhances, denoises, stabilizes, and increases frame rates in video footage, transfor…
veed-2-lipsync — Dub talking-head videos with emotion-matched lip-sync.
veed-lipsync — Re-syncs the lips of any talking-head video to a new speech audio track for realistic dubbing and localizatio…
veed-subtitles — Automatically transcribes and burns styled, translated subtitles into any video with 30 presets and a single…
veed-video-background-removal — Remove any video's background with no green screen, or cleanly key chroma footage, using AI matting.
video-audio-merge — Effortlessly merge audio and video with our intuitive Video Audio Merge model. Create stunning multimedia con…
video-captioner — With Video Captioner create accurate, customizable subtitles for your videos effortlessly.
video-concatenate — Merge videos with custom layouts, spacing, and audio.
video-editor-agent — General-purpose AI media agent: describe the transformation in natural language and it runs ffmpeg in a sandb…
video-loop — Effortlessly loop videos for engaging social media & storytelling with our Video Loop.
video-slicer — Video Slicer
video-split — Utility node: Video Split. 1->N split; returns videos[] array
wan2.7-videoedit — Edit existing videos precisely using natural language text instructions.
```
## Video generation [#video-generation]
Model slugs for video generation on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
cog-video-5b-t2v — CogVideo is a groundbreaking AI model that turns text into high-quality videos. Create realistic scenes, anim…
flux-3-text-to-video — Cinematic text-to-video with native lip-synced audio, up to 20s.
gemini-omni-1.1 — Text-to-video with synchronized native audio, up to 4K.
gemini-omni-flash — Text-to-video and image-to-video with synchronized native audio.
grok-imagine-video — Text-to-video and image-to-video with native synchronized audio.
grok-imagine-video-1.5-text-to-video — Text-to-video clips up to 1080p with native synchronized audio.
heygen-avatar-v — Studio-quality talking-avatar videos from text or audio.
kling-1.6-text2video — Kling AI 1.6 Text-to-Video is a cutting-edge AI tool that transforms text into stunning, lifelike videos. Cre…
kling-3-pro-text2video — Cinematic 1080p videos with realistic audio from text.
kling-3-standard-text2video — Stunning 1080p cinematic videos from simple text prompts.
kling-o3-text2video — 15-second cinematic AI videos with native audio.
kling-text2video — Kling AI Text-to-Video is a cutting-edge AI tool that transforms text into stunning, lifelike videos. Create…
ltx-2-19b-i2v — Synchronized 4K audio-video generation from images, fast.
ltx-2-19b-t2v — Synchronized video and audio from text, multiple input types.
minimax-ai-director — Minimax video-01-director: Create high-quality videos with control camera movements precisely using text prom…
minimax-h3-text-to-video — Text-to-video: cinematic 2K clips with native audio.
pixverse-text2video — Effortlessly create captivating videos from text with Pixverse text to video AI! Customize style, duration, a…
timeline — Utility node: Timeline. declarative multi-track video compositor
veed-avatars — Generate UGC-style talking avatar videos from text or audio using 28 stock presenters with realistic lip-sync.
veo-2 — Create stunning, realistic videos with Veo 2, Google's state-of-the-art AI video generation model. Experience…
veo-3 — Veo 3 revolutionizes video creation with advanced text-to-video generation and realistic audio synthesis for…
veo-3-fast — Veo 3 Fast rapidly creates high-quality, 8-second videos with synchronized audio for diverse content needs.
wan-2.2-t2v-fast — Wan2.2 transforms text and images into high-quality video clips with cinematic flair.
wan-2.5-t2v — Wan2.5-Preview generates synchronized multimedia content, merging text, image, video, and audio seamlessly.
wan2.1-t2v — Create visually impressive and feature varied, lifelike motion videos with Wan2.1 using text prompts.
wan2.7-t2v — 1080P cinematic videos with audio sync and multi-shot control.
```
## Video to audio [#video-to-audio]
Model slugs for video to audio on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
sonilo-video-to-audio — Generate video-synced music and sound effects from footage.
```
## Video to image [#video-to-image]
Model slugs for video to image on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
start-end-frame-extractor — Extract first and last frames from any video.
```
## Video to text [#video-to-text]
Model slugs for video to text on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
heygen-avatar-v-create — Train a Digital Twin avatar from reference video.
```
## Voice [#voice]
Model slugs for voice on the Segmind API — pass one to `https://api.segmind.com/v1/` or `segmind.run("", ...)`:
```text
kling-create-voice — Clone any voice from a single audio sample.
```
# Model Status (https://docs.segmind.com/docs/serverless-api/model-status)
Why a Segmind model responds slowly on its first call: how cold boots and warm boots work, and what each means for request latency.
Model status can be cold and warm refer to how long it takes to launch a machine learning model to accept requests.
* **Cold Boot:** When a model hasn't been used in a while, it gets turned off to conserve resources. This is similar to completely turning off your computer. When you make a request to use the model again, it needs to be fully loaded and started up, which can take several minutes for large models. This is a cold boot.
* **Warm Boot:** If a model has been used recently, it stays loaded and ready to accept requests. This is similar to putting your computer in sleep mode. When you use a warm model, the response is much faster because the model is already up and running.
Here's why this happens:
* Segmind has a large library of models, and keeping them all running all the time would use a lot of resources.
* Only the models actually being used are kept running.
* Cold boots happen more often for less frequently used models.
Segmind only charges you for the time the model is actually processing your request, not the boot time. So, cold boots don't affect your costs.
## Seeing it in your own traffic [#seeing-it-in-your-own-traffic]
Cold boots are visible in [API Health](/docs/serverless-api/monitoring#api-health):
a **p50 in seconds beside a p95 in minutes** is the usual signature — most calls
hitting a warm model, a few paying for a boot. The **By model** table there
breaks latency down per model, so you can tell an occasional cold start apart
from a model that is consistently slow.
# Monitoring (https://docs.segmind.com/docs/serverless-api/monitoring)
Track Segmind API usage from the console: Generations for individual requests, Cost Analytics for spend, and API Health for latency percentiles, success rate and error breakdown.
Three pages in the console cover usage, and they answer different questions:
| Page | Answers |
| ------------------ | ------------------------------------------------------------------------------------------------ |
| **Generations** | *What did I run?* — one row per request, with status, duration, cost and a preview of the output |
| **Cost Analytics** | *What did it cost?* — spend over time, broken down by model, source, API key and team member |
| **API Health** | *Is it working, and how fast?* — success rate, latency percentiles, and what is failing |
All three are under **OBSERVABILITY** in the left nav, and all three are
**scoped to the workspace you are currently in**. Switch workspaces at the
bottom left before reading any of them — a team's usage does not appear in your
Personal account and vice versa. See [Teams](/docs/platform/teams) for how
workspaces work.
They update in near real time. A request shows up in **Generations** within
seconds of finishing, and in the other two within a minute or two — there is no
batch delay to wait out. If a page looks empty, check the workspace and the
date range before assuming the data has not landed yet.
## Generations [#generations]
Every request made from this workspace, newest first.
| Column | Shows |
| -------------- | ----------------------------------------------------------------------------------------- |
| **Model** | the model slug that was called |
| **Time** | when the request was made |
| **Duration** | how long it took end to end |
| **Status** | the HTTP status it returned — see [API error codes](/docs/serverless-api#api-error-codes) |
| **Request ID** | the id the gateway assigned, with a copy button |
| **Cost** | what this single request was charged |
| **Preview** | a thumbnail of the output, or `N/A` for models that do not return an image |
Filter by **model**, **status**, **source** or **date range**, then click
**Apply**. The toggle at the right of the filter bar switches between the list
above and a grid of output previews, which is the faster way to find a
generation you recognise by sight rather than by id.
**Export CSV** downloads the filtered set.
Selecting a row opens the full request beside the list — endpoint, request id,
status, duration, generation time, when it was created, cost and source, with
the prompt and the raw JSON both copyable.
The **Request ID** column is the same id the v2 async endpoints return. If you
are debugging a specific call, copy it here and look it up with
[async inference](/docs/serverless-api/async-inference) rather than scrolling.
Generations does not record **which API key** a request was made with — for
that, use the API key filter and the **Cost by API Key** table in Cost
Analytics.
## Cost Analytics [#cost-analytics]
The same traffic, aggregated for spend.
Three figures sit at the top, all for the **selected period**:
* **Total Cost** — what you spent.
* **Total Requests** — how many calls that was.
* **Projected Month-End** — the current daily average extended to the end of
the month. It is a straight-line estimate, not a commitment.
Below them, **Cost Over Time** charts spend stacked by your top models, with
**Hour / Day / Week / Month** granularity.
### Breakdowns [#breakdowns]
Four tables follow, each with its own **CSV** export:
| Table | Breaks spend down by |
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Cost by Model** | model slug, with request count and cost |
| **Cost by Source** | where the request came from. The **Source** filter names these **API**, **Web** (the playground and model pages) and **Workflows** (PixelFlow runs); the table lists the underlying source ids, which separate v1 and v2 traffic |
| **Cost by API Key** | which key was used, so you can attribute spend to an environment or a service |
| **Cost by Team Member** | per-member spend against the shared team wallet |
**Cost by Source** is the one worth checking first when a bill is surprising —
it separates deliberate API traffic from playground experiments and PixelFlow
runs, which are easy to forget about.
**Cost by Team Member appears only on a team workspace, and only for its owner
and admins.** In a Personal workspace there is nothing to split, and a plain
Member does not see what their colleagues spent. Per-member **limits** are set
on the [team management page](/docs/platform/teams#invite-a-member).
### Filters [#filters]
**Date Range**, **API Key**, **Model** and **Source** apply to every card and
table on the page at once, so narrowing to one model shows that model's chart,
its share of each source, and its month-end projection together. **Reset**
returns to the default range.
The date picker offers **Last 7 days**, **Last 30 days**, and **Week**,
**Month**, **Quarter** and **Year to date**, or a custom range ending today.
The refresh control at the top right re-reads the figures without a full page
reload.
## API Health [#api-health]
Where Generations tells you *what ran* and Cost Analytics *what it cost*, API
Health answers whether your traffic is actually healthy — and it is the page to
open first when something feels slow or flaky.
Five figures sit at the top, each with its change against the previous period
of the same length:
| Card | Shows |
| ------------------ | ------------------------------------------------------- |
| **Total Requests** | how many calls in the period |
| **Failed** | how many failed, and the failure rate |
| **Success Rate** | the inverse, with the succeeded count |
| **p95 Latency** | with **p50** and **p99** underneath |
| **Top Error** | the most common failure, and how many times it happened |
**Read p50 and p95 together.** A p50 in seconds beside a p95 in minutes means
most calls are fine and a few are stuck — usually a cold start or one bad
model, not a general slowdown. See [Model Status](/docs/serverless-api/model-status)
for why the first call to an idle model is slower.
### Breakdowns [#breakdowns-1]
**Requests Over Time** charts volume stacked by your top models, with
**Hour / Day / Week / Month** granularity. Below it:
* **Requests by Model** — with a CSV export.
* **Top errors** — failures grouped into families such as *Polling timeout*,
*Content policy*, *Input validation*, *Upstream 4xx*, *Upstream 5xx* and
*Internal error*. Each shows the message, when it was last seen, and how many
models it affected.
* **By model** — reliability per model: requests, failed, success rate, p95 and
cost. This is how you tell one unreliable model apart from a bad afternoon.
* **By source** — the same split as Cost Analytics, with latency instead of
spend: **API** (direct REST calls from SDKs and integrations), **Web**
(playground and dashboard traffic), **Workflows** (PixelFlow and published
workflow runs), and **Other**.
* **Recent failures** — the 50 most recent failed requests for the current
filters, with model, initiator, latency, error family and request id. **Copy
a request id from here** to look the call up elsewhere.
Filters at the top — **Date Range**, **API Key**, **Model** and **Initiator** —
apply to every card and table at once.
API Health reports **your own traffic**, not a global service status. A failure
here is a failure of your requests — a rejected parameter or a model that timed
out — which is why the error families and the per-model table matter more than
the headline number.
## Related [#related]
* [Billing](/docs/platform/pricing-and-billing) — how credits are reserved and
settled, and what each model costs.
* [API error codes](/docs/serverless-api#api-error-codes) — what each status
code the gateway returns actually means.
# Random Seed (https://docs.segmind.com/docs/serverless-api/random-seed)
Use the seed parameter to control randomness in Segmind model output. Pass -1 for a random seed, or any positive integer for reproducible results.
The seed parameter controls the randomness of model outputs. Here is how it works across the Segmind platform:
## Seed Behavior [#seed-behavior]
| Seed Value | Behavior |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`-1`** | The system picks a seed at random. On v1 it **tells you which one** in the `x-seed-value` response header, so the run can be repeated later; on v2 it does not — see below. |
| **Any positive integer** (e.g., `42`, `12345`) | Deterministic output. Using the same seed with identical parameters will produce the same result. |
| **Omitted / not provided** | Behaviour is model-dependent — most treat it as random. **`x-seed-value` comes back as `None`**, so you are not told what was used and the result cannot be reproduced. |
**Important:** Some model documentation pages may show a default seed value (e.g., `12345`) in the API parameter list. This is a placeholder example, not the actual default used when the parameter is omitted. To guarantee random results every time, explicitly set `seed: -1` in your request.
## Random, but reproducible later [#random-but-reproducible-later]
These two are not the same thing, and the difference only shows up once you
want a result back:
* **Omit the seed** and the response reports no seed at all. The output is
random and **gone** — nothing tells you how to get it again.
* **Send `seed: -1`** and the output is equally random, but the seed that
produced it comes back in `x-seed-value`. Store that alongside the result and
you can reproduce it whenever you like.
Reusing a reported seed with the same prompt and parameters returns the same
image:
```bash
# 1. random run — note the seed the gateway reports
curl -D - -o first.jpg -X POST "https://api.segmind.com/v1/fast-flux-schnell" \
-H "x-api-key: $SEGMIND_API_KEY" -H "Content-Type: application/json" \
-d '{"prompt":"a red apple on a wooden table","steps":4,"seed":-1}' \
| grep -i x-seed-value
# x-seed-value: 42873396
# 2. replay it
curl -o again.jpg -X POST "https://api.segmind.com/v1/fast-flux-schnell" \
-H "x-api-key: $SEGMIND_API_KEY" -H "Content-Type: application/json" \
-d '{"prompt":"a red apple on a wooden table","steps":4,"seed":42873396}'
```
**This round trip only works on v1.** The v2 result payload has a `seed` field,
but it **echoes what you sent** rather than reporting what was used — send
`seed: -1` and it comes back as `"-1"`, which tells you nothing. Only the
`x-seed-value` header on a synchronous response resolves `-1` to the seed the
model actually used.
So if you want a random generation you can reproduce later, either run it on
v1, or choose the seed yourself and send it explicitly.
If you keep generations you might want to revisit — variations on a good
result, a reproducible test set — store the seed with the output. It is the
only thing that makes a generation repeatable, and it costs nothing to record.
## When to Use [#when-to-use]
* **For consistent, reproducible outputs:** Provide a specific seed value (e.g., `seed: 42`). The same prompt + seed + parameters will produce the same output.
* **For varied results each time:** Set `seed: -1` to explicitly request random generation — and keep the reported seed if you might want the output back.
* **For A/B testing or debugging:** Use a fixed seed to isolate the effect of other parameter changes.
This approach works across model APIs, model playground (UI), PixelFlow UI, and PixelFlow APIs.
# Rate Limits (https://docs.segmind.com/docs/serverless-api/rate-limits)
Segmind implements rate limiting to safeguard the integrity and performance of our API.
Rate limiting serves multiple purposes:
* Security: It mitigates the risk of abuse or misuse by preventing malicious users from flooding the API with excessive requests, which could disrupt services.
* Fair Access: Rate limiting ensures equitable access to the API by restricting any single user or application from monopolizing resources, enabling all users to leverage the API effectively.
* Performance Optimization: By managing the overall load on our infrastructure, rate limiting prevents performance degradation due to sudden spikes in API requests, maintaining a smooth and consistent user experience.
At Segmind, we prioritize the security, fairness, and reliability of our API services. Rate limiting is a crucial measure to uphold these core principles and deliver an optimal experience to all our users.
Here are the rate limits depending on your account plan.
| Free | Pro | Enterprise |
| ----- | ------ | ---------- |
| 5 RPM | 50 RPM | Custom |
# Segmind Storage (https://docs.segmind.com/docs/serverless-api/segmind-storage)
Upload files to Segmind Storage and get a reusable URL to pass as an image input to any model, instead of re-uploading the same file.
Segmind Storage allows you to upload files as assets and get URLs that can be used with other models. This is particularly useful when you need to provide image inputs to various AI models without repeatedly uploading the same file.
## Upload Asset API [#upload-asset-api]
Upload files to Segmind Storage and receive a URL that can be used across different models.
### Endpoint [#endpoint]
```
POST https://workflows-api.segmind.com/upload-asset
```
### Headers [#headers]
| Header | Value | Required | Description |
| -------------- | ----------------------------------- | -------- | ----------------------- |
| `accept` | `application/json, text/plain, */*` | Yes | Accepted response types |
| `x-api-key` | `SG_XXX` | Yes | Your Segmind API key |
| `content-type` | `application/json` | Yes | Request content type |
### Request Body [#request-body]
The request body should be a JSON object with the following structure:
```json
{
"data_urls": ["data:image/jpeg;base64,..."]
}
```
| Field | Type | Description |
| ----------- | ---------------- | --------------------------------------------------------- |
| `data_urls` | Array of strings | Array of base64-encoded data URLs for the files to upload |
### Data URL Format [#data-url-format]
Files should be provided as base64-encoded data URLs in the format:
```
data:;base64,
```
Supported formats include:
* Images: `data:image/jpeg;base64,`, `data:image/png;base64,`, `data:image/webp;base64,`
* Other file types as supported by the models you intend to use
### Code Examples [#code-examples]
Upload files to Segmind Storage using your preferred programming language.
```bash
curl 'https://workflows-api.segmind.com/upload-asset' \
-H 'accept: application/json, text/plain, */*' \
-H 'x-api-key: SG_YOUR_API_KEY_HERE' \
-H 'content-type: application/json' \
--data-raw '{"data_urls":["data:image/jpeg;base64,/9j/4AAQSkZJRg..."]}'
```
```python
import requests
import base64
api_key = "SG_YOUR_API_KEY_HERE"
url = "https://workflows-api.segmind.com/upload-asset"
# Read and encode your image file
with open("image.jpg", "rb") as image_file:
encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
data_url = f"data:image/jpeg;base64,{encoded_string}"
data = {
"data_urls": [data_url]
}
headers = {
'x-api-key': api_key,
'accept': 'application/json, text/plain, */*',
'content-type': 'application/json'
}
response = requests.post(url, json=data, headers=headers)
result = response.json()
# Get the uploaded asset URL
asset_url = result['file_urls'][0]
print(f"Asset uploaded successfully: {asset_url}")
```
```javascript
const fs = require('fs');
const api_key = "SG_YOUR_API_KEY_HERE";
const url = "https://workflows-api.segmind.com/upload-asset";
// Read and encode your image file
const imageBuffer = fs.readFileSync('image.jpg');
const base64String = imageBuffer.toString('base64');
const dataUrl = `data:image/jpeg;base64,${base64String}`;
(async () => {
const data = {
data_urls: [dataUrl]
};
const headers = {
'x-api-key': api_key,
'accept': 'application/json, text/plain, */*',
'content-type': 'application/json'
};
const response = await fetch(url, {
method: 'POST',
headers,
body: JSON.stringify(data),
});
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
const result = await response.json();
console.log(`Asset uploaded successfully: ${result.file_urls[0]}`);
})();
```
### Response [#response]
```json
{
"file_urls": [
"https://images.segmind.com/assets/you@example.com/images/fb61f8b1-731e-42fd-988e-675965942a8d.jpg"
],
"message": "Files uploaded successfully"
}
```
| Field | Description |
| ----------- | --------------------------------------------------- |
| `file_urls` | One URL per entry in `data_urls`, in the same order |
| `message` | A human-readable status string |
These URLs can then be used as inputs for various models on the Segmind
platform — pass one wherever a model takes an image URL.
**An asset URL is public, and it identifies your account.** It needs no API key
— anything holding the link can fetch the file — and the path contains the
email address of the account that uploaded it. That is fine for passing to a
model or your own frontend; think twice before putting one somewhere public.
### Use Cases [#use-cases]
1. **Reusable Image Inputs**: Upload an image once and use the URL across multiple model runs
2. **Batch Processing**: Upload multiple images and process them with different models
3. **Workflow Integration**: Use uploaded assets in PixelFlow workflows
4. **Model Chaining**: Pass asset URLs between different models in a pipeline
### Best Practices [#best-practices]
* Store the returned URLs for reuse to avoid uploading the same file multiple times
* Ensure your base64 encoding is correct to prevent upload failures
* Use appropriate MIME types in your data URLs for proper file handling
* Keep your API key secure and never expose it in client-side code
### Limits [#limits]
There is no small file-size cap to design around — uploads well into the tens
of megabytes go through fine.
Two things do bite:
**The request is JSON, so base64 inflates it by about a third.** A 50 MB file
becomes roughly a 67 MB request body. Budget for that in any client timeout.
**The ceiling is total pixel count, not file size and not any single
dimension.** A 5 MB image was rejected while a 53 MB one went through, and a
very wide but short image is unaffected — 16,000 × 800 is only 12.8 megapixels
and uploads without trouble.
Narrowing it by bisection, the limit sits between these two:
| Image | Pixels | Result |
| --------------- | -------- | -------- |
| 13,300 × 13,300 | 176.9 MP | uploads |
| 13,400 × 13,400 | 179.6 MP | rejected |
So anything under roughly 175 megapixels is safe, and there is no practical
reason to send an image that large to a model in the first place.
**An image over that ceiling comes back as a generic validation error**, not a
size error:
```json
{ "error": "No valid files or data URLs provided" }
```
Nothing in that message points at dimensions. If a data URL you are confident
is well formed keeps getting rejected, check the image's pixel count before you
go looking for an encoding bug.
### Rate Limits [#rate-limits]
Asset uploads are subject to the standard Segmind API rate limits. Refer to the [Rate Limits](/docs/serverless-api/rate-limits) documentation for more information.
# Structured Outputs (https://docs.segmind.com/docs/serverless-api/structured-outputs)
Constrain a chat model's reply to JSON — or to a JSON Schema you supply — with response_format, and know where the JSON arrives for each provider.
Chat models accept an OpenAI-style `response_format`, which turns "please reply
in JSON" from a request the model may quietly ignore into a constraint the
provider enforces:
```json
{ "response_format": { "type": "json_schema", "json_schema": {
"name": "person",
"strict": true,
"schema": {
"type": "object",
"properties": { "name": { "type": "string" }, "age": { "type": "integer" } },
"required": ["name", "age"],
"additionalProperties": false
}
} } }
```
Leave the field out — or send `{ "type": "text" }` — and the call behaves
exactly as before, so existing integrations are unaffected.
## The two modes [#the-two-modes]
| Type | What you get |
| ------------- | ------------------------------------------------------------------------------ |
| `json_object` | Valid JSON. The **shape is up to the model**, and it can change between calls. |
| `json_schema` | JSON that conforms to the schema you supply. |
Prefer `json_schema` whenever you know the shape you want. `json_object` still
leaves you writing defensive parsing code, because nothing stops the model from
renaming a key or nesting the answer one level deeper next time.
## Model support [#model-support]
Every chat model accepts **both** types, with these exceptions:
| Models | Accepts |
| ------------------------------------------------------------------------ | ------------------ |
| `claude-4.5-sonnet`, `claude-opus-4.7` | `json_schema` only |
| `gpt-4`, `gpt-4-turbo` | `json_object` only |
| `deepseek-chat`, `deepseek-reasoner` | `json_object` only |
| `qwq-plus`, `qvq-max` | `json_object` only |
| `qwen3-coder-flash`, `qwen3-coder-plus`, `qwen3.5-flash`, `qwen3.5-plus` | `json_object` only |
| `claude-4-sonnet` | neither |
Claude has no schema-less JSON mode, which is why `json_object` is refused
there rather than approximated. The Qwen models above accept a schema upstream
and then answer without enforcing it — a silently unconstrained reply is worse
than a clear error, so the gateway refuses the type the model cannot honour.
Ask for an unsupported type and you get a `400` naming the one that works,
before the request reaches the provider — never a surprise later.
## Where the JSON arrives [#where-the-json-arrives]
The response keeps the provider's **native envelope**. Your JSON is a *string*
in the usual text field, which you parse yourself:
| Provider | Field |
| --------------------------------------------------------- | ------------------------------------- |
| OpenAI-compatible (GPT, DeepSeek, Qwen, Grok, OpenRouter) | `choices[0].message.content` |
| Claude | `content[0].text` |
| Gemini | `candidates[0].content.parts[0].text` |
```json
{
"choices": [
{ "message": { "role": "assistant", "content": "{\"name\":\"Mara Ellison\",\"age\":34}" } }
]
}
```
### On v2 [#on-v2]
An [async](/docs/serverless-api/async-inference) result carries the whole
provider response as a **string** in `output`, so there are two decodes: one to
get the envelope, one to get your object.
```python
result = requests.get(poll_url, headers=headers).json()
envelope = json.loads(result["output"]) # provider response
person = json.loads(envelope["choices"][0]["message"]["content"]) # your object
```
The [Python SDK](/docs/sdks/python) collapses both steps: `ChatResponse.json()`
returns the parsed object on the sync and async paths alike.
## Rules that produce a 400 [#rules-that-produce-a-400]
**OpenAI and DeepSeek require the word "json" in the conversation** when you use
`json_object`. The provider rejects the request outright:
```
'messages' must contain the word 'json' in some form, to use 'response_format' of type 'json_object'
```
Adding "Reply in json." to your prompt is enough. `json_schema` has no such
rule.
**Schemas are not portable between providers.** Each enforces its own subset:
| Provider | Constraint |
| ----------------------- | ------------------------------------------------------------------------- |
| OpenAI (`strict: true`) | every property listed in `required`, and `additionalProperties: false` |
| Anthropic | rejects `minimum`/`maximum`, `minLength`/`maxLength` and recursive `$ref` |
| Gemini | accepts full JSON Schema |
The intersection — an object with every property required and
`additionalProperties: false`, no numeric or length bounds — works everywhere.
Write to that if one schema has to serve several models.
## Errors [#errors]
These come from the gateway, before the provider is called. On `/v1` they are a
`400`; on `/v2` the request lands as `FAILED` carrying the same message.
| Message | Cause |
| --------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| `response_format must be an object with "type" one of: text, json_object, json_schema` | The field is not an object, or the type is unrecognised |
| `response_format.json_schema.schema is required and must be a JSON schema object` | `json_schema` sent without a `schema` object |
| `response_format type json_schema is not supported by this model; use type json_object` | See the support table above |
| `this model does not support response_format` | The model supports neither type |
A schema keyword the provider rejects surfaces as a `400` naming the keyword.
## Examples [#examples]
```bash
curl -X POST https://api.segmind.com/v1/gpt-5.4-mini \
-H "x-api-key: $SEGMIND_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"messages": [{ "role": "user", "content": "Invent one person." }],
"response_format": {
"type": "json_schema",
"json_schema": {
"name": "person",
"strict": true,
"schema": {
"type": "object",
"properties": { "name": { "type": "string" }, "age": { "type": "integer" } },
"required": ["name", "age"],
"additionalProperties": false
}
}
}
}'
```
With the [Python SDK](/docs/sdks/python), where `.json()` does the parsing:
```python
import segmind
reply = segmind.chat_sync(
"gpt-5.4-mini",
messages=[{"role": "user", "content": "Invent one person."}],
response_format={
"type": "json_schema",
"json_schema": {
"name": "person",
"strict": True,
"schema": {
"type": "object",
"properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
"required": ["name", "age"],
"additionalProperties": False,
},
},
},
)
person = reply.json() # {'name': 'Mara Ellison', 'age': 34}
```
`.json()` raises a `SegmindError` when the reply was not JSON — a refusal, for
instance — so catch it rather than assuming the constraint always held.
## Notes [#notes]
* **Billing is unchanged.** You pay the model's usual token rates; asking for
structured output costs nothing extra.
* **No streaming.** Structured replies arrive whole.
* Schema-shaped output is also what powers
[fan-out from an LLM](/docs/pixelflow/guides/fan-out-and-parallel) in
PixelFlow, where the schema is derived from the fields your downstream nodes
consume.
# Video Editing (https://docs.segmind.com/docs/serverless-api/video-editing)
Compose multi-track video with /v2/timeline, split a video into clips with /v2/video-split, and run thumbnail, GIF and format-conversion jobs — all on the same async contract as the models.
Alongside the AI models, Segmind serves a set of **media editing endpoints** —
deterministic operations like compositing a timeline, cutting a video into
clips, or pulling a still frame. There is no model involved, so they are cheap
and fast, and they speak exactly the
[async contract](/docs/serverless-api/async-inference) you already use:
`POST /v2/{slug}`, poll the status URL, read the result.
That means an edit is just another step in the same pipeline as the generation
that produced the footage — no separate tool, no downloading and re-uploading
between stages.
## The endpoints [#the-endpoints]
| Endpoint | Required input | What it does |
| -------------------------- | ------------------- | ----------------------------------------------------------------------------------------- |
| `/v2/timeline` | `tracks` | Composes a multi-track edit — video, overlays, text, captions and audio — into one render |
| `/v2/video-split` | `video`, `mode` | Cuts one video into several clips |
| `/v2/video-thumbnail` | `video` | Extracts a still frame, returned in `images[]` |
| `/v2/video-gif-extract` | `video`, `end_time` | Makes a GIF from a segment |
| `/v2/video-format-convert` | `video` | Re-encodes between container formats |
| `/v2/image-compress` | `image` | Re-encodes an image at a lower size |
Each one bills like any other request — the jobs on this page each cost
$0.0002 — and the result carries the usual `metrics` block with `cost`,
`remaining_credits`, `queue_time` and `total_time`.
Submitting always returns `200` with a `request_id`, even if the body is
invalid. Input is validated when the job runs, so a malformed request surfaces
as `status: FAILED` on the status endpoint with a message naming the field at
fault — not as an error on the POST. Failed jobs are not charged.
## `/v2/timeline` — multi-track composition [#v2timeline--multi-track-composition]
One request describes a whole edit. A `composition` block sets the output
frame, `tracks` holds the layers, and `master` controls the final encode.
```json
{
"composition": { "width": 1280, "height": 720, "fps": 30, "duration": "auto", "format": "mp4" },
"tracks": [
{
"type": "video",
"id": "V1",
"clips": [
{ "source": "https://example.com/shot-a.mp4", "start": 0, "in": 0, "out": 4,
"transition_out": { "type": "dissolve", "duration": 0.75 } },
{ "source": "https://example.com/shot-b.mp4", "start": 3.25, "in": 0, "out": 4 }
]
},
{
"type": "text",
"id": "T1",
"clips": [
{ "start": 0.5, "duration": 3, "text": "Multi-track composition",
"style": { "size": 64, "color": "#FFFFFF", "bg": "#000000AA",
"position": "lower-third", "animation": "fade" } }
]
}
],
"master": { "video": { "crf": 20 }, "audio": { "normalize": true, "target_lufs": -14 } }
}
```
That request renders a 1280×720, 30 fps H.264 file: two clips joined by a
three-quarter-second dissolve, with a lower-third title fading in over the
opening.
### Track types [#track-types]
`tracks` is an ordered list. Visual tracks stack bottom to top, and every audio
track sums into one mix.
| `type` | Holds | Notable per-clip controls |
| --------- | ---------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| `video` | Video clips | `speed`, `crop`, `color`, `transform`, `transition_out`, `gain`, and `audio` to drop the clip's own sound |
| `overlay` | Images or video composited on top | `transform` — position, `scale`, `rotate`, `opacity`, `fit` |
| `text` | Rendered titles and captions you supply inline | `style` — font, `size`, `color`, background pill, stroke, shadow, `position`, `animation` |
| `caption` | Subtitles from an SRT or VTT source | the same `style` block |
| `audio` | Music and voice tracks | `gain`, `loop`, and `duck` |
Every clip shares the same timing fields: `start` places it on the timeline,
`in` and `out` trim the source, and `fade_in` / `fade_out` ramp its edges.
### Composition and master [#composition-and-master]
`composition` takes `width`, `height`, `fps`, `format` (`mp4` or `webm`) and
`background`. `duration` defaults to `"auto"`, which resolves to the extent of
the timeline. **Width and height must both be even numbers.** A transparent
background requires `format: "webm"`, since MP4 cannot carry an alpha channel.
`master` handles the finish: `video.crf` for encode quality, and
`audio.normalize` with `audio.target_lufs` — on by default at −14 LUFS, so a
mix of loud and quiet sources comes out at a consistent level without you
measuring anything.
### Ducking [#ducking]
An audio clip can duck against another track, which is the usual way to put
music under a voiceover:
```json
{ "type": "audio", "id": "A1", "clips": [
{ "source": "https://example.com/music.mp3", "start": 0, "loop": true,
"duck": { "key_track": "A2", "amount": -12, "attack": 0.2, "release": 0.4 } }
]}
```
Whenever a clip on `A2` is playing, this one drops by 12 dB and comes back
after it.
**A transition needs the two clips to overlap.** `transition_out` consumes time
from both sides, so the next clip must start exactly one transition-duration
before the previous one ends. A clip ending at `4` with a `0.75` second
transition requires the next to start at **`3.25`**. Get it wrong and the job
fails with a message giving you the number it expected.
## `/v2/video-split` — one video into many [#v2video-split--one-video-into-many]
```json
{ "video": "https://example.com/long.mp4", "mode": "count", "count": 3 }
```
`mode` picks how the cuts are chosen:
| `mode` | Also send | Result |
| ---------- | ------------------ | ----------------------------------------------------- |
| `count` | `count` | That many equal parts |
| `duration` | `segment_duration` | A part every N seconds, keeping the remainder |
| `segments` | `segments` | An explicit `[{ "start": 4.0, "end": 6.5 }]` cut list |
`reencode` defaults to `true` for frame-accurate cuts; set it to `false` for a
faster stream copy that snaps to keyframes. `output_format` accepts `mp4` or
`webm`.
**The result returns the first segment only.** A split job renders every part,
but the v2 result carries a single `video`. To retrieve a specific range, send
one request per range with `mode: "segments"` — a call with
`segments: [{ "start": 4.0, "end": 6.5 }]` returns exactly that 2.5 seconds.
`response_format: "json"` is accepted and validated, but on this endpoint it
returns the same single file as the default.
## Reading the result [#reading-the-result]
Which field holds the output follows the kind of file produced, matching the
rest of the API:
```json
{
"status": "COMPLETED",
"output": "https://images.segmind.com/generations/.../result.mp4",
"video": { "url": "...", "content_type": "video/mp4", "file_size": "2488382" },
"metrics": { "cost": 0.0002, "remaining_credits": 45.68,
"queue_time": 0.03, "total_time": 14.8 }
}
```
Video jobs fill `video`; jobs that produce a still — `video-thumbnail`,
`video-gif-extract`, `image-compress` — fill `images[]` instead. `output` always
points at the primary file either way.
## Next steps [#next-steps]
The submit-and-poll contract, retries, and the `metrics` block in full.
Upload your own footage and get a URL these endpoints can read.
# Web Search Grounding (https://docs.segmind.com/docs/serverless-api/web-search-grounding)
Ground Gemini text and image generations in live Google Search results with web_search: true, and read back the queries and sources behind the answer.
Gemini models can ground a generation in live Google Search results instead of
relying only on what they learned in training. Add one parameter:
```json
{ "web_search": true }
```
It is **off by default**, so existing calls are unaffected.
Grounding is worth reaching for when the answer depends on something current —
a record, a price, a recent release — and worth leaving off when it does not,
because it costs more and adds latency.
## Supported models [#supported-models]
| Kind | Models |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| **Text** | `gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`, `gemini-3-pro`, `gemini-3.1-pro`, `gemini-3-flash`, `gemini-3.1-flash-lite` |
| **Image** | `nano-banana-2`, `nano-banana-pro` |
On any other model the parameter is simply ignored.
## Reading the evidence [#reading-the-evidence]
Every grounded response tells you **which searches ran and which pages informed
the answer** — but where that arrives depends on the model kind and the API
version, because a sync image response has no JSON body to put it in.
### Text models [#text-models]
The grounding rides inline on the candidate, under `groundingMetadata`:
```json
{
"candidates": [
{
"content": { "parts": [{ "text": "..." }] },
"finishReason": "STOP",
"groundingMetadata": {
"webSearchQueries": [
"who won the most recent FIFA World Cup",
"FIFA World Cup 2022 winner"
],
"groundingChunks": [
{ "web": { "uri": "https://...", "title": "wikipedia.org" } }
],
"groundingSupports": [ ... ],
"searchEntryPoint": { "renderedContent": "
...
" }
}
}
]
}
```
| Field | What it holds |
| ------------------- | ----------------------------------------------------------------------------------------------- |
| `webSearchQueries` | the searches the model actually ran — often several per prompt, and not the same as your prompt |
| `groundingChunks` | the sources, each with a `uri` and a `title` |
| `groundingSupports` | which part of the answer each source backs |
| `searchEntryPoint` | Google's Search Suggestions widget — see [Displaying the widget](#displaying-the-widget) |
### Image models on v2 [#image-models-on-v2]
An image model cannot carry metadata inside its output, so the
[async](/docs/serverless-api/async-inference) result envelope gains a top-level
`grounding` object:
```json
{
"status": "COMPLETED",
"output": "https://images.segmind.com/generations/...jpeg",
"grounding": {
"web_search_queries": [
"men's marathon world record athlete and time"
],
"sources": [
{ "title": "wikipedia.org", "uri": "https://..." }
],
"search_entry_point_html": "
...
"
}
}
```
### Image models on v1 [#image-models-on-v1]
A synchronous image call returns **the image bytes as the body**, so there is
nowhere in the response to put the evidence. The queries come back in a header
instead:
```
x-web-search-queries: ["tallest building in the world 2025", "tallest building in the world height"]
```
It carries the queries that ran, as a JSON array, and is truncated for very
long lists. Expect fewer entries than you might guess: the model batches
related questions, so a prompt asking about a dozen things often resolves to
two or three searches.
If you need the sources as well, use the v2 endpoint — the header has no room
for them.
The details are also kept with the generation, so you can go back and inspect
what a past grounded request searched for.
## Asking for grounding does not guarantee it [#asking-for-grounding-does-not-guarantee-it]
`web_search: true` gives the model permission to search — not an obligation. If
it judges that it does not need to, it answers from training and **the response
carries no grounding at all**: no `groundingMetadata`, no `grounding` object, no
header.
So treat the evidence as optional. Check whether it is present rather than
indexing into it:
```python
grounding = result.get("grounding") # image models on v2
if grounding:
print(grounding["web_search_queries"])
```
An ungrounded answer to a grounded request is normal, not an error.
## Displaying the widget [#displaying-the-widget]
`searchEntryPoint` on text models and `search_entry_point_html` on image models
hold the same thing: a block of HTML for Google's **Search Suggestions** widget.
Google's grounding terms require a user-facing application to display this
widget when it shows a grounded result. If you are surfacing grounded output to
end users, render it — do not discard it. It is passed through to you
unmodified for exactly that reason.
## What it costs [#what-it-costs]
Grounding adds a surcharge on top of the model's normal price, and it is
charged **only when the response actually comes back grounded** — a request that
opts in and is not grounded is not surcharged for search.
How the surcharge is counted depends on the model generation: newer Gemini
models are billed per search query executed, where one prompt can fire several,
and earlier ones a flat amount per grounded prompt. Because the query count is
not known ahead of the call, a grounded request's cost is not fixed — read the
`cost` in the response's `metrics`, or see
[Cost Analytics](/docs/serverless-api/monitoring#cost-analytics) for the totals.
# Webhooks (https://docs.segmind.com/docs/serverless-api/webhooks)
Receive real-time HTTP POST callbacks from Segmind when a PixelFlow run changes state, so you can react to node and graph events without polling.
## Introduction [#introduction]
Webhooks are a powerful feature that allows users or applications to receive real-time updates from the Segmind platform. They enable seamless integration by sending HTTP POST requests to a specified URL whenever certain events occur. This allows developers to automate workflows and respond to events in real-time without polling the API for updates.
## PixelFlow events [#pixelflow-events]
Updates on the execution of API nodes inside PixelFlow workflows, with outputs
delivered as URLs. Two events are supported:
* `NODE_RUN` — sent whenever an API node runs.
* `GRAPH_RUN` — sent once a workflow API has finished all processing.
## Registering a webhook [#registering-a-webhook]
Go to [Webhooks](https://platform.segmind.com/webhooks) in the console, under
**Developer**, and register the URL you want called.
You can also manage registrations from the [Python SDK](/docs/sdks/python)
without opening the console:
```python
import segmind
segmind.webhooks.get() # list your registrations
segmind.webhooks.add(webhook_url, event_types)
segmind.webhooks.update(webhook_id, webhook_url, event_types)
segmind.webhooks.delete(webhook_id)
segmind.webhooks.logs(webhook_id) # delivery history for one registration
```
`logs()` is the one to reach for when a webhook is not arriving — it shows what
was attempted for that registration, which distinguishes "never sent" from
"sent and your endpoint rejected it".
## Fine-tuning events [#fine-tuning-events]
Fine-tuning webhooks — `DATA_PROCESSING`, `TRAINING_INITIATED`,
`TRAINING_COMPLETED`, `DEPLOYING` and `AVAILABLE` — relate to the fine-tuning
service, which **no longer accepts new training jobs**. They are listed here for
existing integrations only. See the
[fine-tuning overview](/docs/fine-tuning).
# Fast Flux fine Tuning API (https://docs.segmind.com/docs/fine-tuning/apis/fast-flux)
Deprecated. API reference for Fast Flux fine-tuning on Segmind: initiate a job, fetch a single request, and list all fine-tune requests.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
This documentation outlines the API endpoints for initiating and managing Fast Flux fine-tuning requests in Segmind.
### Base URL [#base-url]
```
https://api.segmind.com
```
### Authentication [#authentication]
All requests require an API key for authentication. Include the API key in the headers as follows:
```
--header 'x-api-key: YOUR_API_KEY'
```
### 1. Initiate Fine-Tune Request [#1-initiate-fine-tune-request]
#### Description [#description]
Initiate a new fine-tuning request.
Request
**Headers**
* `x-api-key`: Your API key.
* `Content-Type`: Should be `application/json`.
**Dataset (data\_source\_path)**
* `data_source_path`: A URL pointing to a ZIP file containing your training dataset.\
`Purpose`: Specifies the dataset source for fine-tuning. Must be a valid public URL or a Segmind public URL. \
`Options`: "Public ZIP URL (must support GET & HEAD requests)", "Segmind Public URL using Presigned (public)" \
`Descriptions`: \\
* `Public ZIP URL`: Must be directly accessible and respond properly to both HEAD and GET requests with headers like Content-Length. \\
* `Segmind Presigned URL`: Use Segmind Presigned URL endpoint with public as true to upload as public zip file. \\
* `File Size Limit`: The ZIP file must be under 100 MB in size. Larger files will be rejected or failed by the system.
**Body**
The request body must be in JSON format.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/submit' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "fastfluxtest1",
"data_source_path": "Segmind-hosted Public ZIP URL (uploaded via presigned link with public access)" or "any public zip url",
"instance_prompt": "1MAN, running in brown suit",
"trigger_word": "1MAN",
"base_model": "FAST_FLUX",
"theme": "subject",
"segmind_public": false,
"advance_parameters": {
"steps": 2000,
"face_crop": false,
"finetune_type": "LORA"
}
}'
```
#### Sample Response [#sample-response]
```
{
"status": "REQUESTED",
"finetune_id": "uuid",
"name": "fine-tune-job-name"
}
```
### 2. Get the Details of Individual Fine-Tune Request [#2-get-the-details-of-individual-fine-tune-request]
#### Description [#description-1]
Retrieve a fine-tuning request along with details.
**Request**
```
curl --location --request GET 'https://api.segmind.com/finetune/request/details' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"request_id": "FINETUNE_ID"
}'
```
#### Sample Response [#sample-response-1]
```
{
"finetune": {
"id": "uuid",
"finetune_id": "uuid",
"name": "fine-tune-job-name",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"instance_prompt": "sample instance prompt",
"status": "AVAILABLE",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"slug": "model-slug",
"public_model": false,
"error_message": null,
"cloud_storage_url": "https://your-bucket.s3.amazonaws.com/path/to/model.safetensors",
"created_ts": "2025-01-01T00:00:00Z",
"updated_ts": "2025-01-01T00:00:00Z"
}
}
```
### 3. Get the List of Fine-Tune Requests [#3-get-the-list-of-fine-tune-requests]
#### Description [#description-2]
Retrieve a list of fine-tuning requests along with their details.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/list' \
--header 'x-api-key: YOUR_API_KEY'
```
#### Sample Response [#sample-response-2]
```
[
{
"id": "uuid",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"name": "fine-tune-job-name",
"status": "AVAILABLE",
"error_message": null,
"segmind_model_path": null,
"advance_parameters": {
"steps": 10,
"learning_rate": 0.0001,
"prompt": "sample prompt",
"theme": "sample-theme"
},
"segmind_public_model": false,
"train_type": "LORA",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"theme": "sample-theme",
"cloud_storage_url": null,
"finetune_id": "uuid",
"model_information": {}
}
]
```
### 4. Get Fine-Tune Data Upload Pre-Signed URL [#4-get-fine-tune-data-upload-pre-signed-url]
#### Description [#description-3]
Obtain a public pre-signed URL to securely upload fine-tuning data to cloud storage.
This URL allows you to upload data directly from your local system or application without needing AWS credentials.
#### Usage [#usage]
Call this endpoint to generate a temporary public pre-signed URL. Use the returned URL to upload your dataset file to the specified location via a PUT request.
#### Request [#request]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/upload/pre-signed-url' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "NAME_OF_THE_FILE",
"extension": ".zip",
"public": true
}'
```
#### Sample Response [#sample-response-3]
```
{
"presigned_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip?X-Amz-Algorithm=...&X-Amz-Signature=...",
"s3_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip"
}
```
#### Upload File Using the Pre-Signed URL [#upload-file-using-the-pre-signed-url]
Once you have the presigned\_url, upload your dataset file using the following curl command:
#### Request [#request-1]
```
curl -X PUT \
-T your_dataset.zip \
-H "Content-Type: application/zip" \
-H "x-amz-acl: public-read" \
"PRESIGNED_URL"
```
#### Note [#note]
* Replace your\_dataset.zip with your actual local file name.
* Replace PRESIGNED\_URL with the exact presigned\_url value received in the previous step.
* The x-amz-acl: public-read header is required if the pre-signed URL is generated with public read access.
### 5. Update Fine-Tuned Model Access [#5-update-fine-tuned-model-access]
#### Description [#description-4]
Update the access settings of a fine-tuned model (public/private).
#### Request [#request-2]
```
curl --location --request PUT 'https://api.segmind.com/finetune/request/access-update' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'request_id="FINETUNE_REQUEST_ID"' \
--form 'segmind_public="True"'
```
#### Sample Response [#sample-response-4]
```
200
```
### 6. Download the Fine-Tuned Safetensor File [#6-download-the-fine-tuned-safetensor-file]
#### Description [#description-5]
Fast Fine-tuned model weight files (.safetensors) are now publicly accessible via the cloud\_storage\_url.
You can download them directly without generating a pre-signed URL or using AWS credentials.
#### Request [#request-3]
```
curl -L "https://storage.googleapis.com//.safetensors" -o model.safetensors
```
#### Sample Response [#sample-response-5]
```
https://storage.googleapis.com/my-finetune-bucket/abc12345/model.safetensors
```
## Webhooks [#webhooks]
Webhooks provide a way to get real-time updates about finetuning jobs programmatically. You can register a webhook for finetuning jobs in the Developer tab on console.
Once a webhook is created, test it, by having it send a sample payload to verify delivery. Once its up, create a finetuning job to receive status updates. \
\
Events are sent to webhooks on 3 status changes:\\
1. `TRAINING_COMPLETED` : The training is completed on model, and finetuned model is available for download on the `trained_model_url`.
2. `INFERENCE_QUEUED`: Model is being deployed on Segmind inference engine.
3. `AVAILABLE`: Model is deployed, and ready for inferences on `inference_api_url`
Note: You can create only 1 webhook at a time for finetune jobs. If you want to change the webhook, please delete the old webhook before creating a new one.
# Flux Kontext fine Tuning API (https://docs.segmind.com/docs/fine-tuning/apis/flux-kontext)
Deprecated. API reference for Flux Kontext fine-tuning on Segmind: initiate a job, fetch a single request, and list all fine-tune requests.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
This documentation outlines the API endpoints for initiating and managing Flux Kontext fine-tuning requests in Segmind.
### Base URL [#base-url]
```
https://api.segmind.com
```
### Authentication [#authentication]
All requests require an API key for authentication. Include the API key in the headers as follows:
```
--header 'x-api-key: YOUR_API_KEY'
```
### 1. Initiate Fine-Tune Request [#1-initiate-fine-tune-request]
#### Description [#description]
Initiate a new fine-tuning request.
Request
**Headers**
* `x-api-key`: Your API key.
* `Content-Type`: Should be `application/json`.
**Dataset (data\_source\_path)**
* `data_source_path`: A URL pointing to a ZIP file containing your training dataset.\
`Purpose`: Specifies the dataset source for fine-tuning. Must be a valid public URL or a private Segmind URL. \
`Options`: "Public ZIP URL (must support GET & HEAD requests)", "Segmind Private URL using Presigned" \
`Descriptions`: \\
* `Public ZIP URL`: Must be directly accessible and respond properly to both HEAD and GET requests with headers like Content-Length. \\
* `Segmind Presigned URL`: Use Segmind Presigned URL endpoint to upload as private zip file
**GPU Selection**
* `machine_type: Specifies the GPU used for the fine-tuning job`\
`Purpose: Defines the hardware performance tier for training in request submit endpoint` \
`Options: "NVIDIA_H100"` \
`Descriptions: ` \
`- NVIDIA_H100 (Fastest training)` \\
**Body**
The request body must be in JSON format.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/submit' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "fluxkontexttest1",
"data_source_path": "Segmind-hosted Private ZIP URL (uploaded via presigned link)" or "any public zip url",
"instance_prompt": "Change the woman's hair color to bright red",
"base_model": "FLUX",
"train_type": "LORA",
"machine_type": "NVIDIA_H100",
"theme": "KONTEXT",
"segmind_public": false,
"advance_parameters": {
"learning_rate": 0.0004,
"steps": 300
}
}'
```
#### Sample Response [#sample-response]
```
{
"status": "REQUESTED",
"finetune_id": "uuid",
"name": "fine-tune-job-name"
}
```
### 2. Get the Details of Individual Fine-Tune Request [#2-get-the-details-of-individual-fine-tune-request]
#### Description [#description-1]
Retrieve a fine-tuning request along with details.
**Request**
```
curl --location --request GET 'https://api.segmind.com/finetune/request/details' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"request_id": "FINETUNE_ID"
}'
```
#### Sample Response [#sample-response-1]
```
{
"finetune": {
"id": "uuid",
"finetune_id": "uuid",
"name": "fine-tune-job-name",
"data_source_path": "https://bucket.s3.amazonaws.com/path/to/dataset.zip",
"instance_prompt": "sample instance prompt",
"status": "AVAILABLE",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"slug": "model-slug",
"public_model": false,
"error_message": null,
"cloud_storage_url": "https://your-bucket.s3.amazonaws.com/path/to/model.safetensors",
"created_ts": "2025-01-01T00:00:00Z",
"updated_ts": "2025-01-01T00:00:00Z"
}
}
```
### 3. Get the List of Fine-Tune Requests [#3-get-the-list-of-fine-tune-requests]
#### Description [#description-2]
Retrieve a list of fine-tuning requests along with their details.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/list' \
--header 'x-api-key: YOUR_API_KEY'
```
#### Sample Response [#sample-response-2]
```
[
{
"id": "uuid",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"name": "fine-tune-job-name",
"status": "AVAILABLE",
"error_message": null,
"segmind_model_path": null,
"advance_parameters": {
"steps": 10,
"learning_rate": 0.0001,
"prompt": "sample prompt",
"theme": "sample-theme"
},
"segmind_public_model": false,
"train_type": "LORA",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"theme": "sample-theme",
"cloud_storage_url": null,
"finetune_id": "uuid",
"model_information": {}
}
]
```
### 4. Get Fine-Tune Data Upload Pre-Signed URL [#4-get-fine-tune-data-upload-pre-signed-url]
#### Description [#description-3]
Obtain a pre-signed URL to securely upload fine-tuning data to cloud storage.
This URL allows you to upload data directly from your local system or application without needing AWS credentials.
#### Usage [#usage]
Call this endpoint to generate a temporary pre-signed URL. Use the returned URL to upload your dataset file to the specified location via a PUT request.
#### Request [#request]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/upload/pre-signed-url' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "NAME_OF_THE_FILE"
}'
```
#### Sample Response [#sample-response-3]
```
{
"presigned_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip?X-Amz-Algorithm=...&X-Amz-Signature=...",
"s3_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip"
}
```
### 5. Update Fine-Tuned Model Access [#5-update-fine-tuned-model-access]
#### Description [#description-4]
Update the access settings of a fine-tuned model (public/private).
#### Request [#request-1]
```
curl --location --request PUT 'https://api.segmind.com/finetune/request/access-update' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'request_id="FINETUNE_REQUEST_ID"' \
--form 'segmind_public="True"'
```
#### Sample Response [#sample-response-4]
```
200
```
### 6. Download the Fine-Tuned Safetensor File [#6-download-the-fine-tuned-safetensor-file]
#### Description [#description-5]
Generate a time-limited pre-signed URL to securely download the fine-tuned model file (.safetensors) from cloud storage.
The URL is valid for 1 hour and allows direct download without requiring AWS credentials.
#### Request [#request-2]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/file/download' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'cloud_storage_url="CLOUD_STORAGE_URL"'
```
#### Sample Response [#sample-response-5]
```
https://segmind-sd-models.s3.amazonaws.com/finetune/finetuned_models/job_id/filename.safetensors?AWSAccessKeyId=***&Signature=***&Expires=***
```
## Webhooks [#webhooks]
Webhooks provide a way to get real-time updates about finetuning jobs programmatically. You can register a webhook for finetuning jobs in the Developer tab on console.
Once a webhook is created, test it, by having it send a sample payload to verify delivery. Once its up, create a finetuning job to receive status updates. \
\
Events are sent to webhooks on 3 status changes:\\
1. `TRAINING_COMPLETED` : The training is completed on model, and finetuned model is available for download on the `trained_model_url`.
2. `INFERENCE_QUEUED`: Model is being deployed on Segmind inference engine.
3. `AVAILABLE`: Model is deployed, and ready for inferences on `inference_api_url`
Note: You can create only 1 webhook at a time for finetune jobs. If you want to change the webhook, please delete the old webhook before creating a new one.
# Flux Pro fine tuning API (https://docs.segmind.com/docs/fine-tuning/apis/flux-pro)
Deprecated. API reference for Flux Pro fine-tuning on Segmind: initiate a job, fetch a single request, and list all fine-tune requests.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
This documentation outlines the API endpoints for initiating and managing Flux Pro fine-tuning requests in Segmind.
### Base URL [#base-url]
```
https://api.segmind.com
```
### Authentication [#authentication]
All requests require an API key for authentication. Include the API key in the headers as follows:
```
--header 'x-api-key: YOUR_API_KEY'
```
### 1. Initiate Fine-Tune Request [#1-initiate-fine-tune-request]
#### Description [#description]
Initiate a new fine-tuning request.
Request
**Headers**
* `x-api-key`: Your API key.
* `Content-Type`: Should be `application/json`.
**Dataset (data\_source\_path)**
* `data_source_path`: A URL pointing to a ZIP file containing your training dataset.\
`Purpose`: Specifies the dataset source for fine-tuning. Must be a valid public URL or a private Segmind URL. \
`Options`: "Public ZIP URL (must support GET & HEAD requests)", "Segmind Private URL uploaded using Presigned" \
`Descriptions`: \\
* `Public ZIP URL`: Must be directly accessible and respond properly to both HEAD and GET requests with headers like Content-Length. \\
* `Segmind Presigned URL`: Use Segmind Presigned URL endpoint to upload as private zip file. \\
* `File Size Limit`: The ZIP file must be under 100 MB in size. Larger files will be rejected or failed by the system.
**Body**
The request body must be in JSON format.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/submit' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "fluxprotest",
"data_source_path": "Segmind-hosted Private ZIP URL (uploaded via presigned link)" or "any public zip url",
"instance_prompt": "1MAN, running in brown suit",
"trigger_word": "1MAN",
"base_model": "FLUX_PRO",
"theme": "GENERAL",
"segmind_public": false,
"advance_parameters": {
"iterations": 300,
"captioning": true,
"priority": "QUALITY",
"finetune_type": "FULL",
"lora_rank": 32,
"learning_rate": 0.005
}
}'
```
#### Sample Response [#sample-response]
```
{
"status": "REQUESTED",
"finetune_id": "uuid",
"name": "fine-tune-job-name"
}
```
**`Advanced Parameters:`**
* `theme: Determines the finetuning approach based on your concept`\
`Options: "CHARACTER", "PRODUCT", "STYLE", "GENERAL"`
* `iterations`\
`Minimum: 100`\
`Default: 300`\
`Purpose: Defines training duration.`\
`For fast exploration 100-150 iterations can be enough.`\
`For more complex concepts, larger datasets or extreme precision more iterations than the default can help`
* `learning_rate`\
`Default: 0.00001 if finetune_type is "FULL"`\
`Default: 0.0001 if finetune_type is "LORA".`
* `priority`\
`Options: "SPEED", "QUALITY", "HIGH_RES_ONLY"`\
`The speed priority will improve speed per training step`\
`Default: "QUALITY"`
* `captioning`\
`Type: Boolean`\
`Default: True`\
`Purpose: Enables/disables automatic image captioning`
* `trigger_word`\
`Default: "TOK"`\
`Purpose: Unique word/phrase that will be used in the captions, to reference the newly introduced concepts`
* `lora_rank`\
`Default: 32`\
`Choose between 32 and 16. A lora_rank of 16 can increase training efficiency and decrease loading times.`
* `finetune_type`\
`Default: "FULL"`\
`Choose between “FULL” for a full finetuning + post hoc extraction of the trained weights into a LoRA or “LORA” for a raw LoRA training`
### 2. Get the Details of Individual Fine-Tune Request [#2-get-the-details-of-individual-fine-tune-request]
#### Description [#description-1]
Retrieve a fine-tuning request along with details.
**Request**
```
curl --location --request GET 'https://api.segmind.com/finetune/request/details' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"request_id": "FINETUNE_ID"
}'
```
#### Sample Response [#sample-response-1]
```
{
"finetune": {
"id": "uuid",
"finetune_id": "uuid",
"name": "fine-tune-job-name",
"data_source_path": "https://bucket.s3.amazonaws.com/path/to/dataset.zip",
"instance_prompt": "sample instance prompt",
"status": "AVAILABLE",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"slug": "model-slug",
"public_model": false,
"error_message": null,
"cloud_storage_url": "https://your-bucket.s3.amazonaws.com/path/to/model.safetensors",
"created_ts": "2025-01-01T00:00:00Z",
"updated_ts": "2025-01-01T00:00:00Z"
}
}
```
### 3. Get the List of Fine-Tune Requests [#3-get-the-list-of-fine-tune-requests]
#### Description [#description-2]
Retrieve a list of fine-tuning requests along with their details.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/list' \
--header 'x-api-key: YOUR_API_KEY'
```
#### Sample Response [#sample-response-2]
```
[
{
"id": "uuid",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"name": "fine-tune-job-name",
"status": "AVAILABLE",
"error_message": null,
"segmind_model_path": null,
"advance_parameters": {
"steps": 10,
"learning_rate": 0.0001,
"prompt": "sample prompt",
"theme": "sample-theme"
},
"segmind_public_model": false,
"train_type": "LORA",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"theme": "sample-theme",
"cloud_storage_url": null,
"finetune_id": "uuid",
"model_information": {}
}
]
```
### 4. Get Fine-Tune Data Upload Pre-Signed URL [#4-get-fine-tune-data-upload-pre-signed-url]
#### Description [#description-3]
Obtain a pre-signed URL to securely upload fine-tuning data to cloud storage.
This URL allows you to upload data directly from your local system or application without needing AWS credentials.
#### Usage [#usage]
Call this endpoint to generate a temporary pre-signed URL. Use the returned URL to upload your dataset file to the specified location via a PUT request.
#### Request [#request]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/upload/pre-signed-url' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "NAME_OF_THE_FILE"
}'
```
#### Sample Response [#sample-response-3]
```
{
"presigned_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip?X-Amz-Algorithm=...&X-Amz-Signature=...",
"s3_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip"
}
```
### 5. Update Fine-Tuned Model Access [#5-update-fine-tuned-model-access]
#### Description [#description-4]
Update the access settings of a fine-tuned model (public/private).
#### Request [#request-1]
```
curl --location --request PUT 'https://api.segmind.com/finetune/request/access-update' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'request_id="FINETUNE_REQUEST_ID"' \
--form 'segmind_public="True"'
```
#### Sample Response [#sample-response-4]
```
200
```
## Webhooks [#webhooks]
Webhooks provide a way to get real-time updates about finetuning jobs programmatically. You can register a webhook for finetuning jobs in the Developer tab on console.
Once a webhook is created, test it, by having it send a sample payload to verify delivery. Once its up, create a finetuning job to receive status updates. \
\
Events are sent to webhooks on 3 status changes:\\
1. `TRAINING_COMPLETED` : The training is completed on model, and finetuned model is available for download on the `trained_model_url`.
2. `INFERENCE_QUEUED`: Model is being deployed on Segmind inference engine.
3. `AVAILABLE`: Model is deployed, and ready for inferences on `inference_api_url`
Note: You can create only 1 webhook at a time for finetune jobs. If you want to change the webhook, please delete the old webhook before creating a new one.
# Flux fine Tuning API (https://docs.segmind.com/docs/fine-tuning/apis/flux)
Deprecated. API reference for Flux fine-tuning on Segmind: initiate a job, fetch a single request, and list all fine-tune requests.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
This documentation outlines the API endpoints for initiating and managing Flux fine-tuning requests in Segmind.
### Base URL [#base-url]
```
https://api.segmind.com
```
### Authentication [#authentication]
All requests require an API key for authentication. Include the API key in the headers as follows:
```
--header 'x-api-key: YOUR_API_KEY'
```
### 1. Initiate Fine-Tune Request [#1-initiate-fine-tune-request]
#### Description [#description]
Initiate a new fine-tuning request.
Request
**Headers**
* `x-api-key`: Your API key.
* `Content-Type`: Should be `application/json`.
**Dataset (data\_source\_path)**
* `data_source_path`: A URL pointing to a ZIP file containing your training dataset.\
`Purpose`: Specifies the dataset source for fine-tuning. Must be a valid public URL or a private Segmind URL. \
`Options`: "Public ZIP URL (must support GET & HEAD requests)", "Segmind Private URL using Presigned" \
`Descriptions`: \\
* `Public ZIP URL`: Must be directly accessible and respond properly to both HEAD and GET requests with headers like Content-Length. \\
* `Segmind Presigned URL`: Use Segmind Presigned URL endpoint to upload as private zip file
**GPU Selection**
* `machine_type: Specifies the GPU used for the fine-tuning job`\
`Purpose: Defines the hardware performance tier for training in request submit endpoint` \
`Options: "NVIDIA_A100_40GB", "NVIDIA_H100", "NVIDIA_L40S"` \
`Descriptions: ` \
`- NVIDIA_A100_40GB (Balanced performance)` \
`- NVIDIA_H100 (Fastest training)` \
`- NVIDIA_L40S (Cost-efficient)`
**Body**
The request body must be in JSON format.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/submit' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "fluxtest1",
"data_source_path": "Segmind-hosted Private ZIP URL (uploaded via presigned link)" or "any public zip url",
"instance_prompt": "1MAN, running in brown suit",
"trigger_word": "1MAN",
"base_model": "FLUX",
"train_type": "LORA",
"machine_type": "NVIDIA_A100_40GB",
"theme": "FLUX",
"segmind_public": false,
"advance_parameters": {
"auto_caption": true,
"batch_size": 2,
"bucket_steps": 64,
"center_crop": false,
"content_or_style": "balanced",
"gradient_accumulation_steps": 2,
"learning_rate": 0.0004,
"linear": 16,
"linear_alpha": 16,
"lora_rank": 128,
"lr_scheduler": "constant",
"max_grad_norm": 0,
"noise_offset": 0,
"num_train_epochs": 1000,
"optimizer_type": "Adafactor",
"prompt": "driving a truck",
"relative_step": false,
"repeats": 100,
"resolution": 1024,
"steps": 1000,
"weight_decay": 0.01
}
}'
```
#### Sample Response [#sample-response]
```
{
"status": "REQUESTED",
"finetune_id": "uuid",
"name": "fine-tune-job-name"
}
```
### 2. Get the Details of Individual Fine-Tune Request [#2-get-the-details-of-individual-fine-tune-request]
#### Description [#description-1]
Retrieve a fine-tuning request along with details.
**Request**
```
curl --location --request GET 'https://api.segmind.com/finetune/request/details' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"request_id": "FINETUNE_ID"
}'
```
#### Sample Response [#sample-response-1]
```
{
"finetune": {
"id": "uuid",
"finetune_id": "uuid",
"name": "fine-tune-job-name",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"instance_prompt": "sample instance prompt",
"status": "AVAILABLE",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"slug": "model-slug",
"public_model": false,
"error_message": null,
"cloud_storage_url": "https://your-bucket.s3.amazonaws.com/path/to/model.safetensors",
"created_ts": "2025-01-01T00:00:00Z",
"updated_ts": "2025-01-01T00:00:00Z"
}
}
```
### 3. Get the List of Fine-Tune Requests [#3-get-the-list-of-fine-tune-requests]
#### Description [#description-2]
Retrieve a list of fine-tuning requests along with their details.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/list' \
--header 'x-api-key: YOUR_API_KEY'
```
#### Sample Response [#sample-response-2]
```
[
{
"id": "uuid",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"name": "fine-tune-job-name",
"status": "AVAILABLE",
"error_message": null,
"segmind_model_path": null,
"advance_parameters": {
"steps": 10,
"learning_rate": 0.0001,
"prompt": "sample prompt",
"theme": "sample-theme"
},
"segmind_public_model": false,
"train_type": "LORA",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"theme": "sample-theme",
"cloud_storage_url": null,
"finetune_id": "uuid",
"model_information": {}
}
]
```
### 4. Get Fine-Tune Data Upload Pre-Signed URL [#4-get-fine-tune-data-upload-pre-signed-url]
#### Description [#description-3]
Obtain a pre-signed URL to securely upload fine-tuning data to cloud storage.
This URL allows you to upload data directly from your local system or application without needing AWS credentials.
#### Usage [#usage]
Call this endpoint to generate a temporary pre-signed URL. Use the returned URL to upload your dataset file to the specified location via a PUT request..
#### Request [#request]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/upload/pre-signed-url' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "NAME_OF_THE_FILE"
}'
```
#### Sample Response [#sample-response-3]
```
{
"presigned_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip?X-Amz-Algorithm=...&X-Amz-Signature=...",
"s3_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip"
}
```
### 5. Update Fine-Tuned Model Access [#5-update-fine-tuned-model-access]
#### Description [#description-4]
Update the access settings of a fine-tuned model (public/private).
#### Request [#request-1]
```
curl --location --request PUT 'https://api.segmind.com/finetune/request/access-update' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'request_id="FINETUNE_REQUEST_ID"' \
--form 'segmind_public="True"'
```
#### Sample Response [#sample-response-4]
```
200
```
### 6. Download the Fine-Tuned Safetensor File [#6-download-the-fine-tuned-safetensor-file]
#### Description [#description-5]
Generate a time-limited pre-signed URL to securely download the fine-tuned model file (.safetensors) from cloud storage.
The URL is valid for 1 hour and allows direct download without requiring AWS credentials.
#### Request [#request-2]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/file/download' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'cloud_storage_url="CLOUD_STORAGE_URL"'
```
#### Sample Response [#sample-response-5]
```
https://segmind-sd-models.s3.amazonaws.com/finetune/finetuned_models/job_id/filename.safetensors?AWSAccessKeyId=***&Signature=***&Expires=***
```
## Webhooks [#webhooks]
Webhooks provide a way to get real-time updates about finetuning jobs programmatically. You can register a webhook for finetuning jobs in the Developer tab on console.
Once a webhook is created, test it, by having it send a sample payload to verify delivery. Once its up, create a finetuning job to receive status updates. \
\
Events are sent to webhooks on 3 status changes:\\
1. `TRAINING_COMPLETED` : The training is completed on model, and finetuned model is available for download on the `trained_model_url`.
2. `INFERENCE_QUEUED`: Model is being deployed on Segmind inference engine.
3. `AVAILABLE`: Model is deployed, and ready for inferences on `inference_api_url`
Note: You can create only 1 webhook at a time for finetune jobs. If you want to change the webhook, please delete the old webhook before creating a new one.
# Qwen fine Tuning API (https://docs.segmind.com/docs/fine-tuning/apis/qwen)
Deprecated. API reference for Qwen fine-tuning on Segmind: initiate a job, fetch a single request, and list all fine-tune requests.
Segmind fine-tuning no longer accepts new training jobs. Existing fine-tuned
models remain available for inference. This page is kept for reference — see
the [fine-tuning overview](/docs/fine-tuning) for what still applies.
This documentation outlines the API endpoints for initiating and managing Qwen fine-tuning requests in Segmind.
### Base URL [#base-url]
```
https://api.segmind.com
```
### Authentication [#authentication]
All requests require an API key for authentication. Include the API key in the headers as follows:
```
--header 'x-api-key: YOUR_API_KEY'
```
### 1. Initiate Fine-Tune Request [#1-initiate-fine-tune-request]
#### Description [#description]
Initiate a new fine-tuning request.
Request
**Headers**
* `x-api-key`: Your API key.
* `Content-Type`: Should be `application/json`.
**Dataset (data\_source\_path)**
* `data_source_path`: A URL pointing to a ZIP file containing your training dataset.\
`Purpose`: Specifies the dataset source for fine-tuning. Must be a valid public URL or a private Segmind URL. \
`Options`: "Public ZIP URL (must support GET & HEAD requests)", "Segmind Private URL using Presigned" \
`Descriptions`: \\
* `Public ZIP URL`: Must be directly accessible and respond properly to both HEAD and GET requests with headers like Content-Length. \\
* `Segmind Presigned URL`: Use Segmind Presigned URL endpoint to upload as private zip file
**GPU Selection**
* `machine_type: Specifies the GPU used for the fine-tuning job`\
`Purpose: Defines the hardware performance tier for training in request submit endpoint` \
`Options: "NVIDIA_H100"` \
`Descriptions: ` \
`- NVIDIA_H100 (Fastest training)`
**Body**
The request body must be in JSON format.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/submit' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "qwentest",
"data_source_path": "Segmind-hosted Private ZIP URL (uploaded via presigned link)" or "any public zip url",
"instance_prompt": "1MAN, running in brown suit",
"trigger_word": "1MAN",
"base_model": "QWEN",
"theme": "QWEN",
"machine_type": "NVIDIA_H100",
"train_type": "LORA",
"segmind_public": false,
"advance_parameters": {
"steps": 1000,
"auto_caption": false,
"learning_rate": 0.0004
}
}'
```
#### Sample Response [#sample-response]
```
{
"status": "REQUESTED",
"request_id": "uuid",
"name": "fine-tune-job-name"
}
```
### 2. Get the Details of Individual Fine-Tune Request [#2-get-the-details-of-individual-fine-tune-request]
#### Description [#description-1]
Retrieve a fine-tuning request along with details.
**Request**
```
curl --location --request GET 'https://api.segmind.com/finetune/request/details' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"request_id": "REQUEST_ID"
}'
```
#### Sample Response [#sample-response-1]
```
{
"finetune": {
"request_id": "uuid",
"finetune_id": "uuid",
"name": "fine-tune-job-name",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"instance_prompt": "sample instance prompt",
"status": "AVAILABLE",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"slug": "model-slug",
"public_model": false,
"error_message": null,
"cloud_storage_url": "https://your-bucket.s3.amazonaws.com/path/to/model.safetensors",
"created_ts": "2025-01-01T00:00:00Z",
"updated_ts": "2025-01-01T00:00:00Z"
}
}
```
### 3. Get the List of Fine-Tune Requests [#3-get-the-list-of-fine-tune-requests]
#### Description [#description-2]
Retrieve a list of fine-tuning requests along with their details.
**Request**
```
curl --location 'https://api.segmind.com/finetune/request/list' \
--header 'x-api-key: YOUR_API_KEY'
```
#### Sample Response [#sample-response-2]
```
[
{
"request_id": "uuid",
"data_source_path": "https://your-bucket.s3.amazonaws.com/path/to/dataset.zip",
"name": "fine-tune-job-name",
"status": "AVAILABLE",
"error_message": null,
"segmind_model_path": null,
"advance_parameters": {
"steps": 10,
"learning_rate": 0.0001,
"prompt": "sample prompt",
"theme": "sample-theme"
},
"segmind_public_model": false,
"train_type": "LORA",
"source_type": "AWS_S3",
"base_model": "BASE_MODEL_NAME",
"theme": "sample-theme",
"cloud_storage_url": null,
"finetune_id": "uuid",
"model_information": {}
}
]
```
### 4. Get Fine-Tune Data Upload Pre-Signed URL [#4-get-fine-tune-data-upload-pre-signed-url]
#### Description [#description-3]
Obtain a pre-signed URL to securely upload fine-tuning data to cloud storage.
This URL allows you to upload data directly from your local system or application without needing AWS credentials.
#### Usage [#usage]
Call this endpoint to generate a temporary pre-signed URL. Use the returned URL to upload your dataset file to the specified location via a PUT request..
#### Request [#request]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/upload/pre-signed-url' \
--header 'x-api-key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "NAME_OF_THE_FILE"
}'
```
#### Sample Response [#sample-response-3]
```
{
"presigned_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip?X-Amz-Algorithm=...&X-Amz-Signature=...",
"s3_url": "https://finetune-pipeline.s3.amazonaws.com/uploads/{user_id}/{file_id}-{filename}.zip"
}
```
### 5. Update Fine-Tuned Model Access [#5-update-fine-tuned-model-access]
#### Description [#description-4]
Update the access settings of a fine-tuned model (public/private).
#### Request [#request-1]
```
curl --location --request PUT 'https://api.segmind.com/finetune/request/access-update' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'request_id="REQUEST_ID"' \
--form 'segmind_public="True"'
```
#### Sample Response [#sample-response-4]
```
200
```
### 6. Download the Fine-Tuned Safetensor File [#6-download-the-fine-tuned-safetensor-file]
#### Description [#description-5]
Generate a time-limited pre-signed URL to securely download the fine-tuned model file (.safetensors) from cloud storage.
The URL is valid for 1 hour and allows direct download without requiring AWS credentials.
#### Request [#request-2]
```
curl --location --request GET 'https://api.segmind.com/finetune/request/file/download' \
--header 'x-api-key: YOUR_API_KEY' \
--form 'cloud_storage_url="CLOUD_STORAGE_URL"'
```
#### Sample Response [#sample-response-5]
```
https://segmind-sd-models.s3.amazonaws.com/finetune/finetuned_models/job_id/filename.safetensors?AWSAccessKeyId=***&Signature=***&Expires=***
```
## Webhooks [#webhooks]
Webhooks provide a way to get real-time updates about finetuning jobs programmatically. You can register a webhook for finetuning jobs in the Developer tab on console.
Once a webhook is created, test it, by having it send a sample payload to verify delivery. Once its up, create a finetuning job to receive status updates. \
\
Events are sent to webhooks on 3 status changes:\\
1. `TRAINING_COMPLETED` : The training is completed on model, and finetuned model is available for download on the `trained_model_url`.
2. `INFERENCE_QUEUED`: Model is being deployed on Segmind inference engine.
3. `AVAILABLE`: Model is deployed, and ready for inferences on `inference_api_url`
Note: You can create only 1 webhook at a time for finetune jobs. If you want to change the webhook, please delete the old webhook before creating a new one.
# AI Assistant (https://docs.segmind.com/docs/pixelflow/guides/ai-agent-assistant)
PixelFlow's in-editor AI assistant is in beta and not yet answering questions. The per-node Refine with AI tools work today.
**Not connected yet.** The assistant panel ships in the editor and is badged **Beta**, but it isn't wired to a model — every message currently comes back with a placeholder reply along the lines of *"I'm not connected to an API yet."* Nothing on this page describes behaviour you can use today. For AI help that does work right now, see [Refine with AI](#refine-with-ai) below.
The editor includes an AI assistant — a chat panel, opened from the bubble at the bottom-right of the canvas, intended to help you plan workflows, pick models, and answer questions about what's on your canvas without leaving the editor.
## What it will help with [#what-it-will-help-with]
Once it's connected, the assistant is intended to cover:
* **Planning** — describe what you want to build ("turn a product photo into a lifestyle shot with a caption") and get a suggested node structure.
* **Model selection** — ask for models by capability ("fastest image upscaler", "an LLM that handles images") and get recommendations from Segmind's catalog.
* **Editor questions** — how to connect, fan out, pin, or publish, answered in context.
## Refine with AI [#refine-with-ai]
Two AI features are live now, and both sit on the node rather than in the chat panel. Open any model node's parameter form and you'll find:
* **Refine Prompt with AI** — rewrites the prompt in place, expanding a terse idea into something the model responds to better.
* **Refine node parameters with AI** — suggests values for the rest of the node's parameters.
These call a real model and change the node immediately, so review the result — and the node's cost estimate — before running the workflow.
Building a workflow by hand is covered in [build your first workflow](/docs/pixelflow/guides/build-your-first-workflow), and picking models is covered in [model nodes](/docs/pixelflow/nodes/model-nodes). Neither depends on the assistant.
# The Asset Library (https://docs.segmind.com/docs/pixelflow/guides/asset-library)
Every file you upload or generate is kept in one library — searchable, filterable by type, tagged by project and category, and reusable across workflows without re-uploading.
Everything you upload to PixelFlow, and everything your workflows generate,
lands in a single library attached to your account. It is the answer to
re-uploading the same product shot into four workflows, and to losing a good
generation because it only ever existed in a node's output panel.
The library is shared across surfaces — an asset saved from a workflow is
available on the model playground too, and the other way round.
## Opening it [#opening-it]
In the editor sidebar, switch from **Build** to **Assets**. The panel shows a
drop zone, a count of what you have, and a thumbnail grid. **Open asset
library** expands it to the full-screen view, which is where searching,
filtering and tagging happen.
## What lands in it [#what-lands-in-it]
* **Uploads.** Drop files onto **Upload to your library**, in the sidebar or in
the full-screen view. It takes images, video, audio, PDF and text.
* **Generations.** Save a node's output into the library so it survives the run
that made it.
Files you attach directly to a [File input node](/docs/pixelflow/nodes/input-nodes)
are stored the same way, so anything you have uploaded to a workflow is already
here.
## Finding something [#finding-something]
Three controls narrow the grid, and they combine:
| Control | What it does |
| ----------------- | ----------------------------------------------------------------------------------- |
| **Search** | Matches on the title and description you have given an asset |
| **Type** | Filters to images, video, audio or documents |
| **Filter by tag** | Filters by the tags you have applied — the list stays empty until you tag something |
## Tagging [#tagging]
Select any thumbnail and the right-hand pane opens its details. Beyond the
preview — with arrows to step through the library and a position counter — you
get:
* **Title** — a name you will recognise later, instead of *Untitled asset*.
* **Description** — what the asset actually is.
* **Tags**, under two facets: **Project** and **Category**. Each is a searchable
picker that creates the tag if it does not exist yet, so a vocabulary builds
as you go rather than needing to be planned.
Edits save automatically.
## Using an asset in a workflow [#using-an-asset-in-a-workflow]
**Add to canvas** on a selected asset drops it into the graph as an input,
wired and ready to connect. In the grid, hovering a thumbnail gives you the same
thing in one click.
## Letting an LLM node pick for itself [#letting-an-llm-node-pick-for-itself]
Model nodes that take a file can reference the library directly. An LLM node
carries an **Include asset library** toggle: turn it on and the node can choose
among your assets rather than being handed one specific file.
This is what the **Description** field is for. It is the text shared with the
model when that toggle is on — the field placeholder says as much — so a
description like *"packshot, charcoal mug, white seamless background"* is what
makes an asset findable by the model. An untitled, undescribed asset is
effectively invisible to it.
Assets are scoped to the workspace you are in. Switch workspaces at the bottom
left and you get that workspace's library — a team's assets do not appear in
your Personal account, and the reverse. See [Teams](/docs/platform/teams).
## Uploading from the API instead [#uploading-from-the-api-instead]
The library has an API-side counterpart. [Segmind
Storage](/docs/serverless-api/segmind-storage) uploads a file and returns a URL
you can pass to any model, which is the path to use when the file is coming
from your own system rather than your desktop.
## Next steps [#next-steps]
How files enter a workflow, and what each input type accepts.
Sharing a workflow with your team once its assets are in place.
# Build Your First Workflow (https://docs.segmind.com/docs/pixelflow/guides/build-your-first-workflow)
A step-by-step PixelFlow tutorial: build a text-to-image workflow from a blank canvas, run it, iterate with pinning, and get it ready to publish as an API.
In this tutorial you'll build the classic starter workflow — **prompt in, image out** — and learn the editor moves you'll use in every workflow after it.
### Create a workflow [#create-a-workflow]
In the [library](https://platform.segmind.com/pixelflow/library), click **New workflow**. You'll land on an empty canvas.
### Add a text input [#add-a-text-input]
From the sidebar, add an **Input** node. Leave it in plain-text mode and type a prompt — try `a lighthouse at dusk, dramatic sky, photographic`.
### Add an image model [#add-an-image-model]
Open the model search, look up an image-generation model, and add it. Its parameter form appears on the node — defaults are fine for a first run.
### Connect input → model [#connect-input--model]
Drag from the input node's output port to the model's prompt parameter. The port highlights when connected.
### Add an output node [#add-an-output-node]
Add an **Output** node and connect the model's image output to it.
### Run it [#run-it]
Click **Run**. Watch the model node go in‑progress, then your image appears in the output node. Note the execution time and credit cost reported on the node.
### Iterate — with pinning [#iterate--with-pinning]
Tweak the prompt and run again. When part of your graph is already right, [pin](/docs/pixelflow/guides/pinning-and-caching) those nodes — pinned nodes reuse their cached output instead of re-running, saving time and credits while you iterate on the rest.
## Where to go from here [#where-to-go-from-here]
The pattern you just built — input → model → output — scales to everything PixelFlow does:
# Fan-Out and Parallel Runs (https://docs.segmind.com/docs/pixelflow/guides/fan-out-and-parallel)
Run a model once per item with fan-out edges in PixelFlow, then gather results with collect — visual map/reduce for AI: batch images, compare models, scale prompts.
Fan-out turns one edge into many runs: when the data flowing across it is an array, the downstream nodes execute **once per item**. Collect does the reverse — it gathers a fanned-out region's per-item results back into a single array. Together they're visual map/reduce.
## Edge modes [#edge-modes]
Click an edge to set its mode:
* **None** (default) — data passes through unchanged.
* **Fan-out** — the array on this edge is unpacked; everything downstream runs once per item. Reference the current item in node fields with `{{ item }}`, or `{{ item.field }}` for arrays of objects.
* **Collect** — closes a fan-out region: per-item results are gathered into one array, and downstream nodes run once.
Fan-out and collect are mutually exclusive on a single edge — fan out on the way in, collect on the way out.
## Fanning out from an LLM [#fanning-out-from-an-llm]
A powerful pattern: have an LLM *generate* the list. When a fan-out edge originates from an LLM node, PixelFlow works out which `{{ item.* }}` fields your downstream nodes consume and asks the model for exactly those — visible on the node as a read-only **Instructions** field.
On models that support structured outputs, that same field list is also sent as an enforced response schema, so the shape is a guarantee from the provider rather than a request the model can drift from. Each key is typed from the field it feeds and carries that field's own description, and a fixed-choice field — a dropdown such as **Aspect ratio** — restricts the model to that field's actual options. Models without structured-output support still receive the written instructions.
```
Input (topic)
→ LLM "write 5 image prompts about {{ input_1 }}"
→ fan-out → image model (5 parallel runs)
→ collect → Output (gallery of 5)
```
## Comparing models in parallel [#comparing-models-in-parallel]
Fan-out isn't the only way to parallelize — a single output can also feed **multiple different nodes** directly. Wire one prompt input into three different image models side by side and run once to compare them on identical input.
## Use cases [#use-cases]
* **Batch processing** — caption every image in a list, upscale a folder's worth of assets
* **Prompt sweeps** — generate N variants and pick the best
* **Model comparison** — same input across competing models
* **Pipeline scaling** — publish the workflow [as an API](/docs/pixelflow/publish-as-api) and the fan-out scales with the array your callers send
# LLM Chat History (https://docs.segmind.com/docs/pixelflow/guides/llm-chat-history)
The Chat History input on PixelFlow's LLM nodes is not yet carrying conversation context between turns. What the connection does today, and what to use instead.
**Not carrying context yet.** You can wire one LLM node's output into another's **Chat History** input, the edge saves, and the receiving node reports *Chat History · Connected* — but the earlier turn is not currently included in the request sent to the model. A second node asked "what did you just suggest?" answers that it can't see any previous suggestion. Treat everything below as the intended design, not current behaviour, and see [what to do instead](#what-to-do-in-the-meantime).
Chat history is intended to let LLM nodes remember previous turns: connect one LLM node's output to the next node's **Chat History** input and the conversation context carries forward — the foundation for chatbots, agents, and any multi-turn dialogue.
## How it is meant to work [#how-it-is-meant-to-work]
Language model nodes expose a **Chat History** input alongside the prompt:
1. **First turn** — the first LLM node takes your prompt and generates a response. No history is connected.
2. **Carrying context** — connect that node's output to the next LLM node's Chat History input. The full exchange (prompt + response) travels with it.
3. **Subsequent turns** — each node in the chain receives the entire conversation so far, so responses stay coherent across turns.
## What to do in the meantime [#what-to-do-in-the-meantime]
The connection is real and the graph runs — only the context is missing — so anything that doesn't depend on the model *remembering* still works:
* **Pass the previous answer as text.** Wire the first node's output into the second node's **prompt** rather than its Chat History, and write the prompt so it includes what you need carried over. The earlier response then genuinely reaches the model, because it is part of the prompt.
* **Keep single-turn steps single-turn.** Draft-then-critique pipelines work fine when each step restates what it is critiquing.
## Branching conversations [#branching-conversations]
Connect one LLM node's output to the Chat History input of *several* downstream nodes and each is intended to become an independent branch of the conversation — same shared context, different continuations. Planned uses:
* A/B test prompts against identical context
* Explore multiple dialogue paths side by side
* Compare different models continuing the same conversation
## Use cases [#use-cases]
Once context is carried, chat history is aimed at:
* **Chatbots and assistants** that remember the conversation
* **Multi-step reasoning** — draft, critique, revise as separate turns
* **Content pipelines** — interview-style generation where each question builds on previous answers
* **Education tools** — adaptive dialogues that respond to earlier exchanges
[Fan-out and parallel](/docs/pixelflow/guides/fan-out-and-parallel) does work today, and covers the comparison and A/B patterns above without depending on chat history.
# Pinning and Caching (https://docs.segmind.com/docs/pixelflow/guides/pinning-and-caching)
Pin nodes in PixelFlow to cache their output across runs — skip expensive re-execution, iterate faster, and save credits while you refine a workflow.
Pinning caches a node's output. A pinned node is not re-executed on the next run — its previous output is reused and fed to downstream nodes. For expensive or slow models, this is the difference between iterating in seconds and re-paying for the whole pipeline on every tweak.
## How it works [#how-it-works]
Pinning applies to **model nodes**. The pin isn't drawn on the node itself — it lives in the hover action bar, the strip of controls that appears above a node when your cursor is over it. Input, output, and notes nodes have no pin, because there is no model call to skip. Click it to toggle:
* **Pinned** — the icon highlights. On the next run the node is skipped and its most recent successful output is used.
* **Unpinned** — the node executes as usual.
Only nodes with a successful previous run can serve a cached result.
With a node selected, P toggles its pin without reaching for the action bar.
### Running a workflow that contains pinned nodes [#running-a-workflow-that-contains-pinned-nodes]
Running the whole workflow doesn't silently reuse the cache — PixelFlow asks first:
> **Pinned nodes have saved outputs.** 1 pinned node has a saved output. Use it as-is, or re-run everything including pinned nodes?
Three answers: **Use saved outputs** honours the pins, **Re-run everything** ignores them and re-executes the pinned nodes too, and **Cancel** aborts the run. So a pin is the default answer to that question rather than an unconditional skip — useful when you want one fresh run without unpinning and re-pinning a stack of nodes.
## A pin holds until you release it [#a-pin-holds-until-you-release-it]
Pinning does not track staleness, and nothing invalidates the cache for you. A pinned node keeps serving its saved output until you intervene, in one of two ways:
* **Unpin it** — it runs again on the next execution.
* **Answer "Re-run everything"** at the dialog above — a one-off, which leaves the pin in place for later runs.
While a node is pinned its **parameters are read-only** and its own **Run** button is replaced by *Unpin node*, so you cannot edit a pinned node's configuration without unpinning first.
**Editing an upstream node does not release the pin.** Change the prompt feeding a pinned model and it keeps its old output — the workflow will happily run with the new prompt upstream and the stale image downstream. If you have changed anything that feeds a pinned node and you want that change reflected, unpin it or choose **Re-run everything**.
## When to pin [#when-to-pin]
* **Iterative development** — lock in the parts of the workflow that already work and iterate on the rest.
* **Cost control** — don't re-pay for a 4K upscale while you fiddle with a caption model downstream.
* **Speed** — skip slow video or upscaling nodes when their input hasn't changed.
**Run node** — the ▶ in a node's hover action bar — pairs well with pinning: it executes only the selected node, reusing whatever its upstream already produced — the cheapest possible way to test one step. See [the editor](/docs/pixelflow/the-editor#running-workflows).
# Sharing and Collaboration (https://docs.segmind.com/docs/pixelflow/guides/sharing-and-collaboration)
Share PixelFlow workflows with teammates by email or team, duplicate workflows, and export them as reusable templates for your organization.
Workflows don't have to live alone in your library — share them with individuals, your whole team, or export them as templates anyone can clone.
## Share by email or team [#share-by-email-or-team]
Open the **Share** dialog from the editor's title bar:
* **By email** — invite specific users; they receive a notification and the workflow appears in their library.
* **By team** — share with your Segmind [team](/docs/platform/teams) so every member gets access.
Workflows save automatically, and a save is rejected if someone else has saved since you loaded the page — the first edit wins, and the second editor has to reload and redo. Keep one editor open per workflow. See [auto-save and version conflicts](/docs/pixelflow/the-editor#auto-save-and-version-conflicts).
## Duplicate a workflow [#duplicate-a-workflow]
Duplicate from the library (or the editor) to get an independent copy — useful for trying a risky restructure without touching the original, or for using a finished workflow as the starting point for the next one.
## Export as a template [#export-as-a-template]
Turn a workflow into a reusable template others can clone:
Templates carry the graph structure — nodes, connections, parameters — so the recipient starts from a working pipeline instead of a blank canvas. Learn more in [templates](/docs/pixelflow/templates).
# Node Types (https://docs.segmind.com/docs/pixelflow/nodes)
The five node types in PixelFlow — input, model, output, utility, and notes — and how data flows between them through ports and edges.
Workflows are built from five node types. Each does one job; edges move data between them.
## The node types [#the-node-types]
| Node | What it does |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| [Input](/docs/pixelflow/nodes/input-nodes) | Supplies values to the graph — text, numbers, JSON, booleans, or uploaded files (images, video, audio), including inpainting masks. |
| [Model](/docs/pixelflow/nodes/model-nodes) | Calls any model in Segmind's catalog — image, video, audio, and language models — with a parameter form generated from the model's schema. |
| [Output](/docs/pixelflow/nodes/output-nodes) | Displays results, automatically rendering images, video, audio, text, or 3D. |
| [Utility](/docs/pixelflow/nodes/utility-nodes) | Transforms data between models: concatenate text, resize images, split text, join arrays. |
| [Notes](/docs/pixelflow/nodes/notes-nodes) | Sticky notes for documenting the workflow. Notes never execute and are stripped from published APIs. |
## Ports and connections [#ports-and-connections]
Data enters a node through **input ports** (left side) and leaves through **output ports** (right side). Drag from an output port to an input port to create an edge. A single output can feed any number of downstream inputs.
Some models expose more than one output port — for example, a video model may offer both the video and its last frame as separate outputs you can wire independently.
## Choosing the right node [#choosing-the-right-node]
* Want a value you can change per run (and expose as an [API parameter](/docs/pixelflow/publish-as-api))? Use an **input node** rather than typing the value directly into a model's form.
* Need glue between two models — like combining two texts into one prompt? Reach for a [utility node](/docs/pixelflow/nodes/utility-nodes) before adding another model.
* Anything a future reader (or teammate) might ask about? Leave a [note](/docs/pixelflow/nodes/notes-nodes).
# Input Nodes (https://docs.segmind.com/docs/pixelflow/nodes/input-nodes)
Feed data into PixelFlow workflows: text, number, dropdown, multi-select, JSON, and boolean inputs, plus file uploads with an inline inpainting mask tool.
Input nodes supply the values your workflow runs on. They come in two flavors — **text** and **file** — each with several modes.
## Finding the Advanced controls [#finding-the-advanced-controls]
A node's mode, and everything that makes it an API parameter, live under an **Advanced** disclosure at the bottom of the node:
* **Input Type** — the mode. On a file input the same control is labelled **File Type**.
* **Use as API Input** — whether callers can set this input on the published API.
* **API Key Name** — the JSON field name they send it as.
**Creative mode hides all three.** The editor has two modes, switched with the toggle in the top bar: **Creative** (the sparkle, the default) and **Pro**. In Creative mode input and output nodes render without an Advanced section at all. If you're looking for the mode picker and there's no sign of it on the node, in its action bar, or in the sidebar, flip that toggle to Pro.
## Text inputs [#text-inputs]
| Mode | Use it for |
| ---------------- | ---------------------------------------------- |
| **Plain text** | Prompts and free-form strings |
| **Number** | Numeric parameters, with optional min/max/step |
| **Dropdown** | One choice from a fixed list you define |
| **Multi-select** | Several choices from a fixed list |
| **JSON** | Structured payloads passed through as-is |
| **Boolean** | On/off switches |
Dropdown and multi-select options are defined on the node, which keeps published APIs constrained to valid values.
## File inputs [#file-inputs]
File inputs accept uploads by drag-and-drop or file picker:
| Mode | Accepts |
| --------------------------------- | ------------------------------------------------------------------------------ |
| **Any file** | Anything a downstream model can consume — images, video, audio, PDFs, and more |
| **Image** / **Video** / **Audio** | Hints the expected media type |
| **Inpainting** | An image plus a mask you paint directly in the node |
Uploaded files are stored in your asset gallery and passed downstream as URLs.
### The inpainting mask tool [#the-inpainting-mask-tool]
Set **File Type** to **Inpainting** and the node's drop zone narrows to **Upload image** — PNG, JPG, or WebP. There is no masking canvas yet at this point, and that is expected: a mask needs a picture to paint on.
Once the image is in, the node grows a **Draw Mask** button. It opens the **Mask Editor** inline on the node — not a modal, not a separate screen — showing your image under the instruction *"Click and drag to paint mask areas"*. Brush over the regions you want the model to regenerate, then **Apply** to keep the mask, or **Cancel** to discard it and leave the image untouched.
An inpainting file input has **two output ports** rather than one: the image and the mask leave the node separately. Wire each to the matching parameter of an inpainting model.
## Key names: exposing inputs as API parameters [#key-names-exposing-inputs-as-api-parameters]
Give an input node a **key name** to make it a named parameter of your [published API](/docs/pixelflow/publish-as-api) — the key name becomes the JSON field callers send. Inputs without a key name keep their canvas value when the workflow runs as an API.
Prefer input nodes over hard-coding values in model forms for anything you'll want to change per run — they're what become your API's parameters when you publish.
# Model Nodes (https://docs.segmind.com/docs/pixelflow/nodes/model-nodes)
Add any Segmind model to a workflow: search the catalog, configure parameters from the model's schema, see cost estimates, and send images to vision LLMs.
Model nodes are the heart of every workflow — each one calls a model from Segmind's catalog: image generation and editing, video, audio, and large language models.
## Adding a model [#adding-a-model]
Open the model search in the sidebar and type a model's name. Pick a result to drop it onto the canvas as a configured node.
## The parameter form [#the-parameter-form]
Each model node renders a form generated from the model's schema — the same parameters documented on the model's API page. Every parameter can be:
* **Set directly** in the form (a fixed value), or
* **Wired from a connection** — drag an edge from an upstream node onto the parameter's port, or
* **Composed with template expressions** — reference upstream outputs inside text fields, e.g. `A photo of {{ input_1 }}, studio lighting`.
## Cost estimates [#cost-estimates]
Model nodes show an estimated credit cost before you run them, so the price of a run is never a surprise. Actual usage appears in your [billing dashboard](/docs/platform/pricing-and-billing).
## LLMs and vision inputs [#llms-and-vision-inputs]
Language model nodes support:
* **System prompts and chat history** — chain LLM nodes into multi-turn conversations. See [LLM chat history](/docs/pixelflow/guides/llm-chat-history).
* **Vision inputs** — connect image inputs (or upstream image outputs) to vision-capable LLMs to describe, caption, or reason about images. Multiple images are supported.
## Outputs [#outputs]
Model nodes display their results inline — image galleries, video and audio players, text. Outputs flow onward through the node's output ports; some models expose multiple ports (e.g. a video plus its final frame).
## Status, time, and pinning [#status-time-and-pinning]
While running, nodes show live status (in&8209;progress, success, error) and report execution time when done. Successful nodes can be **pinned** to cache their output across runs — see [pinning and caching](/docs/pixelflow/guides/pinning-and-caching).
Want the same model with different settings side-by-side? Duplicate the node from its action bar and [fan out](/docs/pixelflow/guides/fan-out-and-parallel) the same input to both.
# Notes (https://docs.segmind.com/docs/pixelflow/nodes/notes-nodes)
Document workflows on the canvas with resizable, color-coded sticky notes. Notes never execute and are stripped from published APIs.
Notes are sticky notes for the canvas — document what a section of the workflow does, leave instructions for teammates, or mark TODOs.
## Working with notes [#working-with-notes]
* **Add** a note with **Add Note**, the last button in the canvas toolbar, then type directly into it.
* **Color** it — five colors (yellow, blue, green, pink, gray) help group related sections visually.
* **Resize and move** notes freely; park a large note behind a cluster of nodes to visually group a stage of the pipeline.
Notes are purely visual: they never execute, cost nothing, and are automatically stripped when you [publish the workflow as an API](/docs/pixelflow/publish-as-api).
You can also attach a short note to an individual node from its action bar — handy for "why is this parameter 0.35?"-style breadcrumbs.
# Output Nodes (https://docs.segmind.com/docs/pixelflow/nodes/output-nodes)
Display workflow results with output nodes — automatic rendering for images, video, audio, text, and 3D — and name them to define your API's response fields.
Output nodes are where results land. Connect any node's output to an output node and it renders the data in the right format automatically.
## Automatic format detection [#automatic-format-detection]
Output nodes detect what they receive:
* **Images** — displayed as a zoomable gallery
* **Video** — inline player
* **Audio** — inline player
* **Text** — rendered inline
* **3D** — interactive viewer
Output nodes are resizable, so you can give a hero image more room or tuck a debug text output into a corner.
## Wiring specific outputs [#wiring-specific-outputs]
When an upstream model exposes multiple output ports — say, a generated video and its last frame — each port can feed its own output node, so you can inspect both.
## Key names: defining API responses [#key-names-defining-api-responses]
Like [input nodes](/docs/pixelflow/nodes/input-nodes#key-names-exposing-inputs-as-api-parameters), output nodes take a **key name**. When you [publish the workflow as an API](/docs/pixelflow/publish-as-api), each named output becomes a field in the API response. A workflow can return several named outputs — for example, an image *and* the prompt an LLM wrote for it.
# Utility Nodes (https://docs.segmind.com/docs/pixelflow/nodes/utility-nodes)
Text concatenation, image resize, text split, and array join are implemented in the PixelFlow engine but cannot yet be added from the editor. What they will do, and what to use instead.
**Not addable from the editor yet.** These four node types run in the PixelFlow engine — a graph that already contains them executes correctly — but the editor currently offers no way to add one to a canvas. They aren't in the node sidebar, the model search, the Utilities category, or the quick-add palette. Everything below describes intended behaviour. For what to use today, see [alternatives](#alternatives-that-work-today).
Utility nodes transform data between models — the plumbing that makes multi-model workflows fit together. They are designed to run instantly and consume no credits, since no model call is involved.
## Planned utilities [#planned-utilities]
### Text Concatenation [#text-concatenation]
Joins incoming text values into one string. Use it to combine a fixed style prefix with a user prompt, or merge outputs from several LLM nodes into a single document.
### Image Resize [#image-resize]
Resizes an image before it reaches the next model — useful when a downstream model expects specific dimensions, or to cut upload time and cost for large source images.
### Text Split [#text-split]
Splits one text into parts — for instance, breaking an LLM's list output into individual items for downstream processing.
### Array Join [#array-join]
Joins an array of values back into one — the natural companion to Text Split or a [fan-out](/docs/pixelflow/guides/fan-out-and-parallel) region when you want a single combined result.
## Chaining utilities [#chaining-utilities]
Utilities are meant to compose like any other node. The pattern they're built for:
```
LLM (writes 3 prompt variants)
→ Text Split (one per line)
→ fan-out → image model (runs per variant)
→ collect → Array Join
→ Output
```
## Alternatives that work today [#alternatives-that-work-today]
* **Fan-out and collect themselves work.** Only the utility nodes are missing from the chain above — see [fan-out and parallel](/docs/pixelflow/guides/fan-out-and-parallel) for the patterns that don't need a splitter or joiner.
* **Server-side media utilities are available** in the sidebar's **Utilities** category — `Image resizer`, `Video Concatenate`, `NSFW Checker` and others. These are hosted rather than free local transforms, so they cost credits and add a network round trip, but they cover the common image and video cases.
* **The same operations are on the API.** Compositing a multi-track edit, splitting a video into clips, pulling a still frame, making a GIF and converting formats all have endpoints of their own — see [Video Editing](/docs/serverless-api/video-editing). They run on the standard async contract, so a workflow can call one the way it calls any other model.
* **An LLM node can do light text shaping** — concatenating, splitting, or reformatting — at the price of a model call.
# PixelFlow as a ComfyUI Alternative (https://docs.segmind.com/docs/pixelflow/use-cases/comfyui-alternative)
A cloud ComfyUI alternative with no GPU, no install, and no Python: build node-based AI workflows in the browser and publish them as production REST APIs.
If you like ComfyUI's node-based way of building AI pipelines but not the GPU bills, Python environments, and custom-node maintenance, PixelFlow gives you the same graph mental model as a hosted service — running in the browser, backed by Segmind's model catalog, with one-click [publishing to a REST API](/docs/pixelflow/publish-as-api).
## PixelFlow vs. ComfyUI [#pixelflow-vs-comfyui]
| | PixelFlow | ComfyUI |
| --------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
| Setup | None — sign in and build | Local install, Python env, model checkpoints |
| Hardware | Segmind's cloud GPUs, pay per call | Your GPU (or a rented one, always-on) |
| Models | Hosted catalog: image, video, audio, LLMs | Checkpoints and custom nodes you manage |
| Updating models | Automatic — catalog is maintained for you | Manual downloads, version conflicts |
| Workflow → API | Built in, one click, versioned | Requires extra tooling or wrappers |
| Collaboration | [Share by email or team](/docs/pixelflow/guides/sharing-and-collaboration) | Export/import JSON files |
| Extensibility | Catalog models + [utilities](/docs/pixelflow/nodes/utility-nodes) + [fan-out](/docs/pixelflow/guides/fan-out-and-parallel) | Custom Python nodes |
**When ComfyUI is the better fit:** you need custom Python nodes, exotic community extensions, or fully offline/air-gapped operation. PixelFlow trades that low-level control for zero maintenance and a production API path.
## The familiar parts [#the-familiar-parts]
Coming from ComfyUI, you already know how to use PixelFlow:
* **Nodes and edges** — same graph model. [Input](/docs/pixelflow/nodes/input-nodes) → [model](/docs/pixelflow/nodes/model-nodes) → [output](/docs/pixelflow/nodes/output-nodes), connected by dragging between ports.
* **Inpainting** — paint masks [directly in the input node](/docs/pixelflow/nodes/input-nodes#the-inpainting-mask-tool).
* **Caching** — [pinning](/docs/pixelflow/guides/pinning-and-caching) plays the role of ComfyUI's cached executions, with explicit control.
* **Templates** — like sharing workflow JSONs, but [hosted and cloneable](/docs/pixelflow/templates).
## The parts ComfyUI doesn't have [#the-parts-comfyui-doesnt-have]
* **A real API for every workflow** — publish and get a versioned REST endpoint with [submit/poll/fetch semantics](/docs/pixelflow/api-reference), auth, and code samples.
* **All modalities in one graph** — image, video, audio, and LLM nodes from one [catalog](/docs/get-started/models), including [LLM chains with chat history](/docs/pixelflow/guides/llm-chat-history).
* **Visual map/reduce** — [fan-out and collect](/docs/pixelflow/guides/fan-out-and-parallel) for batch processing without custom batch nodes.
* **Cost transparency** — every node shows its estimated cost before you run.
## Frequently asked questions [#frequently-asked-questions]
### Is PixelFlow a ComfyUI alternative? [#is-pixelflow-a-comfyui-alternative]
Yes — PixelFlow offers the same node-based workflow building in the browser, with hosted models instead of local checkpoints, so there's no GPU, Python environment, or custom-node maintenance.
### Do I need a GPU to use PixelFlow? [#do-i-need-a-gpu-to-use-pixelflow]
No. Every model runs on Segmind's cloud infrastructure. You pay per model call with credits instead of renting or owning GPU hardware.
### Can I turn a workflow into an API like ComfyUI-as-an-API setups? [#can-i-turn-a-workflow-into-an-api-like-comfyui-as-an-api-setups]
Yes, natively. Any PixelFlow workflow can be published as a versioned REST endpoint in one click — no serverless wrappers or deployment tooling required. See [publish as an API](/docs/pixelflow/publish-as-api).
### Can I import my ComfyUI workflows? [#can-i-import-my-comfyui-workflows]
There is no direct ComfyUI JSON import. Most graphs translate naturally though: checkpoints map to hosted model nodes, LoadImage to file inputs, and SaveImage to output nodes. [Build your first workflow](/docs/pixelflow/guides/build-your-first-workflow) covers the moves.
## Get started [#get-started]
# No-Code AI Pipelines (https://docs.segmind.com/docs/pixelflow/use-cases/no-code-ai-pipeline)
Build no-code AI pipelines that chain image, video, audio, and language models on a visual canvas — then ship each pipeline as a REST API your team can call.
A no-code AI pipeline chains models together — an LLM writes a prompt, an image model renders it, an upscaler finishes it — without writing orchestration code. In PixelFlow the pipeline *is* the picture: nodes are models, edges are data flow, and the whole thing can [ship as a REST API](/docs/pixelflow/publish-as-api).
## Build one in minutes [#build-one-in-minutes]
1. **Pick your models** — search Segmind's catalog and drop [model nodes](/docs/pixelflow/nodes/model-nodes) onto the canvas: image, video, audio, or language models, mixed freely.
2. **Connect the flow** — drag edges between nodes. [Utilities](/docs/pixelflow/nodes/utility-nodes) handle the glue: combining texts, resizing images, splitting and joining arrays.
3. **Run and refine** — execute the graph, watch each stage complete, [pin](/docs/pixelflow/guides/pinning-and-caching) what works, iterate on what doesn't.
New to the editor? Start with [getting started](/docs/pixelflow/getting-started) or clone a [template](/docs/pixelflow/templates).
## Pipelines that earn their keep [#pipelines-that-earn-their-keep]
* **Content production** — LLM drafts copy → image model renders art → resize for each placement.
* **Catalog processing** — [fan out](/docs/pixelflow/guides/fan-out-and-parallel) over product images: background removal → relight → upscale, in parallel per image.
* **Conversational generation** — [LLM chains with chat history](/docs/pixelflow/guides/llm-chat-history) that interview the user, then generate.
* **Multi-modal assembly** — script (LLM) → narration (audio model) → visuals (video model), one graph.
## From canvas to production [#from-canvas-to-production]
The pipeline you sketch is the pipeline you ship. Publishing creates a versioned REST endpoint — JSON in, JSON out, [async submit/poll/fetch](/docs/pixelflow/api-reference) — so the no-code pipeline slots into a very-much-code product. Builders iterate on the canvas; the endpoint contract stays stable for the engineers calling it.
## Frequently asked questions [#frequently-asked-questions]
### What is a no-code AI pipeline? [#what-is-a-no-code-ai-pipeline]
A sequence of AI models connected so one model's output feeds the next — built on a visual canvas instead of in code. In PixelFlow, nodes are models and edges carry the data.
### Can a no-code pipeline still be used by developers? [#can-a-no-code-pipeline-still-be-used-by-developers]
Yes — that's the point of [publishing](/docs/pixelflow/publish-as-api). The pipeline is built visually, then exposed as a standard REST API with JSON in and JSON out, like any backend service.
### What models can I chain in PixelFlow? [#what-models-can-i-chain-in-pixelflow]
Anything in [Segmind's catalog](/docs/get-started/models): image generation and editing, video, audio, and LLMs — in any combination within one graph.
### How much does it cost to run a pipeline? [#how-much-does-it-cost-to-run-a-pipeline]
You pay per model call in Segmind credits. Each node shows an estimated cost before you run, and [pinning](/docs/pixelflow/guides/pinning-and-caching) lets you skip re-running finished nodes while iterating. See [pricing and billing](/docs/platform/pricing-and-billing).
## Get started [#get-started]
# Build a Text-to-Image API (https://docs.segmind.com/docs/pixelflow/use-cases/text-to-image-api-workflow)
Build a text-to-image API without writing model code: wire a prompt input to an image model in PixelFlow, publish it, and call your endpoint from any app.
The fastest way to put image generation behind your own API: build the pipeline visually, publish it, and call it from your app. You get a stable endpoint you control — swap models or add steps later without changing a line of caller code.
## Build the workflow [#build-the-workflow]
### Wire prompt → model → output [#wire-prompt--model--output]
Create a workflow with a text [input node](/docs/pixelflow/nodes/input-nodes), an image model, and an [output node](/docs/pixelflow/nodes/output-nodes) — the full walkthrough is in [build your first workflow](/docs/pixelflow/guides/build-your-first-workflow).
### Name the API fields [#name-the-api-fields]
Set the input node's key name to `prompt` and the output node's to `image`. Those become your API's request and response fields.
### Publish [#publish]
Click **Publish** — you get a versioned endpoint and code samples. Details in [publish as an API](/docs/pixelflow/publish-as-api).
## Call it from code [#call-it-from-code]
```python
import os, time, json, requests
headers = {"x-api-key": os.environ['SEGMIND_API_KEY']}
submit = requests.post(
"https://api.segmind.com/workflows/v2/",
headers=headers,
json={"prompt": "a lighthouse at dusk, dramatic sky"},
).json()
while True:
s = requests.get(submit["poll_url"], headers=headers).json()
if s["status"] in ("COMPLETED", "FAILED"):
break
time.sleep(3)
result = requests.get(submit["response_url"], headers=headers).json()
print(result["images"][0]["url"])
```
Full request/response shapes, JavaScript and cURL versions, and error handling are in the [API reference](/docs/pixelflow/api-reference).
## Why a workflow instead of calling the model directly? [#why-a-workflow-instead-of-calling-the-model-directly]
You *can* call any single model via the [AI Gateway](/docs/serverless-api). A workflow earns its keep when the endpoint should be **yours**:
* **Swap models without breaking callers** — re-publish with a different model behind the same contract.
* **Add steps invisibly** — bolt an upscaler or safety checker onto the pipeline; callers still send `prompt`, get `image`.
* **Encode your defaults** — style prefixes via [text concatenation](/docs/pixelflow/nodes/utility-nodes), fixed negative prompts, tuned parameters — baked into the workflow, not duplicated across client code.
* **Constrain inputs** — dropdown inputs publish as enumerated parameters, so callers can only send valid values.
## Variations [#variations]
* **Style presets** — a [dropdown input](/docs/pixelflow/nodes/input-nodes) (`photographic`, `anime`, `watercolor`) concatenated into the prompt.
* **Prompt enhancement** — an LLM node rewrites the user's prompt before the image model sees it.
* **Batch generation** — accept an array and [fan out](/docs/pixelflow/guides/fan-out-and-parallel) to generate per item.
# Console Release Notes (April 7-11, 2025) (https://docs.segmind.com/docs/platform/release-notes/2025-04-18-console)
Segmind console updates for April 7 to 11, 2025: a reworked date picker across the app, a branded 404 page, and fixes to team switching inside workflows.
## 1. Date Picker UX Update [#1-date-picker-ux-update]
* **What's new:** Every date field in the console moved to a reworked date picker.
* **Impact:** Consistent date selection wherever you filter by time — transaction history, generation logs, usage statistics and API monitoring.
* **Released:** April 7-9, 2025
## 2. Branded 404 Page [#2-branded-404-page]
* **What's new:** A custom 404 page replaces the default error screen, with a redirect back into the app.
* **Impact:** A missing or moved URL now lands somewhere you can navigate out of.
* **Released:** April 10-11, 2025
## 3. Workflow Navigation Fixes [#3-workflow-navigation-fixes]
* **What's new:** Switching teams while inside a workflow now works correctly, and the workflow buttons on the dashboard were updated.
* **Impact:** Changing team no longer strands you on a workflow route, and workflows are easier to reach from the dashboard.
* **Released:** April 8-9, 2025
# Segmind Website Release Notes (April 5-18, 2025) (https://docs.segmind.com/docs/platform/release-notes/2025-04-18-segmind-website)
Segmind website updates for April 5 to 18, 2025: rebuilt Algolia search, partner integrations, dynamic pricing, and model playground improvements.
## 1. Search System Overhaul [#1-search-system-overhaul]
* **What's new:** Site search was rebuilt, and the list pages it returns work properly on mobile.
* **Impact:** More accurate, more responsive results when looking for a model.
* **Released:** April 8, 2025
## 2. Partner Integration Enhancements [#2-partner-integration-enhancements]
* **What's new:** Dedicated pages for partner models — Ideogram, MiniMax, ElevenLabs, OpenAI, Google, Kling, Luma and Runway — with fuller descriptions.
* **Impact:** A direct route to a given provider's models rather than filtering the whole catalogue.
* **Released:** April 14, 2025
## 3. Dynamic Pricing System [#3-dynamic-pricing-system]
* **What's new:** Pricing tables are generated from the models themselves rather than written out by hand.
* **Impact:** Published prices track what is actually offered, and a new model arrives with its pricing already correct.
* **Released:** April 8, 2025
## 4. Model Playground Improvements [#4-model-playground-improvements]
* **What's new:** Google Translate support, Ideogram colour palettes, improved audio handling, and mask support for the SegFit model.
* **Impact:** More model types are fully usable from the playground.
* **Released:** April 14-18, 2025
## 5. UI/UX Enhancements [#5-uiux-enhancements]
* **What's new:** Model type tags are colour-coded, navigation responsiveness was fixed, and the explore page's back button behaves.
* **Impact:** Easier to tell model types apart at a glance, and browsing no longer loses your place.
* **Released:** April 8-17, 2025
## 6. API Documentation Updates [#6-api-documentation-updates]
* **What's new:** Documentation for API edge cases, and request bodies that update without reloading the page.
* **Impact:** Clearer guidance on how the API behaves outside the happy path.
* **Released:** April 9-10, 2025
## 7. Routing Fixes [#7-routing-fixes]
* **What's new:** A conflicting partner route was removed and the affected redirects corrected.
* **Impact:** Fixes 404s that partner links were hitting.
* **Released:** April 17, 2025
# Segmind Website Release Notes (April 5-19, 2025) (https://docs.segmind.com/docs/platform/release-notes/2025-04-19-website)
Segmind website updates through April 19, 2025: a redesigned video model explorer, shareable playground URLs, an examples manager, and new navigation.
## 1. Video Model Explorer Enhancement [#1-video-model-explorer-enhancement]
* **What's new:** The video model explorer was redesigned around URL-based navigation, so a view can be linked to and the browser's back and forward buttons behave.
* **Impact:** You can share a link to exactly what you were looking at, and browsing no longer loses your place.
* **Released:** April 17, 2025
## 2. Playground Media Handling Improvements [#2-playground-media-handling-improvements]
* **What's new:** Broader support for images, video and audio in the playground, plus colour-palette selection on the models that accept it.
* **Impact:** More model types are usable directly from the playground without downloading and re-uploading files.
* **Released:** April 16, 2025
## 3. Examples Management System [#3-examples-management-system]
* **What's new:** A model's output can be promoted to an example, with clearer errors and easier navigation between examples.
* **Impact:** Better curated examples on model pages, which is usually the fastest way to judge whether a model suits your use case.
* **Released:** April 15, 2025
## 4. Models Page Restructuring [#4-models-page-restructuring]
* **What's new:** Filtering by model type — image, video, audio, LLM — plus a featured section, on a faster-loading page.
* **Impact:** Narrow the catalogue to the kind of model you actually want instead of scrolling all of it.
* **Released:** April 14, 2025
## 5. Homepage Visual Components [#5-homepage-visual-components]
* **What's new:** Featured models and workflows now appear in an auto-scrolling carousel with hover effects.
* **Impact:** More of the catalogue is visible from the homepage, with direct links through to each item.
* **Released:** April 13, 2025
## 6. Navigation System Overhaul [#6-navigation-system-overhaul]
* **What's new:** A rebuilt navigation bar with reorganised dropdowns, team switching, and proper responsive behaviour.
* **Impact:** The same navigation on desktop and mobile, with fewer clicks to the pages people use most.
* **Released:** April 12, 2025
## 7. Google Translate Integration [#7-google-translate-integration]
* **What's new:** Google Translate support across the site.
* **Impact:** Site content can be read in your own language.
* **Released:** April 18, 2025
## 8. Error Handling and Performance [#8-error-handling-and-performance]
* **What's new:** A failing part of a page is now contained rather than taking the page down with it, and loading states show placeholders instead of blank space.
* **Impact:** Fewer dead-end error screens, and clearer feedback while a page is still loading.
* **Released:** April 11-15, 2025
## 9. Route Management Fixes [#9-route-management-fixes]
* **What's new:** A conflicting partner route was removed and the affected redirects corrected.
* **Impact:** Fixes 404s that partner links were hitting, and sends the old URLs somewhere useful.
* **Released:** April 17, 2025
# Segmind Release Notes (May 19–25, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-05-24-weekly)
Segmind updates for May 19 to 25, 2026: a new Observability dashboard for API health and cost, a team usage summary API, and auto-recharge changes.
## 1. New Observability Dashboard — API Health & Cost Analytics [#1-new-observability-dashboard--api-health--cost-analytics]
* **What's new:** A new **Observability** section is live on [platform.segmind.com](https://platform.segmind.com). It includes two dashboards: **API Health** (`/api-health`) showing real-time p50/p95/p99 latency, error breakdown by category, and recent failure history; and **Cost Analytics** (`/cost-analytics`) showing consolidated spend across all models, projections, and a CSV export for your records.
* **Impact:** You can now monitor how your API usage is performing and track spending — all in one place, without any additional calls. Existing bookmarks to `/usage` or `/metrics` automatically redirect to the new Cost Analytics page.
* **Released:** May 24–26, 2026
## 2. Team Usage Summary API [#2-team-usage-summary-api]
* **What's new:** Team account Owners and Admins can now query per-member spending via `GET /inference-request/team-usage-summary`. Supports grouping by `user`, `model`, or `user_model`, filterable by date range.
* **Impact:** If your team shares a wallet, you can now see exactly who is spending what and on which models — useful for internal cost tracking and quota management. Member-role API keys receive a 403 by design.
* **Released:** May 23, 2026
## 3. Accurate HTTP Error Codes for Google/Vertex Models [#3-accurate-http-error-codes-for-googlevertex-models]
* **What's new:** Veo 2, Veo 3, Veo 3.1, Veo 3.1-fast, Veo 3.1-lite, Lyria 2, and Imagen-backed models now return meaningful HTTP status codes for client-side errors — 400 for invalid inputs, 403 for access issues, 429 for rate limits, and so on.
* **Impact:** Debugging failed requests is now much easier. If the model returns a 400 with a clear message (e.g. "Provided image is not valid"), that's a signal about your input — not a platform outage. Previously these showed up as generic 500 errors.
* **Released:** May 26, 2026
## 4. Simple Prompt Input for LLM Endpoints [#4-simple-prompt-input-for-llm-endpoints]
* **What's new:** GPT-5.5 (`/v2/gpt-5.5`) and Gemini 2.5 Flash (`/v2/gemini-2.5-flash`) now accept a bare `{"prompt": "your text"}` body in addition to the full `messages` array format.
* **Impact:** Simpler integrations just work out of the box. If you were hitting 400 or 406 errors using the prompt shorthand this week, those are fully resolved — no changes needed on your end.
* **Released:** May 27, 2026
## 5. Auto-Recharge Billing Reliability [#5-auto-recharge-billing-reliability]
* **What's new:** Auto-recharge billing now processes with multi-layer safeguards to prevent duplicate charges.
* **Impact:** Wallet top-ups are reliable. If you experienced unexpected duplicate charges around May 23, those were a temporary issue that has been fully resolved. No action is required from your side — reach out to support if you'd like a review of your billing history from that window.
* **Released:** May 27, 2026
# Segmind Release Notes (May 25–31, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-05-31-weekly)
Segmind updates for May 25 to 31, 2026: PDF, audio, and video inputs for Claude and other LLMs, an editable JSON playground, and a 2 GB upload limit.
## 1. Expanded Multimodal Inputs Across LLM Models [#1-expanded-multimodal-inputs-across-llm-models]
* **What's new:** Anthropic models (including `claude-opus-4.7` and all Claude variants) now fully support the documented `{prompt, image}` and `{prompt, pdf}` payload format. OpenAI models now accept PDF and audio file inputs in addition to images. Gemini models now accept video and file inputs natively.
* **Impact:** You can send PDFs, audio, and video directly to the corresponding models using Segmind's standard payload format — no need to hand-build complex `messages` arrays. If you were hitting validation errors with Anthropic models using the simple interface, those are fully resolved.
* **Released:** May 28, 2026
## 2. Editable JSON Playground [#2-editable-json-playground]
* **What's new:** The model playground on [platform.segmind.com](https://platform.segmind.com) now lets you directly edit the raw API payload in JSON mode. Form mode and JSON mode stay in sync bidirectionally, and an inline validator highlights any JSON errors before you submit.
* **Impact:** You can prototype and test custom API parameters without writing code — just switch to JSON mode, edit the payload, and run. Useful for exploring advanced parameters not exposed in the form UI.
* **Released:** May 28, 2026
## 3. Platform File Upload Limit Raised to 2 GB [#3-platform-file-upload-limit-raised-to-2-gb]
* **What's new:** The maximum file size you can upload directly on the platform has been raised from \~6 MB to **2 GB**.
* **Impact:** Large video files, high-resolution images, and multi-minute audio clips can now be uploaded directly in the platform UI for use in your workflows — no more workarounds for large assets.
* **Released:** May 28, 2026
## 4. Seedance 2.0 Image-to-Video: Retry-Friendly Error Handling [#4-seedance-20-image-to-video-retry-friendly-error-handling]
* **What's new:** When the Seedance 2.0 image-to-video provider is temporarily slow or unavailable, the API now returns a `503` with a `Retry-After: 30` header instead of a hard `400`.
* **Impact:** Integrations that automatically retry on `503` will succeed once the provider recovers. Requests that return `503` are not charged. Previously these surfaced as `400` errors with no retry guidance.
* **Released:** May 28, 2026
## 5. Clearer Content Policy Errors for Veo 3.1-fast [#5-clearer-content-policy-errors-for-veo-31-fast]
* **What's new:** When a prompt is rejected by Responsible AI (RAI) content filtering on `veo-3.1-fast`, the API now returns a `400` with the specific filter reason included in the response body.
* **Impact:** If your prompt triggers a content policy rejection, you now get an actionable error message explaining why — instead of a generic `500`. This makes it much easier to iterate on prompts that run into content policy limits.
* **Released:** May 28, 2026
## 6. PixelFlow: Share Workflows to Teams [#6-pixelflow-share-workflows-to-teams]
* **What's new:** PixelFlow workflows can now be shared directly to teams from the share modal. Use the Teams tab to select your team by checkbox, or paste a team ID to share with external collaborators.
* **Impact:** Teams can now collaborate on shared workflows without passing links around manually. Useful for organizations where multiple members need access to the same automation.
* **Released:** May 29, 2026
# Segmind Release Notes (June 1–7, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-06-07-weekly)
Segmind updates for June 1 to 7, 2026: Ideogram 4, MAI Image 2.5, and TripoSPLAT image-to-3D, plus dynamic fan-out in the PixelFlow editor.
## 1. New Models — Ideogram 4, MAI Image 2.5, and TripoSPLAT (Image-to-3D) [#1-new-models--ideogram-4-mai-image-25-and-triposplat-image-to-3d]
* **What's new:** Three new models are now available on Segmind: `ideogram-4` (text-to-image), `mai-image-2.5` (text-to-image), and `triposplat` (image-to-3D, which returns a 3D mesh as a `.ply`/`.splat` file).
* **Impact:** More options for high-quality image generation, plus a new image-to-3D path — turn a single image into a downloadable 3D mesh you can drop straight into a 3D pipeline.
* **Released:** June 6, 2026
## 2. PixelFlow: Dynamic Fan-Out and Asset Library in the Visual Editor [#2-pixelflow-dynamic-fan-out-and-asset-library-in-the-visual-editor]
* **What's new:** The PixelFlow editor on [platform.segmind.com](https://platform.segmind.com) gained two upgrades. **Dynamic fan-out** lets a node emit an array and run the downstream steps once per element, then collect the results back together — with per-element bindings (`{{ item }}`, `{{ index }}`) and multi-input zipping. And **asset library integration** lets LLM nodes browse and reference assets you've saved, with an "Add to assets" action that saves generation outputs back to your library (with automatic metadata) and a streaming gallery view of results.
* **Impact:** Build batch and iterative pipelines that loop over arrays natively, and reuse your own assets across a workflow without re-uploading — a big step up for multi-image and multi-step automations.
* **Released:** June 2–7, 2026
## 3. Gemini Embedding 2: Multimodal Embeddings [#3-gemini-embedding-2-multimodal-embeddings]
* **What's new:** `gemini-embedding-2` now accepts image, audio, video, and PDF inputs in addition to text, all mapped into a single shared embedding space. A new generic `file`/`files` input lets one request mix multiple media types into a single aggregated vector, with the media type detected automatically.
* **Impact:** Embed and compare content across modalities through one endpoint — existing text-only integrations keep working unchanged, and new modalities are opt-in by passing media in the input.
* **Released:** June 3–5, 2026
## 4. GPT Image 2: Flexible Output Sizing [#4-gpt-image-2-flexible-output-sizing]
* **What's new:** `gpt-image-2` now accepts aspect-ratio presets (1:1, 3:2, 2:3, 4:3, 3:4, 16:9, 9:16) and validated custom `width`/`height` values, in addition to fixed pixel strings.
* **Impact:** Pick the exact framing you need — square, portrait, landscape, widescreen, or vertical — or pass your own dimensions. Existing pixel-string requests keep working, and billing is unchanged (token-based and size-independent).
* **Released:** June 2, 2026
## 5. HeyGen Avatar IV: Output Resolution Control [#5-heygen-avatar-iv-output-resolution-control]
* **What's new:** `heygen-avatar-iv` now exposes output resolution control — choose from resolution presets or pass custom `width`/`height` for the generated avatar video.
* **Impact:** Tailor avatar video output dimensions to your use case instead of being limited to a single fixed size. Flat-priced, so there's no billing change.
* **Released:** June 5, 2026
## 6. Website Playground: Real-Time Status, Cancel, and Refresh-Safe Runs [#6-website-playground-real-time-status-cancel-and-refresh-safe-runs]
* **What's new:** Model runs in the website playground now use async inference end to end. You see live status as a job moves through Submitting → Queued → Processing → Completed, can cancel an in-flight run, and in-progress runs survive a page refresh — across image, video, audio, and LLM models.
* **Impact:** Long-running generations are no longer a black box. Track progress in real time, cancel runs you don't need, and reload the page without losing a job.
* **Released:** June 5, 2026
# Segmind Release Notes (June 8–14, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-06-14-weekly)
Segmind updates for June 8 to 14, 2026: Grok Imagine text-to-image, Bria Video Background Removal 3.0, and more reliable async inference.
## 1. New Models — Grok Imagine and Bria Video Background Removal 3.0 [#1-new-models--grok-imagine-and-bria-video-background-removal-30]
* **What's new:** **Grok Imagine** is now available as a text-to-image model on the API at `POST /v1/grok-imagine-image`. We also added **Bria Video Background Removal 3.0** (`bria-video-background-removal-3.0`), which removes the background from a video and returns alpha-channel (transparent) output, with an option to preserve the original audio.
* **Impact:** Generate images with Grok Imagine, and produce clean, background-free video with real transparency straight from the API — no extra compositing step needed before you drop the footage onto a new background.
* **Released:** June 9–10, 2026
## 2. PixelFlow Editor: Asset Library, Faster Model Access, and Smoother Navigation [#2-pixelflow-editor-asset-library-faster-model-access-and-smoother-navigation]
* **What's new:** The PixelFlow editor on [platform.segmind.com](https://platform.segmind.com) gained a full-screen **Asset Library** with a faceted tag editor, a quick-access **Top Models** flyout (Image / Video / Audio / LLM), and a per-workflow **Recently Used** models list. Connections between LLM and model nodes now manage their instructions automatically, creative mode shows clean parameter chips and media thumbnails instead of raw template syntax, and trackpad canvas navigation is more reliable — two-finger panning and Ctrl+scroll zoom work as expected, without accidental browser back/forward swipes.
* **Impact:** Finding and reusing models and assets takes fewer clicks, and the canvas behaves predictably on laptops and trackpads — building and editing workflows is noticeably faster and less fiddly.
* **Released:** June 8–13, 2026
## 3. More Reliable Async Inference and Credit Handling [#3-more-reliable-async-inference-and-credit-handling]
* **What's new:** Several improvements landed for asynchronous inference. Failed async requests now release their credit hold immediately instead of leaving credits reserved, long-running generations (over \~1 hour) are no longer at risk of running twice or being double-billed, high-volume workloads no longer hit false rate-limit (`429`) errors while polling for results, and credit holds left by interrupted requests now clear within about 15 minutes.
* **Impact:** Heavy and long-running jobs are more dependable, and you're far less likely to be wrongly blocked by a temporary "insufficient credits" error caused by a stuck hold.
* **Released:** June 9–13, 2026
## 4. Clearer API Error Responses [#4-clearer-api-error-responses]
* **What's new:** API errors are now returned as structured JSON — unknown model slugs return a `404` and unexpected failures return a clean `500`, instead of raw gateway errors. Calls to retired or deprecated models now fail fast with a `410 Gone` and are not charged.
* **Impact:** Errors are easier to detect and handle programmatically, and you won't be billed for requests to models that have been retired.
* **Released:** June 9, 2026
## 5. Platform Fixes — Uploads, Voice Studio, and veo-3.1 [#5-platform-fixes--uploads-voice-studio-and-veo-31]
* **What's new:** You can now upload `.m4a`, `.flac`, `.avif`, and `.mkv` files without errors. Cloned and designed voices in **Voice Studio** now reliably appear in your voice list right after you create them. And `veo-3.1` image-to-video again works correctly when you pass `reference_images`.
* **Impact:** More file types just work on upload, your custom voices show up immediately, and reference-image-guided generation with veo-3.1 is back to working as documented.
* **Released:** June 9–13, 2026
# Segmind Release Notes (June 15–21, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-06-21-weekly)
Segmind updates for June 15 to 21, 2026: an OAuth 2.1 server for connecting third-party apps without sharing an API key, and Grok Imagine controls.
## 1. OAuth 2.1 — Connect Third-Party Apps Without Sharing Your API Key [#1-oauth-21--connect-third-party-apps-without-sharing-your-api-key]
* **What's new:** Segmind now runs an OAuth 2.1 authorization server (endpoints under `/oauth/`). Third-party applications — including MCP clients — can request scoped, user-authorized access and call the API on your behalf without ever handling your API key. The change is fully additive: your existing API keys and signed-in sessions keep working exactly as before.
* **Impact:** You can safely connect external tools and integrations to your Segmind account through a standard OAuth consent flow, instead of pasting a long-lived API key into apps you don't control.
* **Released:** June 16, 2026
## 2. Grok Imagine — Quality and Image Editing Now Controllable by Parameter [#2-grok-imagine--quality-and-image-editing-now-controllable-by-parameter]
* **What's new:** Grok Imagine image generation is now a single model, `grok-imagine-image`, where image **quality** and **image editing** are selectable request parameters instead of separate model variants.
* **Impact:** Choose a quality level or switch to image-editing mode on the same model by setting a parameter — no need to call different endpoints for each mode.
* **Released:** June 16, 2026
## 3. More Flexible LLM Inputs [#3-more-flexible-llm-inputs]
* **What's new:** Two improvements landed for language-model calls. The simplified `{"prompt": "..."}` request shorthand now works across more of the LLMs available on Segmind, and Claude models now reliably accept image and PDF inputs supplied as URLs.
* **Impact:** Send a quick single-prompt request to more models without building a full `messages` array, and pass image or PDF URLs to Claude with confidence that they'll be fetched and processed reliably.
* **Released:** June 16, 2026
## 4. Clearer, Mode-Aware API Code Samples on Model Pages [#4-clearer-mode-aware-api-code-samples-on-model-pages]
* **What's new:** The API tab on model pages now opens to **asynchronous** examples first (with synchronous as the second tab) and organizes code samples in a two-axis **Mode (Sync / Async) × Language** layout. We added v2 asynchronous examples, including Python SDK (async) and cURL (async v2), and fixed a formatting issue that affected the PHP and Ruby snippets.
* **Impact:** Copy a working example that matches exactly how you want to call the model — async or sync, in your language of choice — straight from the model page.
* **Released:** June 16, 2026
## 5. PixelFlow — Run a Single Node on Its Own [#5-pixelflow--run-a-single-node-on-its-own]
* **What's new:** In the PixelFlow editor on [platform.segmind.com](https://platform.segmind.com), you can now run an individual node by itself. It uses the saved outputs of upstream nodes as its inputs, and gives a clear error if an upstream node hasn't been run yet, rather than silently re-running the rest of the graph.
* **Impact:** Iterate on one step of a workflow without re-running everything before it — faster tweaking and debugging of individual nodes.
* **Released:** June 15, 2026
## 6. Playground and Model Page Improvements [#6-playground-and-model-page-improvements]
* **What's new:** The Playground now renders 3D gaussian-splat outputs (`.ply` / `.splat`) from image-to-3D models directly in the viewer instead of showing raw data. Separately, newly added models no longer display a placeholder price before real pricing is available — the price stays hidden until accurate data is in place.
* **Impact:** Preview image-to-3D results visually right where you generate them, and avoid being misled by placeholder pricing on brand-new models.
* **Released:** June 16, 2026
# Segmind Release Notes (June 22–28, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-06-28-weekly)
Segmind updates for June 22 to 28, 2026: HappyHorse 1.1 video, the cheaper Seedance 2.0 Mini, and a p-image-try-on virtual try-on model.
## 1. HappyHorse 1.1 — New Video Model [#1-happyhorse-11--new-video-model]
* **What's new:** HappyHorse 1.1 (`happyhorse-1.1`) is now live. It automatically detects text-to-video, image-to-video, and reference-to-video generation from your request payload. HappyHorse 1.0 (`happyhorse`) is unchanged and keeps working exactly as before.
* **Impact:** Generate video from a text prompt, a starting image, or a reference video using a single model that picks the right mode from your inputs.
* **Released:** June 24, 2026
## 2. Seedance 2.0 Mini — A More Affordable Video Model [#2-seedance-20-mini--a-more-affordable-video-model]
* **What's new:** Seedance 2.0 Mini (`seedance-2.0-mini`) is now live on [platform.segmind.com](https://platform.segmind.com). It supports text-to-video, image-to-video, and reference-guided generation at 480p and 720p, and is a more cost-efficient option than Seedance 2.0.
* **Impact:** Produce Seedance-style video at a lower cost — a strong fit for higher-volume or budget-conscious workloads.
* **Released:** June 25, 2026
## 3. Virtual Try-On — New `p-image-try-on` Model [#3-virtual-try-on--new-p-image-try-on-model]
* **What's new:** A new virtual try-on model (`p-image-try-on`) is available via the API. Provide a person image plus up to 11 garment images in a single request.
* **Impact:** Generate on-model try-on imagery — dress a person in one or several garments — directly through the API.
* **Released:** June 28, 2026
## 4. API & Developer Experience [#4-api--developer-experience]
* **What's new:** Two improvements for API users. First, v2 asynchronous inference responses now include a `metrics` block on the status and result endpoints, reporting `cost`, `remaining_credits`, `queue_time`, `total_time`, and `retry_count` — an additive change with no breaking impact. Second, when a generation is blocked by content-safety filters, the API now returns a consistent, structured error response across supported models and automatically refunds the request.
* **Impact:** Track exactly what each async request cost, how long it queued and ran, and how many credits remain — without a separate lookup. And trust that a filtered request fails clearly and is refunded, rather than being silently charged.
* **Released:** June 25–26, 2026
## 5. Faster Playground — Run Generations in Parallel [#5-faster-playground--run-generations-in-parallel]
* **What's new:** The Playground now runs up to 3 generations at once, with clear in-progress feedback on the Generate button and protection against accidental double-submits. When you reach the limit, a `3/3 generating…` indicator and tooltip explain the wait instead of a silently disabled button.
* **Impact:** Kick off several generations side by side and always see what's happening — no more guessing whether a click registered or why the button is unavailable.
* **Released:** June 24, 2026
## 6. PixelFlow Editor Improvements [#6-pixelflow-editor-improvements]
* **What's new:** Several refinements landed in the PixelFlow editor on [platform.segmind.com](https://platform.segmind.com): template autocomplete now inserts reliably and handles edits made over a selection, pinned nodes show a clear ring and badge so their state reads at a glance, and a node now warns you when an upstream step could feed in an invalid asset reference.
* **Impact:** Build and edit PixelFlow workflows with fewer surprises — cleaner template editing, clearer node state, and earlier warnings before a misconfiguration causes a bad run.
* **Released:** June 23–26, 2026
## 7. Platform Reliability Improvements [#7-platform-reliability-improvements]
* **What's new:** Generated images and videos now save to your Generations page more reliably, FLUX Schnell and Fast FLUX Schnell automatically retry transient errors and return cleaner messages, and long-running Grok Imagine video jobs no longer time out prematurely.
* **Impact:** More of your generations land where you expect them, with fewer transient failures on high-volume image models and no premature timeouts on longer video jobs.
* **Released:** June 23–28, 2026
## 8. Creator Program Is Live [#8-creator-program-is-live]
* **What's new:** The new Segmind Creator Program is live, with a dedicated application page at [segmind.com/creator-program](https://segmind.com/creator-program).
* **Impact:** Creators can now apply to join the program directly from the website.
* **Released:** June 27, 2026
# Segmind Release Notes (June 29–July 5, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-07-05-weekly)
Segmind updates for June 29 to July 5, 2026: gemini-omni-flash text and image-to-video, nano-banana-2-lite, and full p-image-upscale controls.
## 1. gemini-omni-flash — New Text/Image-to-Video Model [#1-gemini-omni-flash--new-textimage-to-video-model]
* **What's new:** gemini-omni-flash (`gemini-omni-flash`) is now live — Google's any-to-any model for generating short video from a text prompt or an image. It returns inline H.264 clips at 720p/24fps (around 5 seconds) and is token-billed.
* **Impact:** Turn a prompt or a starting image into a short 720p video clip directly through the API, paying by tokens.
* **Released:** July 1, 2026
## 2. nano-banana-2-lite — New Image Model [#2-nano-banana-2-lite--new-image-model]
* **What's new:** nano-banana-2-lite (`nano-banana-2-lite`) is now available — a lighter companion to nano-banana-2 that mirrors its capabilities: output up to 4K, built-in web search, and up to 14 reference images.
* **Impact:** Get nano-banana-2's feature set — high-resolution output, web search, and multi-reference input — from a lighter-weight model option.
* **Released:** July 1, 2026
## 3. Expanded Gemini Video & Media Support [#3-expanded-gemini-video--media-support]
* **What's new:** Gemini models on Segmind now accept much larger video and media inputs — well beyond the previous upload limit — and pass YouTube URLs straight through to the model. Long videos, up to roughly 3 hours, are now supported, with video sampling tuned automatically to stay within limits. The LLM chat playground now forwards video and PDF attachments (not just images), and PixelFlow's File→Gemini node now sends video input to the model.
* **Impact:** Send long-form and large video, PDF, and media inputs — including YouTube links — to Gemini from the API, the chat playground, and PixelFlow, and have them reliably analyzed.
* **Released:** July 4–5, 2026
## 4. p-image-upscale — Full Parameter Control [#4-p-image-upscale--full-parameter-control]
* **What's new:** The p-image-upscale model (`p-image-upscale`) now exposes its full parameter set, including target resolution in megapixels, output format, and output quality.
* **Impact:** Control the resolution and encoding of upscaled images directly, instead of only supplying the input image.
* **Released:** July 1, 2026
## 5. Platform & UI Improvements [#5-platform--ui-improvements]
* **What's new:** Partner model pages — such as Black Forest Labs — now list all of a partner's available models instead of showing an empty state. A new Support page routes you to the right channel by issue type (Discord for technical questions, email for billing), with a Discord link added to the site footer. Reference-to-video requests on wan2.7 now process more reliably.
* **Impact:** Browse every model from a given partner in one place, reach the right support channel faster, and get more consistent results from wan2.7 reference-to-video.
* **Released:** June 30–July 1, 2026
# Segmind Release Notes (July 6–12, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-07-12-weekly)
Segmind updates for July 6 to 12, 2026: Seedream 5.0 Pro, new VEED video models, HeyGen avatar looks, and auto-clipping for long-form video.
## 1. Seedream 5.0 Pro — New Image Model [#1-seedream-50-pro--new-image-model]
* **What's new:** Seedream 5.0 Pro (`seedream-5-pro`) is now live — ByteDance's flagship image model. It supports text-to-image as well as single- and multi-reference image-to-image with up to 10 reference images, at 1K and 2K output tiers.
* **Impact:** Generate high-quality images from a prompt, or guide generation with up to 10 reference images, choosing 1K or 2K output — all from one model code.
* **Released:** July 8, 2026
## 2. New VEED Video Models [#2-new-veed-video-models]
* **What's new:** Five new VEED video models are now available: `veed-fabric-1.0` (video generation), `veed-lipsync`, `veed-avatars`, `veed-video-background-removal`, and `veed-subtitles`.
* **Impact:** Add lip-sync, AI avatars, automatic video background removal, subtitle generation, and VEED's Fabric video model to your workflows — all through the API.
* **Released:** July 6, 2026
## 3. heygen-generate-look — New Avatar Look Model [#3-heygen-generate-look--new-avatar-look-model]
* **What's new:** A new model, `heygen-generate-look`, is now live. From a text prompt, it changes a photo avatar's outfit, environment, or pose to produce a new look of the same identity — using either a pre-trained avatar group or a single face image. Its output can feed the `heygen-avatar-iv` and `heygen-avatar-v` models to create talking video.
* **Impact:** Restyle a consistent avatar — new outfits, settings, or poses — from a simple text prompt, then bring the result to life as talking video.
* **Released:** July 9, 2026
## 4. Higgsfield Soul 2.0 — New Image Model [#4-higgsfield-soul-20--new-image-model]
* **What's new:** Higgsfield Soul 2.0 (`higgsfield-soul-2`) is now available through the API.
* **Impact:** Access Higgsfield's latest Soul 2.0 image generation directly on Segmind.
* **Released:** July 8, 2026
## 5. opus-clips-from-video — Auto-Clip Long-Form Video [#5-opus-clips-from-video--auto-clip-long-form-video]
* **What's new:** A new creator utility model, `opus-clips-from-video`, automatically turns long-form video into short, shareable clips. It's available with both synchronous and asynchronous calls.
* **Impact:** Automatically cut long videos into ready-to-share short clips through the API.
* **Released:** July 6, 2026
## 6. New Video Editing API — Timeline & Split [#6-new-video-editing-api--timeline--split]
* **What's new:** A new `/v2/timeline` endpoint provides a multi-track video compositor — combine video, text, overlay, and audio tracks with transitions, per-clip audio ducking, and automatic loudness normalization in a single request. A companion `/v2/video-split` endpoint splits one video into multiple segments.
* **Impact:** Assemble multi-track video edits — layering clips, text, overlays, and mixed audio — in a single API call, and split videos programmatically, without stitching together separate tools.
* **Released:** July 7, 2026
## 7. API Enhancements [#7-api-enhancements]
* **What's new:** Several models gained new controls this week. `nano-banana-pro`, `nano-banana-2`, and `nano-banana-2-lite` now accept an optional `system_prompt` input; `grok-imagine-video` now accepts up to 7 reference images (up from 3); and Seedance 2.0, 2.0-fast, and 2.0-mini added an optional `bitrate_mode` (`standard` or `high`) for encoding-quality control. Separately, the `heygen-avatar-v` endpoint now returns a clear, structured response including a consent URL when a real-face avatar requires one-time on-camera consent — so you can verify and retry instead of hitting an opaque error.
* **Impact:** More control over your generations — system prompts for nano-banana, more references for Grok Imagine, and encoding-quality control for Seedance — plus a clearer path when a HeyGen avatar needs consent verification.
* **Released:** July 7–9, 2026
## 8. Platform & UI Improvements [#8-platform--ui-improvements]
* **What's new:** Signing in, signing out, and creating API keys now work reliably across the platform. In the playground, pasted video and audio URLs now preview correctly, JSON outputs render properly, and downloaded images keep their original file format. And subscription renewals that are fully covered by a discount coupon or account credit balance now correctly apply the monthly credit grant.
* **Impact:** A smoother sign-in and API-key experience, more dependable playground previews and downloads, and reliable monthly credits even when your renewal is fully discounted.
* **Released:** July 6–11, 2026
# Segmind Release Notes (July 13–19, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-07-19-weekly)
Segmind updates for July 13 to 19, 2026: the glm-5.2, nemotron-3-ultra, and minimax-m3 chat models, plus veed-2-lipsync and a multi-clip gallery.
## 1. New Chat Models — glm-5.2, nemotron-3-ultra, minimax-m3 [#1-new-chat-models--glm-52-nemotron-3-ultra-minimax-m3]
* **What's new:** Three new chat LLMs are now available through the API: `glm-5.2`, `nemotron-3-ultra`, and `minimax-m3`.
* **Impact:** Call three additional large language models directly through the Segmind API.
* **Released:** July 13, 2026
## 2. veed-2-lipsync — New Lip-Sync Model [#2-veed-2-lipsync--new-lip-sync-model]
* **What's new:** A new lip-sync model, `veed-2-lipsync` (VEED Lipsync v2), is now live. It uses the same `video_url` + `audio_url` request contract as the previous version, so existing integrations can move over without code changes.
* **Impact:** Sync a speaker's lips to any audio track with VEED's latest lip-sync model — a drop-in upgrade for current `veed-lipsync` users.
* **Released:** July 16, 2026
## 3. opus-clips-from-video — Structured Video Output [#3-opus-clips-from-video--structured-video-output]
* **What's new:** The `opus-clips-from-video` result endpoint now returns a structured `videos[]` array — each item includes `url`, `content_type`, `file_name`, `file_size`, and `metadata` — matching the standard `video/*` response shape, instead of a stringified JSON blob. Clients that parsed the previous string response should update to read the array.
* **Impact:** Parse multi-clip output reliably with a standard, structured response. Note this is a breaking change for integrations built against the older string format.
* **Released:** July 14, 2026
## 4. Playground — Multi-Clip Gallery View [#4-playground--multi-clip-gallery-view]
* **What's new:** The Playground now displays multi-clip video output as a gallery — a main preview with a filmstrip of all clips, inline playback, and per-item download. Because `opus-clips-from-video` can return many clips per request, they now all appear and play directly in the Playground.
* **Impact:** Preview, play, and download every clip from a multi-clip generation right in the Playground.
* **Released:** July 15, 2026
## 5. New Platform Dashboard Now Open to Everyone [#5-new-platform-dashboard-now-open-to-everyone]
* **What's new:** The new dashboard at [platform.segmind.com](https://platform.segmind.com) is now open to all users. Previously limited to a rollout group, it is now available to everyone.
* **Impact:** Use the new Segmind dashboard right away — no rollout group or waitlist required.
* **Released:** July 18, 2026
## 6. Reliability & Billing Improvements [#6-reliability--billing-improvements]
* **What's new:** Several reliability and billing improvements landed this week. Gemini Omni Flash generations that include a reference video now retry automatically on transient upstream errors, making video-input runs far more dependable. Seed Audio 1.0 also retries transient upstream failures and now returns a clear, distinct message when a request is rejected by content moderation, rather than an ambiguous error. And credit auto-recharge top-ups that are paid late or manually — for example after switching payment cards — now correctly grant credits instead of being dropped.
* **Impact:** More dependable Gemini Omni Flash video-input and Seed Audio generations with clearer error messages, and reliable credit top-ups even when a payment completes late or on a different card.
* **Released:** July 13–15, 2026
## 7. Platform & UI Improvements [#7-platform--ui-improvements]
* **What's new:** Dark theme is now the default across [segmind.com](https://segmind.com) and [platform.segmind.com](https://platform.segmind.com) for new visitors. If you've already chosen light, system, or dark, your preference is preserved.
* **Impact:** A consistent dark-by-default experience across the website and platform, while any theme you've explicitly picked stays put.
* **Released:** July 16, 2026
# Segmind Release Notes (July 20–26, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-07-26-weekly)
Segmind updates for July 20 to 26, 2026: opt-in web search grounding for Gemini models, source citations, and a redesigned model playground.
## 1. Web Search Grounding for Gemini Models [#1-web-search-grounding-for-gemini-models]
* **What's new:** Gemini text models and `nano-banana-pro` now accept an opt-in `web_search: true` parameter that grounds a generation in live Google Search results. It is off by default, so existing calls behave exactly as before.
* **Impact:** Ground text and image generations in current information from the web by adding a single parameter to your request.
* **Released:** July 24, 2026
## 2. See the Sources Behind a Grounded Generation [#2-see-the-sources-behind-a-grounded-generation]
* **What's new:** Image models (`nano-banana-2` and `nano-banana-pro`) now return the evidence behind a search-grounded result. The v2 response envelope includes a `grounding` object, synchronous requests also return an `X-Web-Search-Queries` header, and the same details are stored in the generation's metadata. Requests that don't use `web_search` are unchanged.
* **Impact:** Inspect the exact search queries and sources that informed a grounded image, so you can verify and cite what the model used.
* **Released:** July 25, 2026
## 3. Utility Tools — Full JSON Output [#3-utility-tools--full-json-output]
* **What's new:** Utility tools accept a new opt-in `response_format: json` parameter that returns every output from a job — the text response plus every generated clip and image — instead of only the first result. The default `file` response is untouched, and billing is unchanged either way.
* **Impact:** Retrieve every clip or image from a multi-output job in a single structured response, which makes multi-clip video-editing runs much simpler to consume.
* **Released:** July 25, 2026
## 4. Redesigned Model Playground [#4-redesigned-model-playground]
* **What's new:** Model pages at `segmind.com/models/{slug}` are getting a creator-first playground: a sticky compose panel that stays in view while you work, a running feed of your generations, and the model's documentation stacked below. The new design is rolling out gradually.
* **Impact:** Compose, generate, and compare results on a model page without losing your place or scrolling back to the prompt box.
* **Released:** July 25, 2026
## 5. Classic Interface Toggle [#5-classic-interface-toggle]
* **What's new:** A "Classic Interface" toggle lets you switch the playground back to the previous layout at any time. Your choice is remembered in your browser.
* **Impact:** Keep working in whichever playground layout suits your workflow while the new design rolls out.
* **Released:** July 26, 2026
## 6. Playground — Long Prompts and Multiple References [#6-playground--long-prompts-and-multiple-references]
* **What's new:** Several improvements for prompt-heavy work: the compose dock now stays expanded, the prompt box grows taller before it starts scrolling, a fullscreen prompt editor handles scene-length scripts, and filled reference tiles now display the filename of the image you attached.
* **Impact:** Write and edit long, detailed prompts comfortably, and tell your reference images apart at a glance.
* **Released:** July 26, 2026
## 7. Playground — Session Generation Strip [#7-playground--session-generation-strip]
* **What's new:** A strip of chips along the top of the canvas tracks the generations in your current session, showing which are in flight, completed, or failed. Click any completed chip to bring that result back on screen. The strip stays hidden until you start a generation.
* **Impact:** Run several video generations in parallel, watch all of them at once, and jump back to any finished result without re-running it.
* **Released:** July 26, 2026
## 8. Playground — More Reliable Generations [#8-playground--more-reliable-generations]
* **What's new:** Generations now stay attached to the page as you navigate, and refreshing a tab mid-generation reconnects to the running job and picks it back up. Saving a result to your machine now works consistently across browsers.
* **Impact:** Move around the site or refresh the page during a long generation and still get your result.
* **Released:** July 26, 2026
## 9. Playground — Correct Video Aspect Ratios [#9-playground--correct-video-aspect-ratios]
* **What's new:** Video output in the playground now renders at the media's true aspect ratio.
* **Impact:** Portrait (9:16) and other non-landscape videos fill the player at their true dimensions.
* **Released:** July 22, 2026
# Segmind Release Notes (July 27–August 2, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-08-02-weekly)
Segmind updates for July 27 to August 2, 2026: two new image models, full multi-image responses, portrait reference-to-video, a resizable playground, and clearer team model access.
## 1. New Image Models — Reve v2 and Pruna × Ideogram [#1-new-image-models--reve-v2-and-pruna--ideogram]
* **What's new:** Two new image models are live on the API. `reve-2` brings Reve v2 text-to-image, including its edit and remix modes. `p-image-ideogram` brings Ideogram generation accelerated by Pruna, offered in four quality tiers with support for custom output dimensions — Segmind is a launch partner.
* **Impact:** Call two more text-to-image families through the same API you already use, and choose a quality tier on `p-image-ideogram` to match the fidelity you need.
* **Released:** July 27–30, 2026
## 2. Multiple Images per Request with `grok-imagine-image` [#2-multiple-images-per-request-with-grok-imagine-image]
* **What's new:** Requests with `n > 1` now return every generated image, and the playground presents them as a gallery — a large preview of the selected image plus a filmstrip of the full set.
* **Impact:** Generate a batch of variations in a single call and browse the whole set without re-running the request.
* **Released:** July 27–30, 2026
## 3. Portrait and Custom Aspect Ratios for WAN 2.7 Reference-to-Video [#3-portrait-and-custom-aspect-ratios-for-wan-27-reference-to-video]
* **What's new:** `wan2.7-r2v` now honours the aspect ratio you request, including portrait 9:16, instead of always producing 16:9. Ultra-wide ratios the model does not support are rejected up front with a clear error rather than accepted and ignored.
* **Impact:** Produce vertical, square, and other non-landscape reference-to-video output for social formats directly from the API.
* **Released:** July 29, 2026
## 4. Playground — Resizable Workspace and One-Click Settings [#4-playground--resizable-workspace-and-one-click-settings]
* **What's new:** The playground dock and canvas are now separated by a drag handle you can move to resize either side, enum and boolean settings render as one-click pills instead of dropdowns, and a download chip is anchored to the output.
* **Impact:** Size the compose area and the preview to suit the work in front of you, change common settings in a single click, and save a result without hunting for the download button.
* **Released:** July 31, 2026
## 5. Restricted Models Are Labelled Before You Generate [#5-restricted-models-are-labelled-before-you-generate]
* **What's new:** When a team admin restricts a model, it now carries a "Restricted" badge with a lock icon and a disabled Generate button — across the model and LLM playgrounds, Pixelflow, the segmind.com playground, and navbar search.
* **Impact:** See at a glance which models your team has made unavailable, instead of finding out from an error after you press Generate.
* **Released:** July 31–August 1, 2026
## 6. Audio-Aware Pricing for Seedance 1.5 Pro [#6-audio-aware-pricing-for-seedance-15-pro]
* **What's new:** The pricing page now lists separate output rates for `seedance-1.5-pro` depending on whether audio generation is enabled — $2.4/M output tokens without audio, $3.0/M with audio.
* **Impact:** Know what generating with audio costs before you run the job rather than when the invoice arrives.
* **Released:** August 1, 2026
## 7. Team Invites Survive Sign-In [#7-team-invites-survive-sign-in]
* **What's new:** An invite link now carries its token through the login and OAuth redirect, so people who don't yet have a Segmind account are added to the team once they finish signing up.
* **Impact:** Invite teammates who are new to Segmind and have them land in the right team, not on an empty dashboard.
* **Released:** August 1, 2026
## 8. Shared Pixelflow Graphs Open Correctly [#8-shared-pixelflow-graphs-open-correctly]
* **What's new:** Shared Pixelflow workflows now open with all node connections intact. Graphs shared before this change repair themselves the next time they're opened — there is no need to re-share them.
* **Impact:** Open a workflow someone shared with you and run it as-is.
* **Released:** July 30, 2026
# Segmind Release Notes (August 3–9, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-08-09-weekly)
Segmind updates for August 3 to 9, 2026: Sonilo audio models, the FLUX 3 video family with draft enhance, Seedance 2.5 and new video controls, magic-link sign-in for everyone, Bundles, and a more persistent playground.
## 1. New Audio Models — Sonilo [#1-new-audio-models--sonilo]
* **What's new:** Three Sonilo audio models are live on the API: video-to-audio, text-to-audio, and video-to-video. They are billed per second of output, with rates from $0.0028 to $0.0225 per second depending on the model and sound type, and they are available through the API, the SDK, Pixelplay, and Pixelflow.
* **Impact:** Generate soundtracks and sound effects for your videos, or audio from a text prompt, without leaving Segmind — and pay only for the seconds you actually generate.
* **Released:** August 3–4, 2026
## 2. FLUX 3 Video Models and Draft Enhance [#2-flux-3-video-models-and-draft-enhance]
* **What's new:** The FLUX 3 family is onboarded with four modality slugs — text-to-video, image-to-video, video-to-video, and draft. Drafts generated asynchronously can be enhanced through the `/v2` API, which returns a `draft_cache_url` envelope, and the playground picks up a draft from a `?draft_cache=` parameter so you can enhance it there too.
* **Impact:** Preview a cheap draft first, then enhance only the takes worth finishing — from the API or the playground.
* **Released:** August 6–8, 2026
## 3. Seedance 2.5, Plus New Video Controls [#3-seedance-25-plus-new-video-controls]
* **What's new:** `seedance-2.5` is live on the API alongside the existing Seedance 2.0 slugs, with pricing listed on the pricing tab ($10.97/M text-image input tokens, $6.56/M video input tokens). `seedance-2.5` and `seedance-2.0-mini` also accept `duration: -1`, default an omitted aspect ratio to `adaptive`, and can return `.mov` output.
* **Impact:** Run Seedance 2.5 through the same endpoints you already use, and drive video-editing tasks such as element replacement and clip extension that previously weren't reachable through the API.
* **Released:** August 7–9, 2026
## 4. More Models and Model Options [#4-more-models-and-model-options]
* **What's new:** `qwen-3.8-max` (Alibaba Qwen3.8 Max) is available at `POST /v1/qwen-3.8-max`. `grok-imagine-video-1.5` is now split into three explicit slugs — text-to-video, image-to-video, and reference-to-video — that match the inputs each mode actually accepts. `minimax-h3` adds a 768p resolution tier across all three of its slugs, with the default unchanged at 2K, so existing calls are unaffected. The `pixverse-*-transition` slugs are working again end to end, including first-frame/last-frame generation.
* **Impact:** More models to call, clearer slugs that tell you up front what inputs a mode takes, and a lower-resolution MiniMax tier when you don't need 2K.
* **Released:** August 4–6, 2026
## 5. Sign In With a Magic Link — Now Open to Everyone [#5-sign-in-with-a-magic-link--now-open-to-everyone]
* **What's new:** Email magic-link login is available to all users; the previous whitelist and the "whitelisted emails only" notice are gone. The login flow also shows the specific reason when a link can't be sent, such as an invalid address or a rate limit.
* **Impact:** Sign in with just your email address, without a password or a wait for access.
* **Released:** August 6, 2026
## 6. Bundles — Curated Workflow Collections [#6-bundles--curated-workflow-collections]
* **What's new:** Partners and admins can group Pixelflow workflows into Bundles with their own public landing page at `segmind.com/bundles/{slug}`, reachable from site navigation. Partners can also publish Pixelflow templates directly and edit the ones they authored, with no approval step. The bundle editor scopes to a partner's own published workflows, and workflow publish, API, and share routes enforce owner-only access.
* **Impact:** Package a set of related workflows as a shareable, linkable collection, and publish your own templates on your own schedule.
* **Released:** August 5–9, 2026
## 7. Playground and Pixelflow Improvements [#7-playground-and-pixelflow-improvements]
* **What's new:** The playground now keeps your full session — form inputs, parameters, output, and the "this session" strip — across navigation between History and Playground and across hard reloads. The download chip is always visible rather than appearing on hover, expanded prompts cap at ten lines, and the interface toggle preserves your parameters and prompt. In Pixelflow, parameter descriptions moved behind a `(?)`, dropzones are shorter, there's a fan-out popover and model ranking, the editor handles connections from un-run nodes cleanly (repairing affected graphs automatically), and the Share button now emails the recipient a working link.
* **Impact:** Come back to a generation exactly as you left it, and build in Pixelflow with less clutter and fewer interruptions.
* **Released:** August 3–9, 2026
## 8. Billing, Credits, and Clearer Errors [#8-billing-credits-and-clearer-errors]
* **What's new:** Failed generations are never charged — request records always reach a terminal state and billed failures are never replayed. Auto-recharge now uses Stripe PaymentIntent with 3D Secure for SCA-compliant card capture, reuses a single Stripe customer per account, shows an accurate setup status, and disables the retry button while a charge is in flight. Credit balances for accounts returning after a period of inactivity are restored from the source of record rather than starting from zero. Errors originating with upstream providers are translated into clear, consistent Segmind error responses, with transient faults marked retryable.
* **Impact:** Pay only for generations that succeed, set up auto-recharge with a card that passes European SCA checks, and get an actionable error message when something upstream goes wrong.
* **Released:** August 4–8, 2026
## 9. Terms and Privacy Policy, Restructured [#9-terms-and-privacy-policy-restructured]
* **What's new:** The Master Cloud Services Agreement at `/terms` and the policy at `/privacy` have been restructured so they are navigable, citable by clause number, and printable. The wording is unchanged word for word.
* **Impact:** Point your legal or procurement team at a specific clause instead of a wall of text.
* **Released:** August 5, 2026
# Segmind Release Notes (August 10–16, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-08-16-weekly)
Segmind updates for August 10 to 16, 2026: object extraction and layer decomposition models, LTX 2.5, Grok Imagine Image 2, an annotatable playground with shot chaining, clearer API errors, x-api-key code samples, per-team-member usage visibility, and Pixelflow partner publishing.
## 1. New Models — Object Extraction and Layer Decomposition [#1-new-models--object-extraction-and-layer-decomposition]
* **What's new:** Two new image models are live on the API. `bria-extract-object` isolates a single named object from an image using a text prompt and returns an RGBA PNG cutout with soft alpha edges. `seedream-5-pro-layer-decomposition` takes one image and returns a base image plus up to 16 transparent PNG element layers, each with its stacking order, bounding box, and name.
* **Impact:** Pull one subject cleanly out of a photo, or break a finished composition back into editable layers, without a manual masking pass in an image editor.
* **Released:** August 12, 2026
## 2. LTX 2.5, Grok Imagine Image 2, and Legacy LTX Slugs [#2-ltx-25-grok-imagine-image-2-and-legacy-ltx-slugs]
* **What's new:** `ltx-2.5-fast`, `ltx-2.5-pro`, and `grok-imagine-image-2` are live on the API. The legacy `ltx-2-*` slugs now resolve to LTX 2.3 ahead of LTX 2's August 15 end of life, so calls still pointing at the old slugs keep working.
* **Impact:** Call the newer LTX tiers directly, and keep existing LTX integrations running without an emergency change on your side.
* **Released:** August 14, 2026
## 3. Playground — Layer Gallery, Annotated Inputs, and Shot Chaining [#3-playground--layer-gallery-annotated-inputs-and-shot-chaining]
* **What's new:** The playground supports `seedream-5-pro-layer-decomposition` with a layer gallery that shows each returned PNG alongside its `z_index` and bounding-box manifest, plus a new annotatable image input — circle or scribble on the source image and the marks are flattened into what the model sees. For Seedance 2.x, the last frame of a generated clip is now surfaced as a labelled artifact in the output gallery and feeds directly into the next clip's `first_frame_url`.
* **Impact:** Point the model at exactly what you mean by marking up the image, inspect decomposed layers one at a time, and chain shots together by carrying the last frame of one clip into the start of the next.
* **Released:** August 12–13, 2026
## 4. Clearer API Errors and Stricter Request Validation [#4-clearer-api-errors-and-stricter-request-validation]
* **What's new:** Video-model failures now return a specific, actionable reason — for example, a source image whose height falls outside the accepted range — instead of one generic "reference media could not be prepared" message. Provider-side error output is normalised into clean Segmind error responses, and transient faults are marked as retryable. On the validation side, `seedance-2.5` submissions now resolve aspect-ratio and task-type constraints automatically instead of being rejected, and `wan2.7-r2v` caps `duration` at 10 seconds when the reference material includes a video and rejects out-of-range or non-numeric durations with a clear `400`.
* **Impact:** Read the error, fix the input, and retry — instead of guessing which part of your request was rejected. A request that can't run tells you so up front rather than running at a duration you didn't ask for.
* **Released:** August 11, 2026
## 5. API Code Samples Now Use `x-api-key` [#5-api-code-samples-now-use-x-api-key]
* **What's new:** Every API code sample — curl, Python, JavaScript, Go, PHP, and Ruby, across the model, Pixelflow, LLM, and AI gateway tabs — now authenticates with the `x-api-key` header. `SG_` keys authenticate with `x-api-key`, not `Authorization: Bearer`.
* **Impact:** Copy a sample straight out of the playground and it authenticates on the first try, instead of returning a confusing `401`.
* **Released:** August 16, 2026
## 6. Per-Team-Member Usage and Cost Visibility [#6-per-team-member-usage-and-cost-visibility]
* **What's new:** The `/request-history` and `/generations` endpoints accept optional `user_id` and `user_email` filters and now return who made each request. In the console, generations can be filtered by team member across the table, grid, mobile, and CSV export views, and the Source filter now offers only the values the API actually accepts. The cost-analytics "Cost by Team Member" card explains when it requires team-admin access rather than rendering blank, and cost analytics loads reliably regardless of the shape of the response.
* **Impact:** See which teammate ran which generation, and break usage and spend down per person from either the API or the console.
* **Released:** August 14–16, 2026
## 7. Pixelflow — Partner Publishing and Editor Reliability [#7-pixelflow--partner-publishing-and-editor-reliability]
* **What's new:** External affiliate partners can now publish Pixelflow workflows with a callable API, and a template's private, playground, and API visibility settings now drive the tabs shown on its page. Templates without a playground snapshot show the Workflow canvas tab instead of an empty state. In the editor, a new "Run as API" mode simulates a published run on the canvas, publish-compatibility warnings flag blockers before you publish, each node keeps its own model's output type, `{{ }}` references to deleted nodes are cleaned up automatically, and workflow cards fall back to a placeholder icon when a thumbnail is unavailable.
* **Impact:** Publish a workflow as an API that others can call, and see how it will behave — and what would block it — before you ship it.
* **Released:** August 13–15, 2026
## 8. Coming Soon Model Pages and Google Sign-In [#8-coming-soon-model-pages-and-google-sign-in]
* **What's new:** Models can now appear on `segmind.com/models` before they're runnable, with a "Coming Soon" pill, a dedicated pre-launch page, and a disabled playground. Separately, Google sign-in now completes reliably, and an interrupted sign-in lands on a recoverable retry notice on the console login page instead of a dead end; old `/login` bookmarks route to the current login page.
* **Impact:** See what's landing next and bookmark the page before a model goes live, and sign in with Google without getting stuck.
* **Released:** August 13–15, 2026
# Segmind Release Notes (August 17–23, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-08-23-weekly)
Segmind updates for August 17 to 23, 2026: Google Lyria 3 music generation with timed lyrics, Seedance 2.5 at 1080p, audio on by default and forgiving Seedance inputs, clearer 401 and async errors, a Cost Analytics member filter, restored team model access controls, and a batch of Pixelflow reliability fixes.
## 1. New Model — Google Lyria 3 Music Generation [#1-new-model--google-lyria-3-music-generation]
* **What's new:** Google Lyria 3 is live on the API. `lyria-3` generates a 30-second clip and `lyria-3-pro` generates a full song, both returning MP3. In the playground, sung lyrics are rendered in time with the playhead — the current line highlights as it plays and you can click any line to seek to it — and the example output shows the lyrics before you generate anything.
* **Impact:** Generate original music with vocals from a prompt, and follow the lyrics against the audio instead of listening blind to work out what the model sang.
* **Released:** August 23, 2026
## 2. Seedance 2.5 — 1080p Output [#2-seedance-25--1080p-output]
* **What's new:** Seedance 2.5 gains a 1080p (10-bit) output tier, available on both the v1 and v2 endpoints.
* **Impact:** Render Seedance 2.5 clips at 1080p without stepping outside the same request you already use.
* **Released:** August 18, 2026
## 3. Seedance — Audio On by Default and Forgiving Input Handling [#3-seedance--audio-on-by-default-and-forgiving-input-handling]
* **What's new:** `generate_audio` now defaults to `true` on Seedance 2.x, so a request that omits the flag comes back with audio rather than a silent video. Input images that fall outside the accepted size range are auto-resized by default. When a reference image conflicts with first/last-frame control, frame control now wins and the request returns a warning — an `X-Warning` header on v1, a `warning` field on v2 — instead of failing outright; this applies across the whole family (2.0, 2.0-fast, 2.0-mini and 2.5). In the playground, the input dock now shows only the input modes that are valid together, so frame-control and reference-media tiles no longer appear side by side.
* **Impact:** Fewer rejected requests and fewer surprises — an oversized reference image or a slightly over-specified request now runs and tells you what it did, instead of returning an error you have to decode.
* **Released:** August 18–20, 2026
## 4. Clearer API Errors — Authentication, Async, and gpt-image [#4-clearer-api-errors--authentication-async-and-gpt-image]
* **What's new:** A `401` now names the actual cause rather than returning one generic "invalid or expired" message — for example, a key sent as `Authorization: Bearer` is never checked, and the response now says so. Failed v2 async requests surface the real upstream error instead of an opaque placeholder response. On the gpt-image side, a `png` `output_format` no longer returns a `400`, and the `gpt-image-1` family returns its moderation results instead of discarding them.
* **Impact:** When a request fails, the response tells you what to change — the wrong auth header, the real provider error, the actual moderation outcome — instead of leaving you to guess.
* **Released:** August 19–21, 2026
## 5. Cost Analytics and Inference History by Team Member [#5-cost-analytics-and-inference-history-by-team-member]
* **What's new:** Cost Analytics adds a **Member** filter that rescopes the entire page — total cost, request count, projected month-end and every chart — with per-member costs reconciling exactly to the team total. Console inference history (request history and generations) gains the same member filter, plus a "Requested by" row in the request detail sidebar. On the API, `GET /request-metrics` accepts `user_id` and `user_email` filters, and `GET /team/get-details` returns each member's `user_id`. Both the member filters and the metrics filters are available to team admins.
* **Impact:** Team admins can answer "who spent what" for any teammate across cost, requests and history, in the console or straight from the API.
* **Released:** August 19–20, 2026
## 6. Team Model Access Controls [#6-team-model-access-controls]
* **What's new:** The team model catalog and blacklist endpoints now take an explicit `team_id` rather than inferring one from the caller's workspace, and the team settings "Edit access" dialog and Model Providers page pass the team id from the route.
* **Impact:** Team admins can set team-wide and per-member model restrictions again, on the right team, instead of running into a failed model catalog load.
* **Released:** August 22, 2026
## 7. Pixelflow — Reliable Runs, Legacy Migration, and Clearer Errors [#7-pixelflow--reliable-runs-legacy-migration-and-clearer-errors]
* **What's new:** Published workflows with a multi-input Output node now return every connected wire, and a run that fails partway returns its partial results. Every execution path, including the WebSocket path, now runs through a single execution engine with publish as the only gate. Opening a workflow built in the old console now prompts you to convert it or open it read-only, instead of migrating and autosaving in the background — conversion is atomic and keeps a copy of the original — and legacy graphs no longer open with blank parameter panels. A published API URL now resolves back to the graph it belongs to, team-membership checks work for every member, and a workflow that won't open because of the active workspace now says exactly that.
* **Impact:** Published workflows return the outputs you paid for, legacy workflows migrate on your terms, and a workflow you can't open tells you why instead of showing one generic loading error.
* **Released:** August 20–23, 2026
## 8. Platform — Sign-In Reliability, Accurate Pricing, and Console Consistency [#8-platform--sign-in-reliability-accurate-pricing-and-console-consistency]
* **What's new:** Sign-in now mints a fresh verification token on every attempt, and a rejected verification shows a "we couldn't verify that request" notice on the console login page instead of leaving you signed out with no explanation. Email login lands on the current console, and a stale session cookie that could shadow the real one is now cleared. Model pages show correct usage-based pricing for models priced dynamically from your inputs, such as Grok Imagine video, so the quote on the page matches what you are billed. Across the console, the three dashboards share the same filters, presets and date caps, and the generations view explains the 31-day range limit rather than returning an empty result.
* **Impact:** Sign in without getting stuck, trust the price shown on a model page before you call it, and move between console dashboards without re-learning the filters.
* **Released:** August 20–23, 2026
# Segmind Release Notes (August 24–30, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-08-30-weekly)
Segmind updates for August 24 to 30, 2026: restored availability across the Kling and Ideogram 3 families, a Wan 3.0 Video contract update, in-playground mask drawing and a raw JSON response view, more forgiving uploads and dimensions, API key attribution in request history, working dedicated-endpoint controls, and a batch of Pixelflow reliability fixes.
## 1. Restored Availability — Kling, Ideogram 3, and More [#1-restored-availability--kling-ideogram-3-and-more]
* **What's new:** The Kling and Ideogram 3 model families, along with `ray-flash-2-720p` and `material-transfer`, are pricing and running normally again after a fault in how their pricing records were read. Requests that failed during that period were never billed. Separately, the ESRGAN upscaler no longer fails partway through a run.
* **Impact:** Every model in these families accepts requests again, and upscale jobs complete reliably.
* **Released:** August 26–27, 2026
## 2. Wan 3.0 Video — API Contract Update and Input Handling [#2-wan-30-video--api-contract-update-and-input-handling]
* **What's new:** Now that Wan 3.0 Video has left beta, `wan3.0-video` no longer accepts `enable_thinking`, and a request that sends both a first frame and conflicting reference media is rejected rather than silently resolved. Input handling also improved: asset-library URLs containing `@` now resolve correctly, and reference clips longer than 15 seconds are rejected up front with a clear message instead of failing after the upload completes. The model is also now featured on the models page carousel.
* **Impact:** A stable request contract to build against, and reference-video inputs that either run or tell you why they can't before you wait on an upload.
* **Released:** August 24–26, 2026
## 3. Playground — Mask Drawing, Media Previews, and a Raw JSON View [#3-playground--mask-drawing-media-previews-and-a-raw-json-view]
* **What's new:** You can now draw alpha masks directly on the canvas for `gpt-image-2`, painting in place without moving the image pair around, and the mask editor always loads the current image rather than a cached copy. The input dock gains preview and playback for uploaded media, so you can inspect a file before running it. A new **Preview | JSON** toggle shows the verbatim `/v2/requests/{id}` response body — or the model's stored sample output before your first run. Playground chat also keeps attached images reliably, and video uploads now have their own size budget.
* **Impact:** Mask, inspect, and run an edit end to end in the playground, and read the exact API response you'd get from your own integration without leaving the page.
* **Released:** August 24–28, 2026
## 4. Uploads and Dimensions — Fewer Rejected Inputs [#4-uploads-and-dimensions--fewer-rejected-inputs]
* **What's new:** Filenames containing `#`, filenames with no extension, and filenames with no name at all now upload successfully. Photos taken in portrait orientation on a phone have their EXIF rotation baked in at upload time, so they arrive the right way up — and as a side effect, EXIF and GPS metadata are stripped. On `gpt-image-2`, a requested width or height is snapped to the nearest supported multiple of 16 instead of returning an error.
* **Impact:** Files you already have work as inputs without renaming, re-exporting, or rounding dimensions by hand.
* **Released:** August 24–28, 2026
## 5. Clearer Errors — Moderation, Formats, and Empty Results [#5-clearer-errors--moderation-formats-and-empty-results]
* **What's new:** Content blocked by a provider's moderation is now labelled as **moderation** in the playground and in history, rather than surfacing as a generic failure. A request that completes with no output returns a moderation-style explanation instead of an `unknown output` response. The Sonilo music and sound-effects models accept `output_format` correctly, and a bad format now names the accepted values. Errors raised inside a serverless worker are preserved end to end instead of collapsing into one generic message.
* **Impact:** When a request doesn't return what you expected, the response tells you which of those things happened instead of leaving you to guess.
* **Released:** August 24, 2026
## 6. Request History — API Key Attribution and Failure Reasons [#6-request-history--api-key-attribution-and-failure-reasons]
* **What's new:** Request history now shows which API key produced each generation, displayed as a masked key name, and can be filtered by key. The **Source** filter selects a whole initiator family, so traffic sent through the SDKs appears under the filter you'd expect. Generations that failed now appear in your history with the reason they failed, including older history that had been hidden. A "see all history" deep link keeps its model, status, and date filters instead of dropping them on arrival.
* **Impact:** Trace any generation back to the key and the client that made it, see the failures alongside the successes, and land on a filtered view that stays filtered.
* **Released:** August 24–25, 2026
## 7. Dedicated Endpoints — Working Console Controls and Scoped Access [#7-dedicated-endpoints--working-console-controls-and-scoped-access]
* **What's new:** Create, pause, resume, purge, and delete all work again from the dedicated-endpoints console, and the endpoint detail page loads rather than failing on a dead request. **Purge Queue** is functional for the first time, backed by a new route. An endpoint's scaler configuration is now preserved across stop, resume, and update instead of reverting to defaults. The `/endpoint/usage`, `/history`, and `/billing` endpoints honour the `endpoints.view` scope, so team members without admin rights can read them.
* **Impact:** Manage a dedicated endpoint's full lifecycle from the console without losing your scaling settings, and give teammates read access to usage and billing without making them admins.
* **Released:** August 24–25, 2026
## 8. Pixelflow — Run Reliability and Canvas Stability [#8-pixelflow--run-reliability-and-canvas-stability]
* **What's new:** An LLM node wired into a media node now passes the resolved value rather than the whole raw JSON reply, and conflicting multi-input connections use an explicit keyed-object contract. Asset slugs resolve across both plain and fan-out connections, so templates like `{{ llm.text }}` work as written. Unsatisfiable multi-input wiring is flagged directly, and the misleading "run upstream first" message no longer appears on nodes that already succeeded. Read-only workflows can no longer be executed, so opening one has no billable side effects. On the canvas, pinch-zoom, two-finger pan, and scroll-to-zoom are restored on read-only and public workflows, and media decoding is bounded so larger graphs stay stable in the browser.
* **Impact:** Workflows that chain an LLM into a media model run correctly on the first attempt, and the canvas stays responsive as graphs grow.
* **Released:** August 24–28, 2026
## 9. Platform — Pricing Accuracy, Session Stability, and Model Access [#9-platform--pricing-accuracy-session-stability-and-model-access]
* **What's new:** Seedance 2.x model cards now show the full cost of a request, including reference video input, and Seedance 2.5's 1080p rates are listed. The `/pricing` page loads reliably. A backend hiccup while loading team details no longer signs every team member out. Model access restrictions are applied consistently across personal and team accounts, and restricted model information is served reliably to authorized team callers.
* **Impact:** The price shown before you run a Seedance job matches what you're billed, sessions survive a transient backend error, and model restrictions behave the same way on every call.
* **Released:** August 25–28, 2026
# Segmind Release Notes (August 31–September 6, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-09-06-weekly)
Segmind updates for August 31 to September 6, 2026: three new models (Sarvam Bulbul v3 TTS, Pruna video editing, MiniMax H3 Max Turbo), structured output for LLMs, named and model-scoped API keys, a Developer team role with team spending caps, OAuth connected apps, playground and Pixelflow improvements, and reliability fixes.
## 1. New Models — Sarvam Bulbul v3, Pruna Video Edit, MiniMax H3 Max Turbo [#1-new-models--sarvam-bulbul-v3-pruna-video-edit-minimax-h3-max-turbo]
* **What's new:** `sarvam-bulbul-v3-tts` brings Sarvam's Bulbul v3 text-to-speech to the API with 37 voices across 11 Indian languages, and a `language_code` parameter that pins the output language so mixed-script text no longer drifts. `p-video-edit` (Pruna) is an instruction-driven video-to-video editor that takes a source clip of up to 15 seconds plus up to four reference images, with a `draft` tier for quick, low-cost previews. `minimax-h3-max-turbo` is a single slug that runs MiniMax H3 Max Turbo as either text-to-video or image-to-video depending on the inputs you send.
* **Impact:** Natural Indian-language speech that stays in the language you asked for, prompt-based edits of existing footage, and MiniMax's latest video model behind one endpoint.
* **Released:** September 3–5, 2026
## 2. LLMs — Structured Output and Broader Provider Coverage [#2-llms--structured-output-and-broader-provider-coverage]
* **What's new:** Every LLM on the platform now honours an OpenAI-style `response_format`, so JSON-schema-constrained requests take effect instead of being silently ignored. The playground gained a structured-output control and the API docs describe the parameter. Anthropic models return a clear explanation when `json_object` is not supported and extract structured content safely across refusals and truncated replies. Empty chat requests are rejected with a `400` rather than being run — and billed — with filler tokens.
* **Impact:** Ask any chat model for schema-shaped JSON from the API or the playground and get it, with no charges for empty requests.
* **Released:** September 4–6, 2026
## 3. API Keys — Names, Per-Key Model Access, and One-Time Reveal [#3-api-keys--names-per-key-model-access-and-one-time-reveal]
* **What's new:** API keys can be named at creation and renamed later (`PUT /auth/rename-api-key`, or an optional `name` when generating), and those names now appear in cost analytics, API health, and CSV exports in place of masked strings. A key can be scoped to the models it is allowed to call via `PUT /auth/api-key-model-access` or the shield dialog on `/api-keys`, so a leaked credential can only reach the models you chose. The full key is now shown once at creation with a copy button, and is no longer retrievable from the key list. If key creation fails, the console shows the actual reason.
* **Impact:** Label machine keys by service, limit the blast radius of any single credential, and keep secrets out of the console after the moment you copy them.
* **Released:** August 31–September 3, 2026
## 4. Teams — Developer Role and Spending Controls [#4-teams--developer-role-and-spending-controls]
* **What's new:** A new **Developer** team role can create and manage API keys without billing, member, or team-settings powers. Team managers get a **Team Spending Cap** card on the team page to set daily, weekly, or monthly budgets with live per-period spend (`PUT /team/spending-cap` on the API), and newly invited members start with a default weekly budget. Budget alert emails now distinguish "nearly used up" (80%) from "reached" (100%), and format amounts to the precision of the limit.
* **Impact:** Hand out key-management access without granting admin, cap what a whole team can spend, and get alerts that say exactly where the budget stands.
* **Released:** August 31–September 3, 2026
## 5. OAuth — Consent Screen, Connected Apps, and MCP Connectors [#5-oauth--consent-screen-connected-apps-and-mcp-connectors]
* **What's new:** Third-party apps can now complete the OAuth flow end to end: the consent screen at `/oauth/consent` is live and shows the hostname the authorization code will be sent to, with a plain-language note for local desktop apps. A new `/connected-apps` page lists every app you've authorized and lets you revoke access. The authorization server also supports Client ID Metadata Documents and floating ports for loopback redirects, which is what tools like Claude Code and the OpenAI connector need to connect to the Segmind MCP server.
* **Impact:** Connect Segmind to MCP-capable assistants and other apps with a real consent step, then see and revoke those grants at any time.
* **Released:** September 4–6, 2026
## 6. Playground and Model Pages [#6-playground-and-model-pages]
* **What's new:** Each model's sample inputs are now a visible **Try an example** strip with thumbnails, and your pick survives a reload. Switching modes in the playground keeps your uploads (Seedance 2.5 no longer drops the start frame or reference media). Image attachments in LLM chat upload reliably on Gemini and other text-and-image models. For ElevenLabs models, the `voice_id` field searches the full Voice Library with sample playback, and any pasted id resolves to its voice. Long-context token pricing tiers are shown on every pricing surface and returned by the pricing API, and model prices on `/pricing`, model Pricing tabs, and `llms.txt` now match what you're billed. Brand searches in the site nav resolve to partner pages, the Stability AI partner page and several others load correctly, and missing or mismatched provider logos were fixed across the model list, Pixelflow picker, and partner cards.
* **Impact:** Pick an example, keep your inputs while you explore modes, find the exact voice you want, and see the right price before you run.
* **Released:** September 1–6, 2026
## 7. Restricted Models — Hidden by Default [#7-restricted-models--hidden-by-default]
* **What's new:** Models restricted to specific teams now carry a lock badge and are hidden from model listings and Pixelflow pickers unless you turn on **Show restricted models** — a toggle that is preserved in the URL, so a filtered view can be shared.
* **Impact:** Cleaner model lists for everyone, with one click to reveal what your team has been granted.
* **Released:** August 31–September 1, 2026
## 8. Pixelflow — Sharing, Assets, Connections, and Output Nodes [#8-pixelflow--sharing-assets-connections-and-output-nodes]
* **What's new:** Sharing a Pixelflow to a team now notifies its members. **Add to assets** works on every output. Multiple connections from one LLM node into a single node keep the same loop mode, so fan-out wiring is no longer dropped, and a connected string field stays in sync with its template. Output nodes gained three size modes (Fit to node, Fit to screen, 100%), a click-to-expand lightbox for single outputs, and larger header controls; node width stays consistent when changing modes, and a trackpad pinch zooms the canvas rather than the browser page.
* **Impact:** Share and build workflows with fewer surprises, and inspect outputs at whatever size you need without losing the canvas.
* **Released:** September 4–6, 2026
## 9. Request History — API Key Attribution Fully Live [#9-request-history--api-key-attribution-fully-live]
* **What's new:** The API-key column and **Key** filter on `/generations` are now fully backed by the platform, so filtering by key returns only that key's requests. The **Source: API** filter includes traffic from the Python SDK, which previously fell outside it.
* **Impact:** Trace every generation to the key and client that produced it, with filters you can trust.
* **Released:** August 31–September 5, 2026
## 10. Reliability and Clearer Errors [#10-reliability-and-clearer-errors]
* **What's new:** The Kokoro-82M TTS worker was rebuilt with roughly 3–4× faster cold starts and a polling loop that fails fast instead of stalling, resolving the queued-job delays some users saw. Upstream provider account faults (for example, a provider's own credit balance running out) are now detected and escalated on our side and no longer appear in your request history or error messages as if your balance were empty; affected Flux requests were never charged. Sarvam requests carry the provider's request id in an `X-Provider-Request-ID` response header for support traceability.
* **Impact:** Faster TTS starts, no misleading "insufficient credits" messages for problems that aren't yours, and a reference id when something needs investigating.
* **Released:** September 1–4, 2026
# Segmind Release Notes (September 7–13, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-09-13-weekly)
Segmind updates for September 7 to 13, 2026: new GPT Image 2.5 Flare and Sunburst models, Pruna p-video-2 with native audio, the Imagen slugs moved to Gemini 2.5 Flash Image, a Seedance 2.0 Mini price cut, parsed structured output for LLM calls, the hosted MCP server landing page, Pixelflow copy and paste across workflows, clearer moderation errors, and console improvements.
## 1. New Models — GPT Image 2.5 Flare and Sunburst, Pruna p-video-2 [#1-new-models--gpt-image-25-flare-and-sunburst-pruna-p-video-2]
* **What's new:** `gpt-image-2.5-flare` and `gpt-image-2.5-sunburst` are live on the platform, with per-token pricing shown on their model pages. `p-video-2` from Pruna generates video from text, an image, or an audio track, and produces native audio alongside the picture rather than a silent clip. The Topaz video upscaler also stopped downscaling its own output, so an upscale now returns the resolution you asked for.
* **Impact:** Two more OpenAI image models to choose from, a video model that ships with sound built in, and upscales that actually come back upscaled.
* **Released:** September 9–10, 2026
## 2. Imagen Slugs Now Served by Gemini 2.5 Flash Image [#2-imagen-slugs-now-served-by-gemini-25-flash-image]
* **What's new:** Google retired the Imagen models on Vertex AI. Every Imagen slug on Segmind keeps answering — requests are now served by `gemini-2.5-flash-image` behind the same slug, with the request and response contract kept field for field, so existing integrations need no code change. The `person_generation=dont_allow` value maps correctly on the new path instead of returning a `400`. The four retired Imagen model pages now redirect to `nano-banana-2`.
* **Impact:** No broken calls and nothing to migrate — your existing Imagen requests keep working, parameters included.
* **Released:** September 7–8, 2026
## 3. Seedance Pricing Reduced [#3-seedance-pricing-reduced]
* **What's new:** Seedance 2.0 Mini now bills at **$1.75 per million input tokens and $1.05 per million output tokens**, down from $3.50 and $2.10 — a 50% cut, reflected on the model page, `/pricing`, and `llms.txt`. Seedance 2.0 Fast also had its rate reduced; see the pricing page for its current numbers. Both cuts are forward-only, so past invoices are unchanged.
* **Impact:** Seedance 2.0 Mini costs half what it did last week, with no change to the API or the output.
* **Released:** September 11–13, 2026
## 4. Structured Output — Parsed Results and Documented Samples [#4-structured-output--parsed-results-and-documented-samples]
* **What's new:** v2 LLM calls now return parsed structured output directly, instead of handing back a string you have to parse yourself — an API contract change for callers using `response_format`. Every LLM model page now documents structured output, with `response_format` and a response example added to all 13 code samples. In Pixelflow, LLM nodes that fan out to other nodes enforce the JSON contract with `response_format`, so a stray preamble or an unexpected shape no longer breaks the fan-out region.
* **Impact:** Schema-shaped JSON arrives ready to use, copy-paste samples show exactly how to ask for it, and Pixelflow fan-outs stop failing on chatty model replies.
* **Released:** September 8–9, 2026
## 5. MCP — Landing Page and Connector Discovery [#5-mcp--landing-page-and-connector-discovery]
* **What's new:** A `/mcp` landing page for the hosted Segmind MCP server is live, with a copyable connector URL, setup tabs for Claude Code, ChatGPT developer mode, Codex and VS Code 1.106+, a reference for all 13 tools, and a model wall and FAQ. The authorization server now publishes RFC 8414 metadata at the location the spec requires, which is what MCP clients look for when connecting to `mcp.segmind.com`.
* **Impact:** Point an MCP-capable assistant at Segmind with a URL and a setup snippet, and clients that previously failed discovery now connect.
* **Released:** September 7–11, 2026
## 6. Pixelflow — Copy and Paste Across Workflows, Collaboration Signals, Masks [#6-pixelflow--copy-and-paste-across-workflows-collaboration-signals-masks]
* **What's new:** Nodes now copy and paste between workflows with `Cmd+C` / `Cmd+V`, plus `Cmd+X` to cut and `Cmd+D` to duplicate, carrying edges, parameters, fan-out settings and `{{ }}` variable references intact. Team workflows show who else is editing, warn you when a teammate has saved a version newer than the one you loaded, and record who wrote last. Draw mask has its own dock control and a standalone drawable mask renders as a tile. Dragging a file from your desktop lands anywhere on the canvas, file pickers accept as many files as the field allows, and a dragged asset previews as what it actually is rather than as the node's current mode. Models marked coming soon are hidden from the pickers and blocked at execution, so a placeholder can no longer fail at Run.
* **Impact:** Move a working subgraph into another workflow without rebuilding it, and see a teammate's edits before you overwrite them.
* **Released:** September 7–11, 2026
## 7. Clearer Moderation Errors [#7-clearer-moderation-errors]
* **What's new:** When a provider blocks a request for content reasons, the response now explains what was blocked instead of a generic "blocked by provider" line. The clearer messages cover the video models, xAI Grok, and the Wan and Qwen families, and they now survive the asynchronous worker path, so the reason reaches the caller reliably rather than only on some routes.
* **Impact:** When a generation is refused, you can tell why and adjust the prompt, instead of guessing.
* **Released:** September 7–8, 2026
## 8. Console — Sign-in, Mobile Navigation, and Request History [#8-console--sign-in-mobile-navigation-and-request-history]
* **What's new:** The sign-in page at `/auth/login` was rebuilt with a full-bleed video background drawn from recent model examples, and trimmed from roughly 802 KB to 382 KB per load — a 52% reduction. Accepting a team invitation no longer bounces between sign-in and the accept page. On mobile, two overlapping navigation triggers were replaced by a single bottom tab bar with a More sheet. The date picker on `/generations` now browses one month at a time and prevents ranges longer than 30 days from being selected. In the playground, a voice id that resolves to nothing shows a neutral note rather than a warning.
* **Impact:** A sign-in page that loads in half the bytes, team invites that complete on the first try, and a console that is usable on a phone.
* **Released:** September 7–9, 2026
# Segmind Release Notes (September 14–20, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-09-20-weekly)
Segmind updates for September 14 to 20, 2026: Anthropic's Claude 5 family (Opus 5, Sonnet 5, Fable 5.1) and a reasoning effort control that works the same way across 26 models.
## 1. New Models — Claude Opus 5, Sonnet 5, and Fable 5.1 [#1-new-models--claude-opus-5-sonnet-5-and-fable-51]
* **What's new:** Anthropic's Claude 5 family is on the API. `claude-opus-5` is the frontier model for coding, reasoning and agents; `claude-sonnet-5` is the most agentic Sonnet yet, with near-Opus coding and tool use; `claude-fable-5.1` is Anthropic's most capable model for coding, debugging and long-horizon reasoning. All three carry a 1M-token context window and think adaptively — the model decides how much reasoning a request needs, and you set the depth with `effort` (below). Two API details worth knowing: these models accept only `temperature: 1`, so any other sampling temperature is dropped, and at higher effort levels the reply begins with a `thinking` block, which means `content[0]` is not the text — read the first block whose `type` is `text`.
* **Impact:** Anthropic's newest models behind the same endpoint and key as everything else, with reasoning depth you control per request.
* **Released:** September 14, 2026
## 2. LLMs — Reasoning Effort Control [#2-llms--reasoning-effort-control]
* **What's new:** An `effort` parameter sets how hard a reasoning model thinks before it answers, using one vocabulary across providers: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. It is accepted on 26 models — Claude (Opus 5, Sonnet 5, Fable 5.1, Opus 4.7), OpenAI's reasoning models (o3, o3-mini, o4-mini, the GPT-5 family, GPT-6 Astra), Gemini 3.x, and Qwen 3.8 Max, GLM 5.2, MiniMax M3 and Nemotron 3 Ultra. Each model accepts the subset of levels it genuinely supports; those levels are listed on the model's API page and in its playground dropdown, and a level a model does not support is rejected with a message naming the ones it does, rather than being quietly downgraded. `reasoning_effort` is accepted as an alias. The control is also available on Pixelflow LLM nodes and appears in the code samples on every model's API page.
* **Impact:** Trade depth against cost and latency per request instead of living with each provider's default — one field that behaves the same way whichever model you call. Thinking is billed as output tokens: the per-token rate is unchanged, but a higher level spends more of them, so the same prompt costs more at a higher level. Each model's pricing page says so.
* **Released:** September 14–15, 2026
# Segmind Release Notes (September 21–27, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-09-27-weekly)
Segmind updates for September 21 to 27, 2026: model pages gain a Resources tab with per-model prompting guides — the same guidance the playground's Refine action uses — plus Seedance 2.5 Draft mode, a codec choice for Seedance video, Recraft V4 and Wan 3.0 Prime, a public key-less model catalog API, fuller generation history and CSV export, and Pixelflow fixes.
## 1. Model Pages — Resources and Per-Model Prompting Guides [#1-model-pages--resources-and-per-model-prompting-guides]
* **What's new:** Model pages now carry a **Resources** tab beside About and Guide, listing the files attached to that model with their format and size. The first of these are prompting guides for `flux-1.1-pro` and `p-image` — short, model-specific write-ups on what each one responds to, what to avoid, and how to phrase a prompt for it. This is the same document the playground's **Refine** action reads when it rewrites your prompt, so the guidance the model is given is now guidance you can read. A model with no attached files does not show the tab.
* **Impact:** The advice that used to sit behind the Refine button is readable directly, so you can write a good prompt yourself rather than round-tripping through the rewriter to find out what a model likes.
* **Released:** September 21, 2026
## 2. Seedance 2.5 — Draft Mode [#2-seedance-25--draft-mode]
* **What's new:** Send `"draft": true` to `POST /v1/seedance-2.5` and you get a fast, low-cost 480p preview plus a task id. When you like the shot, pass that id to `POST /v1/seedance-2.5-draft-final` as `draft_task_id` and the same generation is re-rendered at 1080p. A draft can be finalized for 7 days; the final render is billed at the 1080p rate. In the playground and Pixelflow, a draft result shows its task id as a copyable value with a **Render final in 1080p** action, and you can wire draft → final as two nodes in a flow.
* **Impact:** Iterate on prompts and motion at preview cost, and only pay for full-resolution output on the takes you keep.
* **Released:** September 25, 2026
## 3. Seedance 2.x — Choose Your Output Codec [#3-seedance-2x--choose-your-output-codec]
* **What's new:** A new `output_codec` parameter on the Seedance 2.x family controls how the video is delivered. Leave it out (or set `auto`) to receive the model's own encode byte-for-byte — the default and unchanged behavior. Set `h264` to have the file re-encoded to H.264 whenever the model returns HEVC. An unrecognized value is rejected at submit time, before anything is billed. Separately, Pixelflow now shows an explanatory placeholder for a video your browser can't decode, instead of an empty player bar.
* **Impact:** If your viewers are on browsers that don't play HEVC (for example Chrome or Firefox on Windows), ask for `h264` and the file plays everywhere; if you're post-processing the file yourself, you keep the original untouched.
* **Released:** September 21–23, 2026
## 4. New Models — Recraft V4 and Wan 3.0 Prime [#4-new-models--recraft-v4-and-wan-30-prime]
* **What's new:** The **Recraft V4** family is live in four variants: `recraft-v4` (text-to-image with accurate in-image text for design work), `recraft-v4-svg` (editable SVG vectors for logos, icons and illustrations), `recraft-v4-pro` (print-ready 2K design images) and `recraft-v4-pro-svg` (higher-quality editable vectors). Also new is `wan3.0-video-prime`, an accelerated Wan 3.0 video model at 480p, 720p and 1080p that runs roughly 1.4× faster than standard Wan 3.0, with native audio and lip-sync. All are on the API and selectable in the playground; per-request pricing is on each model's page.
* **Impact:** Vector-native, text-accurate design generation for brand and print work, and a faster route to Wan 3.0 video when turnaround matters.
* **Released:** September 24–27, 2026
## 5. Public Model Catalog API [#5-public-model-catalog-api]
* **What's new:** `GET https://api.segmind.com/models` returns the full Segmind catalog — no API key required. Each entry includes the slug, name, description, category, input/output modality, provider, average cost, typical latency, a popularity score and the model's parameter schema. The list can be filtered server-side (`q`, `input`, `output`, `provider`, `min_cost`/`max_cost`, `max_latency`, `created_after`, `is_new`, `slugs`) and sorted by `popular`, `newest`, `name`, `cheapest`, `fastest` or `relevance`; add `facets=true` to get counts per category, modality and provider for building filter UIs. Look up a single model with `GET https://api.segmind.com/model/`. Requests are rate-limited per IP.
* **Impact:** Build model pickers, availability checks or "cheapest video model that takes an image" queries straight against the live catalog, without scraping pages or hard-coding slugs.
* **Released:** September 24–26, 2026
## 6. Generation History — Cost, Prompts and Full CSV Export [#6-generation-history--cost-prompts-and-full-csv-export]
* **What's new:** `GET /inference-request/generations` now returns each request's `status`, its cost (`credits_deduction`, in USD), the prompt and the full parameters, alongside the ids and output URLs it already returned — existing fields are unchanged. In the console, **Export CSV** on the Generations page now exports every request matching your current filters (up to 10,000, one sheet per model) with all parameters, not just the rows visible on screen.
* **Impact:** Reconcile spend per generation and reproduce any past result from your own records, whether you pull history through the API or download it from the console.
* **Released:** September 23, 2026
## 7. Pixelflow Improvements [#7-pixelflow-improvements]
* **What's new:** Files you upload into a workflow's input nodes are now saved to your asset library when you save or publish, so published flows and templates keep working after temporary upload links expire — existing workflows have been migrated. Published workflow APIs now pass through every setting on an LLM node (for example `web_search: true` on Gemini), so a published flow behaves exactly like it does in the editor. Dropdown, number and toggle defaults on older nodes are now sent correctly (Bria Expand's `aspect_ratio` works on first run), and on phones the editor opens with the models panel closed and the toolbar no longer covers the workflow title. **Bundle** pages have been redesigned so each bundle lists every included workflow, with featured ones marked.
* **Impact:** Published Pixelflow APIs are more reliable and match what you built, and workflows are easier to edit on mobile and to browse in bundles.
* **Released:** September 23–26, 2026
## 8. Playground and Account [#8-playground-and-account]
* **What's new:** Every playground output now has an info button that opens a **generation details** panel — the same view as in the console — and timings that weren't recorded are omitted rather than shown as "0.0s". The OAuth consent screen explains the `keys:write` permission in plain language ("create and revoke API keys", without being able to read existing keys). Links into the console now survive sign-in, so a top-up link opens checkout after you log in, and old `cloud.segmind.com/console/…` links redirect to the matching page on `platform.segmind.com`. The sidebar plan card's **Upgrade** button now opens the plan picker directly.
* **Impact:** Fewer dead ends — bookmarks, emailed links and third-party "connect your Segmind account" flows land where they should, and you can see exactly how any playground result was produced.
* **Released:** September 21–27, 2026
# Segmind Release Notes (September 28–October 4, 2026) (https://docs.segmind.com/docs/platform/release-notes/2026-10-04-weekly)
Segmind updates for September 28 to October 4, 2026: Gemini 3.8 Flash TTS and Flash-Lite TTS, Ideogram 4.5 generate and edit, a ModelArk artifact verification endpoint, Seedance 2.5 draft-to-1080p hand-off, a redesigned homepage and models page, richer model pages, and Pixelflow LLM node improvements.
## 1. New Models — Gemini 3.8 Flash TTS and Flash-Lite TTS [#1-new-models--gemini-38-flash-tts-and-flash-lite-tts]
* **What's new:** **Gemini 3.8 Flash TTS** and **Flash-Lite TTS** are live on the API. Both return WAV audio directly and accept multi-speaker input with per-turn style direction, so a single request can voice a whole conversation with a different voice and delivery for each speaker. Pricing is token-based and listed on each model's page.
* **Impact:** Produce multi-voice dialogue, narration and podcasts-style audio in one call, with a lighter Flash-Lite option when speed and cost matter most.
* **Released:** September 30, 2026
## 2. New Models — Ideogram 4.5 [#2-new-models--ideogram-45]
* **What's new:** **Ideogram 4.5** is now available as `ideogram-4.5` for text-to-image generation and `ideogram-4.5-edit` for precise edits to an existing image. Both are on the API and selectable in the playground.
* **Impact:** Generate images with strong in-image typography, and make targeted changes to an existing picture without regenerating it from scratch.
* **Released:** October 1, 2026
## 3. Model Artifact Verification Endpoint [#3-model-artifact-verification-endpoint]
* **What's new:** A new `modelark-artifact-verification` model lets you submit an image or video and find out whether it was generated by a BytePlus ModelArk model such as Seedance or Seedream. It appears in the new video-to-text category alongside image-to-text models, with filters and playground samples to match.
* **Impact:** Check the provenance of AI-generated media directly through the Segmind API.
* **Released:** September 30, 2026
## 4. Seedance 2.5 — Easier Draft-to-Final Hand-off [#4-seedance-25--easier-draft-to-final-hand-off]
* **What's new:** Draft results in the playground History now show a **Render final in 1080p** link for 7 days after the draft, and the draft task id is a copyable row in the generation info sheet and the console Generations detail. The request-history API now returns `draft_task_id` for completed Seedance 2.5 draft requests.
* **Impact:** Find any recent draft and promote it to a full 1080p render in one click, or look up its id programmatically — no need to keep the id yourself.
* **Released:** September 30, 2026
## 5. Homepage and Models Page Refresh [#5-homepage-and-models-page-refresh]
* **What's new:** The segmind.com homepage has a new **model bookshelf** under the hero: the 100 newest models as book-cover cards with Latest, Popular and modality filters. A new **real-world use cases** section (Catalog, Adapt, Localize, Storyboard, Personalize) shows live customer flows, and the mobile layout is cleaner with finished output cards and a swipe-to-open model shelf. The models page banner highlights the newest frontier models, banner titles no longer clip descenders, and the cookie banner is now a compact card with equally prominent Accept and Reject options. The Cookie Policy now displays with proper headings and bullets.
* **Impact:** Discover new models faster, see how Segmind workflows apply to real jobs, and manage cookie consent with less friction.
* **Released:** October 1–5, 2026
## 6. Model Pages — Richer Context and Better Discovery [#6-model-pages--richer-context-and-better-discovery]
* **What's new:** Each model's FAQ now has its own tab, with all tabs available in the page's server-rendered content. The `llms.txt` for each model now includes About, Usage, Prompting, FAQ and Examples, so AI assistants that open a model page (such as Open in ChatGPT or Claude, or MCP clients) get fuller context. The Related Models rail now ranks by usage and recency, and gains a **Most popular** sort.
* **Impact:** Find the right model faster, and get more accurate help from AI assistants when working with a model.
* **Released:** September 29–October 1, 2026
## 7. Pixelflow — LLM Node and Editor Improvements [#7-pixelflow--llm-node-and-editor-improvements]
* **What's new:** A new visual field builder lets you compose an LLM node's structured output without hand-writing JSON, and the **Response format** is editable again and validated against the selected model. An LLM node now stops with a clear error when its reply doesn't match the declared format, and plain-edge hints no longer conflict with a node's own JSON format. Videos show their first frame instead of a black box before playback, nodes for models with no listed parameters render correctly, and the Ask Pixi panel on a prompt field closes when you click outside it. Team admins can now rename a team, and the workspace switcher scrolls when you have many workspaces.
* **Impact:** Build reliable structured-output flows more easily, preview video results at a glance, and manage team workspaces with less friction.
* **Released:** October 2–3, 2026
## 8. Platform Improvements [#8-platform-improvements]
* **What's new:** The asset library now accepts **AVIF** images. The playground keeps the newest generation on the canvas when an older run finishes late. Exporting generations to CSV or Excel no longer stalls on requests with long prompts. API keys created through an authorized third-party app are now tied to that app, so disconnecting the app also revokes the keys it created.
* **Impact:** More upload formats, a steadier playground, dependable exports, and tighter control over what connected apps can leave behind.
* **Released:** September 29–October 3, 2026
# Release Notes (https://docs.segmind.com/docs/platform/release-notes)
New models, API features, and platform improvements on Segmind — summarized every week.
What's new on Segmind — new models, API capabilities, PixelFlow upgrades, and other platform improvements, summarized each week. Select any entry for the full notes.
# Endpoint APIs (https://docs.segmind.com/docs/serverless-api/dedicated-endpoints/endpoint-apis)
Endpoints can be managed via APIs as well as UI. Use the APIs to create/delete endpoints, update capacity or other configuration parameters for each endpoint.
## List All Endpoints: [#list-all-endpoints]
```
curl 'https://api.spotprod.segmind.com/endpoint/list' \
--header 'content-type: application/json' \
--header 'x-api-key: SG_XXXXX'
```
## Add Endpoint [#add-endpoint]
```
curl 'https://api.spotprod.segmind.com/endpoint/add' \
--header 'content-type: application/json' \
--header 'x-api-key: SG_XXXXX' \
--data-raw '{"endpoint_name":"replace-with-endpoint-name","model_name":"replace-with-model-name","workers_min":0,"workers_max":1,"idle_timeout":60,"execution_timeout":600,"scaler_type":"REQUEST_COUNT","scaler_value":1,"gpu_id":"AMPERE_80"}'
```
## Update Endpoint [#update-endpoint]
```
curl -XPUT 'https://api.spotprod.segmind.com/endpoint/update' \
--header 'content-type: application/json' \
--header 'x-api-key: SG_XXXXX' \
--data-raw '{"workers_min":0,"workers_max":2,"endpoint_id":"tpr9hugy367nbz","scaler_type":"REQUEST_COUNT","scaler_value":1,"idle_timeout":60,"execution_timeout":600,"force_update":false}'
```
Use this API to automate endpoint capacity updates on schedule or demand
## Delete Endpoint [#delete-endpoint]
```
curl -XDELETE 'https://api.spotprod.segmind.com/endpoint/delete' \
--header 'content-type: application/json' \
--header 'x-api-key: SG_XXXXX' \
--data-raw '{"endpoint_id":"tpr9hugy367nbz"}'
```
`-XDELETE` is required. `/endpoint/add`, `/endpoint/update` and `/endpoint/delete`
are all served by the same resource, which picks the operation from the HTTP
method rather than the path. Without it, `--data-raw` makes curl send a POST, and
the request is handled as an endpoint **creation** — failing on the arguments it
expects for a new endpoint instead of deleting anything.
# Getting started (https://docs.segmind.com/docs/serverless-api/dedicated-endpoints/getting-started)
Find the Endpoints page in the Segmind console, deploy a model onto your own GPUs, and manage the endpoints you have running.
Dedicated endpoints run a model on GPUs reserved for you, rather than on the
shared pool the [AI Gateway](/docs/serverless-api) uses. See
[the overview](/docs/serverless-api/dedicated-endpoints) for when that is worth
paying for.
## Finding Endpoints [#finding-endpoints]
Sign in to the console and open **Endpoints** from the left nav.
The page lists every endpoint you have running. Before you deploy one it shows
**No endpoints deployed**; afterwards each row can be started, stopped or
deleted, and carries a usage view broken down by time.
**Deploy Endpoint**, top right, starts a new one.
## What you choose when deploying [#what-you-choose-when-deploying]
Deploying asks for four things:
| Setting | What it decides |
| --------------------------------- | ---------------------------------------------------------------------------- |
| **Model** | which model runs on the endpoint |
| **Endpoint URL** | a name of your own, which becomes the address you call |
| **GPU type** | the card the model runs on — the larger the card, the higher the hourly rate |
| **Baseline and autoscaling GPUs** | how many are always on, and how many may spin up under load |
The instance panel shows the GPU, CPU and RAM you have selected along with the
hourly rate, so the cost is visible before anything launches. Current rates are
on the [pricing page](https://www.segmind.com/pricing) — they are not repeated
here, because a number in the docs goes stale the moment hardware pricing moves.
A dedicated endpoint bills for **the time it is up**, not per request. A
baseline GPU left running costs money whether or not you call it — stop or
delete endpoints you are not using. The
[overview](/docs/serverless-api/dedicated-endpoints#pricing) explains how
baseline and autoscaling hours are charged.
## Calling your endpoint [#calling-your-endpoint]
Once an endpoint is running, call it with your API key exactly like any other
Segmind model. See [Endpoint APIs](/docs/serverless-api/dedicated-endpoints/endpoint-apis)
for the request shape.
# Dedicated Endpoints (https://docs.segmind.com/docs/serverless-api/dedicated-endpoints)
Endpoints are GPU instances enabling AI models to be deployed on dedicated hardware . This enables private inferences that automatically scale up or down based on traffic.
## Overview [#overview]
By using Endpoints, Segmind users can unlock the full potential of AI models, enabling them to build innovative applications that drive business growth and solve real-world challenges easily and reliably.
* **Blazingly fast:** Endpoints with 1+ baseline GPUs are the fastest way to inference on Segmind platform for any models.
* **Private by default**: Endpoints allows developers to perform **private** inference on their models. This ensures that latency and other runtime metrics are not affected by other users’ requests, unlike the public endpoints, which utilise a shared queue for all users.
* **Scalable by design:** Endpoints offer scalable inference by handling large volumes of requests concurrently. Developers can specify up to 10 max workers to process multiple requests simultaneously. Endpoints also provide full control over scaling policies, enabling developers to manage complex and high-throughput workloads efficiently.
* **Cost-effective**: With an option to specify a maximum limit for autoscaling workers, developers can set predictable costing for their endpoints. For 0-n setups, there is no upfront commitment, allowing seamless scale with increasing traffic, on a **pay-as-you-go** setup.
* **Choose your own hardware** : Developers have the option to choose among a wide variety of GPU options for balancing price and performance. The cards on offer and their hourly rates are on the [pricing page](https://www.segmind.com/pricing); you pick one while deploying.
## How it works [#how-it-works]
For creating an Endpoint, you specify the model, the GPU type and a URL slug for exposing your endpoint. Once created, Segmind allocates a cluster of GPU instance(s) for the specified model. These GPU instances act as dedicated computing resources responsible solely for executing inference requests on the specified slug.
When an inference request is received, Endpoint efficiently routes it to the appropriate instance in a round robin fashion, ensuring fast and reliable processing.
Autoscaling instances are automatically spun up for each request, if the baseline GPUS are busy. The GPUs stay up for some time after processing a request, which is defined by `idle_timeout`.
Requests on both Baseline and Autoscaling GPUs will be terminated after a duration defined by `execution timeout`. Use this to control your costs in some cases where the GPU might be stuck. The request will fail, but the baseline GPU will become available much faster, in case of errors or wrong inputs.
All user endpoints are private, meaning only the user who created the endpoint can inference on the endpoint using their API key. [Segmind Models](https://www.segmind.com/models) are all hosted on public endpoints.
### Pricing [#pricing]
Endpoints are charged hourly depending on total usage = baseline + autoscaling. There is no additional cost for inference requests to endpoints.
24 hours of runtime cost is required as credit balance for creating/updating endpoints. Users receive a warning mail when their balance drops below 10 hours of runtime. And all endpoints are turned off once user credit balance goes below $10.
### Autoscaling [#autoscaling]
While creating endpoints, number of Baseline and Autoscaling GPUs need to be specified.
**Baseline instances** are always-on machines, providing a solid low-latency starting point for handling consistent workloads.
**Autoscaling instances**, on the other hand, dynamically spin up and down based on demand, ensuring that resources are allocated only when necessary, albeit with a cold-start latency of around 5-500s. \\
Baseline workers specify minimum number of GPUs, that are always on. Autoscaling workers are turned on only whenever required, and are billed by second. \
To determine your required configuration, we suggest starting with 1-2 setup, and do a load test to check out response times with increasing traffic.
### Advanced Configuration [#advanced-configuration]
Endpoints offers advanced autoscaling capabilities through **idle timeouts, execution timeout** and **scaling policy.**
* Idle timeout: How much time should the scaled worker continue to run after it has processed request. Defaults to 10s. This can be increased to 300s to avoid cold starts.
* Execution timeout: Max time for an inference request, after which the request is terminated. Default is 600s.\\
This scaling approach ensures efficient resource utilisation, minimizing costs while maintaining peak performance, all while giving control to the users for managing their costs and usage.
### Examples [#examples]
**Development/Testing** (0-1 setup): Basic serverless setup, good for testing models. High latency, as almost all requests require cold start. Low and predictable cost (0 commitment, 1 max)
**Serverless auto scaling setup** (0-5 setup): Good for cases where cold starts are not a concern, like batch jobs. Can scale upto 5 machines. Low cost (0 commitment, 5 max)
**Production setup** (2-10) : Production grade auto-scaling inference setup. 2 dedicated GPU machines running all the time, which scales up to 10 during peak traffic. Low latency.
**RPM calculation**
Consider [**faceswap-v2**](https://www.segmind.com/models/faceswap-v2) for example. The average latency for this model is \~6s. The average RPM supported by each machine can be estimated as 60/6 = 10. \
So 1 machines can support 10 requests every minute, and each autoscaling workers can handle 10 additional requests per minute on demand.
Assume an app expects 20 requests per minute, that can go upto 100 during peak times. Then the minimum recommended configuration is 2-10. For even lower response times, we suggest setting a higher number of baseline GPUs. It should be noted that 0-10 would also work fine, though the response times would be higher for endpoints without any baseline GPU.
#### Colocation [#colocation]
Contact Segmind support to deploy multiple models on a single endpoint or increase the max limits for workers.
## Getting started [#getting-started]
See [Getting started](/docs/serverless-api/dedicated-endpoints/getting-started) for creating and managing your endpoints, and [Endpoint APIs](/docs/serverless-api/dedicated-endpoints/endpoint-apis) for calling one.