Segmind Storage

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 files to Segmind Storage and receive a URL that can be used across different models.

Endpoint

POST https://workflows-api.segmind.com/upload-asset

Headers

Request Body

The request body should be a JSON object with the following structure:

{
  "data_urls": ["data:image/jpeg;base64,..."]
}

Data URL Format

Files should be provided as base64-encoded data URLs in the format:

data:<mime-type>;base64,<base64-encoded-content>

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

Upload files to Segmind Storage using your preferred programming language.

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..."]}'

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

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

{
  "file_urls": [
    "https://images.segmind.com/assets/you@example.com/images/fb61f8b1-731e-42fd-988e-675965942a8d.jpg"
  ],
  "message": "Files uploaded successfully"
}

These URLs can then be used as inputs for various models on the Segmind platform — pass one wherever a model takes an image URL.

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

• 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

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:

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.

{ "error": "No valid files or data URLs provided" }

Rate Limits

Asset uploads are subject to the standard Segmind API rate limits. Refer to the Rate Limits documentation for more information.