Segmind AI Documentation

https://docs.segmind.com
Admin
Segmind AI Platform allows users to create and build with generative AI, offering state-of-the-art...
Tokens:124,497
Snippets:1,260
Trust Score:9.9
Update:2 days ago
Show doc for...
Tokens:
Raw
================
LIBRARY RULES
================
- To check whether Segmind supports a model (and get its parameters), query the live catalog — segmind.models.list() or GET https://api.spotprod.segmind.com/inference-model-information/list (public, no auth) — rather than relying on any static model list;

================
CODE SNIPPETS
================
### Install the Segmind Python SDK

Source: https://docs.segmind.com/docs/sdks/python

Install the SDK with pip, requiring version 1.2.0 or later. This is the first step before using any Segmind model.

```bash
pip install "segmind>=1.2.0"
```

--------------------------------

### Full example in cURL

Source: https://docs.segmind.com/docs/pixelflow/api-reference

Full workflow example in cURL: submit a workflow, poll until COMPLETED, then fetch the result. Uses the SEGMIND_API_KEY environment variable for authentication.

```bash
# 1. Submit
curl -X POST "https://api.segmind.com/workflows/v2/<your-workflow-slug>" \
  -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 "<poll_url>" \
  -H "x-api-key: $SEGMIND_API_KEY"

# 3. Fetch the result
curl -X GET "<response_url>" \
  -H "x-api-key: $SEGMIND_API_KEY"
```

--------------------------------

### Full example in Python

Source: https://docs.segmind.com/docs/pixelflow/api-reference

Full workflow example in Python: submit a workflow, poll until COMPLETED or FAILED, then fetch the result and parse the output. Uses the SEGMIND_API_KEY environment variable.

```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/<your-workflow-slug>",
    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)
```

--------------------------------

### Full example in JavaScript

Source: https://docs.segmind.com/docs/pixelflow/api-reference

Full workflow example in JavaScript: submit a workflow, poll until COMPLETED or FAILED, then fetch the result and parse the output. Uses the SEGMIND_API_KEY environment variable.

```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/<your-workflow-slug>",
  {
    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);
```

--------------------------------

### Sample Response for Get Details

Source: https://docs.segmind.com/docs/fine-tuning/apis/fast-flux

Sample response for the get details request. Contains the full finetune object with status, model paths, and timestamps.

```json
{
  "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"
  }
}
```

--------------------------------

### Check status with curl using status_url

Source: https://docs.segmind.com/docs/serverless-api/async-inference

GET request to the status_url endpoint for lightweight polling. Returns only status and metrics, no output payload. Example shows the response while processing (status QUEUED) and when done (status COMPLETED with metrics).

```bash
curl "https://api.segmind.com/v2/requests/2c7f59ea-.../status" \
  -H "x-api-key: YOUR_API_KEY"
```

```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": {}
}
```

```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
  }
}
```

--------------------------------

### Audio ducking example for /v2/timeline

Source: https://docs.segmind.com/docs/serverless-api/video-editing

An audio clip can duck against another track, the usual way to put music under a voiceover. 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.

```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 } }
]}
```

--------------------------------

### Initiate Fine-Tune Request

Source: https://docs.segmind.com/docs/fine-tuning/apis/qwen

Initiates a Qwen fine-tuning job. Requires a valid public ZIP URL or a Segmind presigned URL for data_source_path. Uses NVIDIA_H100 GPU and LORA training.

```bash
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
    }
}'
```

--------------------------------

### Quick start: Async (default) with segmind.run

Source: https://docs.segmind.com/docs/sdks/python

Default async usage: submits to v2, polls until COMPLETED, returns the result body. Prints the URL to the generated image.

```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
```

--------------------------------

### Sample Response for Initiate

Source: https://docs.segmind.com/docs/fine-tuning/apis/qwen

Sample response from the submit endpoint, indicating the job was requested.

```json
{
    "status": "REQUESTED",
    "request_id": "uuid",
    "name": "fine-tune-job-name"
}
```

--------------------------------

### Decode async structured output

Source: https://docs.segmind.com/docs/serverless-api/structured-outputs

