Model Parameters

Discovering Parameters

Every model has its own set of input parameters. Use the /Tool/Detail endpoint to retrieve a model's parameter definitions. The response includes a parameters array where each item describes a parameter group with its items:

{
  "parameters": [
    {
      "title": "Input",
      "items": [
        {
          "id": "prompt",
          "type": "textarea",
          "label": "Prompt",
          "required": true,
          "placeholder": "Describe what you want...",
          "note": "Text description of the desired output"
        },
        {
          "id": "inputImage",
          "type": "fileinput",
          "label": "Input Image",
          "required": true,
          "note": "Upload an image or provide a URL"
        }
      ]
    }
  ]
}

Parameter Types

JSON vs Multipart

The content type of your request depends on whether the model requires file inputs:

File Upload Patterns

Single File (fileinput)

For parameters like inputImage, send either a file or a URL. When using multipart, always include both the {id} and {id}Url fields and leave one empty:

# Option 1: Upload file — send file in {id}, empty {id}Url
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImage=@/path/to/photo.jpg" \
  -F "inputImageUrl="

# Option 2: Send URL via {id}Url — send empty {id}, URL in {id}Url
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImage=" \
  -F "inputImageUrl=https://example.com/photo.jpg"

Multiple Files (multifileinput)

For parameters like inputDocumentMultiple, send either up to N files or a comma-separated list of URLs. The URL list goes in the field that puts Url before Multiple: inputDocumentUrlMultiple. When using multipart, include both fields and leave one empty:

# Option 1: Upload files in {id}, leave inputDocumentUrlMultiple empty
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputDocumentMultiple=@doc1.pdf" \
  -F "inputDocumentMultiple=@doc2.pdf" \
  -F "inputDocumentUrlMultiple="

# Option 2: Send comma-separated URLs in inputDocumentUrlMultiple, leave {id} empty
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputDocumentMultiple=" \
  -F "inputDocumentUrlMultiple=https://example.com/doc1.pdf,https://example.com/doc2.pdf"

Combined (combinefileinput)

For parameters like inputImageClothes, files and URLs go directly in the same {id} field, with no {id}Url suffix:

# Option 1: Upload files — each as a separate {id} entry
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImageClothes=@shirt.jpg" \
  -F "inputImageClothes=@pants.jpg"

# Option 2: Send URLs — each directly in {id}
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImageClothes=https://example.com/shirt.jpg" \
  -F "inputImageClothes=https://example.com/pants.jpg"

# Option 3: Mixed — files and URLs in the same {id} field
curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImageClothes=@shirt.jpg" \
  -F "inputImageClothes=https://example.com/pants.jpg"

Common Model Patterns

Image Generation (text-to-image)

Models like Stable Diffusion, Flux (JSON body, no file uploads):

{
  "prompt": "A futuristic city at sunset",
  "negative_prompt": "blurry, low quality",
  "width": 1024,
  "height": 1024
}

Image-to-Image (upscaler, style transfer)

Models that take an input image (multipart with file upload):

curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImage=@photo.jpg" \
  -F "scale=4"

Virtual Try-On

Multiple image inputs (multipart with multiple files):

curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputImageHuman=@person.jpg" \
  -F "inputImageClothes=@shirt.jpg"

LLM / Document Processing

Text prompt with optional document uploads:

curl -X POST "https://api.wiro.ai/v1/Run/{owner-slug}/{model-slug}" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "inputDocumentMultiple=@resume.pdf" \
  -F "prompt=Extract the candidate name and skills" \
  -F "outputType=json" \
  -F "language=en"

Realtime Voice Conversation

Realtime voice models accept configuration parameters (voice, system instructions, audio format, etc.) as JSON. Parameters vary per model. Use /Tool/Detail to discover them. The actual audio interaction happens over Realtime Voice WebSocket after the task starts:

Available realtime models include:

• openai/gpt-realtime-mini
• openai/gpt-realtime
• elevenlabs/realtime-conversational-ai

// Example: OpenAI GPT Realtime
{
  "voice": "marin",
  "system_instructions": "You are a helpful voice assistant.",
  "input_audio_format": "audio/pcm",
  "output_audio_format": "audio/pcm",
  "input_audio_rate": "24000",
  "output_audio_rate": "24000"
}

Realtime Text to Speech

Realtime TTS models stream synthesized audio back over WebSocket as binary frames. Text is required. Reference audio is optional for voice cloning.

Available realtime TTS models include:

• openmoss/moss-tts-realtime

{
  "text": "Hello, this is a test of real-time text to speech.",
  "inputAudio": "",
  "temperature": 0.8,
  "topP": 0.6,
  "topK": 30,
  "repetitionPenalty": 1.1,
  "repetitionWindow": 50,
  "maxLength": 3000
}

Realtime Speech to Text

Realtime STT models transcribe audio streamed from the microphone over WebSocket. No text input is needed: audio is streamed from the microphone. The transcriptionDelay controls the speed vs accuracy trade-off.

Available realtime STT models include:

• mistralai/voxtral-mini-4b-realtime-2602

{
  "transcriptionDelay": "balanced"
}

Webhook Callback

All models support an optional callbackUrl parameter. When provided, Wiro will POST the task result to your URL when the task completes, so you do not need to poll:

{
  "prompt": "A sunset over mountains",
  "callbackUrl": "https://your-server.com/webhook/wiro"
}

Wiro sends a POST request with a JSON body (Content-Type: application/json) once the task has finished, whether it succeeded or failed: check pexit in the body. The body is the task, including its parameters and outputs.

• Any 2xx answer counts as delivered. Answer with a 2xx as soon as the request arrives, and do slower work after that.
• Up to 3 tries. When your endpoint answers with anything other than a 2xx, or cannot be reached, Wiro tries again 2 seconds later, up to 3 tries in all.
• Redirects are not followed. A 3xx answer counts as not delivered, so pass the final address.
• No authorization header. To check that a webhook comes from your own run, match its task ID with your records.

The callbackUrl must be a public http(s) address. A host that is, or resolves to, a private, loopback or link-local address gets no webhook; the task still runs. When a webhook does not arrive, poll Task/Detail with the task ID to get the result.