For async inference, the provider response is a string in the output field. Decode twice: first to get the envelope, then 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
```

--------------------------------

### Make your first Segmind API request with cURL, Python, or JavaScript

Source: https://docs.segmind.com/docs/get-started

Make a first Segmind API request to the fast-flux-schnell model on the AI Gateway. The response body is the image, not JSON, so these examples write it to output.jpg. Replace YOUR_API_KEY with your own key before running.

```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()));
```

--------------------------------

### Quick start: Sync with segmind.run_sync

Source: https://docs.segmind.com/docs/sdks/python

Single blocking v1 call that returns a raw httpx.Response. Writes the binary content to a file.

```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)
```

--------------------------------

### Get Fine-Tune Request Details - curl request

Source: https://docs.segmind.com/docs/fine-tuning/apis/flux-pro

Retrieve details of a specific fine-tuning request using the GET /finetune/request/details endpoint. Requires the x-api-key header and a JSON body with the request_id.

```bash
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"
}'
```

--------------------------------

### Make first Segmind API request with fast-flux-schnell (cURL, Python SDK, Python HTTP, JavaScript)

Source: https://docs.segmind.com/docs/get-started/quickstart

Send a text-to-image request to the fast-flux-schnell model on the Segmind API. The response body is the image, so the cURL example requires --output to avoid printing binary data to the terminal. The Python SDK example uses segmind.run() and prints the returned image URL; the HTTP examples write the image to output.jpg.

```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"
  }'
```

```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
```

```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()));
```

--------------------------------

### Python Upload Example

Source: https://docs.segmind.com/docs/serverless-api/segmind-storage

Upload a file to Segmind Storage using Python. Reads an image file, encodes it to base64, sends a POST request, and prints the uploaded asset URL.

```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}")
```

--------------------------------

### Download Fine-Tuned Safetensor File - sample response

Source: https://docs.segmind.com/docs/fine-tuning/apis/qwen

Sample response showing a pre-signed URL for downloading the fine-tuned model file, with expiration parameters.

```text
https://segmind-sd-models.s3.amazonaws.com/finetune/finetuned_models/job_id/filename.safetensors?AWSAccessKeyId=***&Signature=***&Expires=***
```

--------------------------------

### Submit and poll async request with Python requests

Source: https://docs.segmind.com/docs/serverless-api/async-inference

Raw Python example showing the submit-and-poll loop for the async inference API. The Python SDK does this automatically via segmind.run; this example calls the API directly. Replace YOUR_API_KEY with your actual key.

```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")
```

--------------------------------

### GET /endpoint/list

Source: https://docs.segmind.com/docs/serverless-api/dedicated-endpoints/endpoint-apis

Lists all endpoints associated with the API key.

```APIDOC
## GET /endpoint/list

### Description
Lists all endpoints associated with the API key.

### Method
GET

### Endpoint
https://api.spotprod.segmind.com/endpoint/list

### Parameters
#### Headers
- **content-type** (string) - Required - Must be `application/json`
- **x-api-key** (string) - Required - Your API key (e.g., `SG_XXXXX`)

### Request Example
```
curl 'https://api.spotprod.segmind.com/endpoint/list' \
  --header 'content-type: application/json' \
  --header 'x-api-key: SG_XXXXX'
```

### Response
No response schema is documented in the source.

```

--------------------------------

### GET /finetune/request/details

Source: https://docs.segmind.com/docs/fine-tuning/apis/flux-pro

Retrieve a fine-tuning request along with details.

```APIDOC
## GET /finetune/request/details

### Description
Retrieve a fine-tuning request along with details.

### Method
GET

### Endpoint
https://api.segmind.com/finetune/request/details

### Parameters
#### Request Body
- **request_id** (string) - Required - The ID of the fine-tuning request.

### Request Example
```
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"
}'
```

### Response
#### Success Response (200)
- **finetune** (object) - Details of the fine-tuning request.
  - **id** (string) - UUID of the fine-tune record.
  - **finetune_id** (string) - UUID of the fine-tune request.
  - **name** (string) - Name of the fine-tune job.
  - **data_source_path** (string) - URL to the dataset zip file.
  - **instance_prompt** (string) - Instance prompt used for training.
  - **status** (string) - Status of the fine-tune (e.g., AVAILABLE).
  - **source_type** (string) - Source type (e.g., AWS_S3).
  - **base_model** (string) - Base model name.
  - **slug** (string) - Model slug.
  - **public_model** (boolean) - Whether the model is public.
  - **error_message** (string or null) - Error message if any.
  - **cloud_storage_url** (string or null) - URL to the trained model file.
  - **created_ts** (string) - Creation timestamp.
  - **updated_ts** (string) - Last update timestamp.

#### Response Example
```
{
  "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"
  }
}
```
```

--------------------------------

### Node.js Upload Example

Source: https://docs.segmind.com/docs/serverless-api/segmind-storage

Upload a file to Segmind Storage using Node.js. Reads an image file, encodes it to base64, sends a POST request with fetch, and logs the uploaded 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]}`);
})();
```
Tokens:
Raw