Replicate 🔄

Run any open-source ML model with a single API call.

🎨

What you can do: Image generation (FLUX, SDXL), video generation, audio, language models, and thousands of community models with simple API access.

Setup

Add your Replicate API token in the ProtectMyAPI Dashboard.

Run Predictions

Basic Prediction

let replicate = ProtectMyAPI.replicateService()
 
let prediction = try await replicate.createPrediction(
    request: ReplicatePredictionRequest(
        model: "meta/llama-2-70b-chat",
        input: [
            "prompt": "Write a haiku about programming",
            "max_new_tokens": 100
        ]
    )
)
 
// Predictions run asynchronously - check status
print("Status: \(prediction.status)")
print("Output: \(prediction.output ?? "pending")")

val replicate = ProtectMyAPIAI.replicateService()
 
val prediction = replicate.createPrediction(
    request = ReplicatePredictionRequest(
        model = "meta/llama-2-70b-chat",
        input = mapOf(
            "prompt" to "Write a haiku about programming",
            "max_new_tokens" to 100
        )
    )
)
 
println("Status: ${prediction.status}")
println("Output: ${prediction.output}")

final replicate = ProtectMyAPIAI.replicateService();
 
final prediction = await replicate.createPrediction(
  request: ReplicatePredictionRequest(
    model: "meta/llama-2-70b-chat",
    input: {
      "prompt": "Write a haiku about programming",
      "max_new_tokens": 100,
    },
  ),
);
 
print("Status: ${prediction.status}");
print("Output: ${prediction.output}");

Wait for Completion

// Create and wait for prediction
let prediction = try await replicate.createPredictionAndWait(
    request: ReplicatePredictionRequest(
        model: "meta/llama-2-70b-chat",
        input: ["prompt": "Hello, world!"]
    ),
    timeout: 60 // seconds
)
 
print("Result: \(prediction.output!)")

val prediction = replicate.createPredictionAndWait(
    request = ReplicatePredictionRequest(
        model = "meta/llama-2-70b-chat",
        input = mapOf("prompt" to "Hello, world!")
    ),
    timeout = 60
)
 
println("Result: ${prediction.output}")

final prediction = await replicate.createPredictionAndWait(
  request: ReplicatePredictionRequest(
    model: "meta/llama-2-70b-chat",
    input: {"prompt": "Hello, world!"},
  ),
  timeout: Duration(seconds: 60),
);
 
print("Result: ${prediction.output}");

Image Generation

FLUX (Fast)

let image = try await replicate.generateFluxImage(
    prompt: "A cyberpunk cat wearing VR goggles",
    options: FluxOptions(
        model: .schnell, // Fast generation
        width: 1024,
        height: 1024,
        numOutputs: 1,
        outputFormat: .png
    )
)
 
// image.output contains the URL of generated image
if let url = image.output?.first {
    print("Image URL: \(url)")
}

val image = replicate.generateFluxImage(
    prompt = "A cyberpunk cat wearing VR goggles",
    options = FluxOptions(
        model = FluxModel.SCHNELL,
        width = 1024,
        height = 1024,
        numOutputs = 1,
        outputFormat = OutputFormat.PNG
    )
)
 
image.output?.firstOrNull()?.let { url ->
    println("Image URL: $url")
}

final image = await replicate.generateFluxImage(
  prompt: "A cyberpunk cat wearing VR goggles",
  options: FluxOptions(
    model: FluxModel.schnell,
    width: 1024,
    height: 1024,
    numOutputs: 1,
    outputFormat: OutputFormat.png,
  ),
);
 
if (image.output?.isNotEmpty == true) {
  print("Image URL: ${image.output!.first}");
}

FLUX Pro (Higher Quality)

let image = try await replicate.generateFluxImage(
    prompt: "Professional product photography of a luxury watch",
    options: FluxOptions(
        model: .pro,
        width: 1024,
        height: 1024,
        aspectRatio: "1:1",
        promptUpsampling: true, // Enhance prompt automatically
        safetyTolerance: 2
    )
)

val image = replicate.generateFluxImage(
    prompt = "Professional product photography of a luxury watch",
    options = FluxOptions(
        model = FluxModel.PRO,
        width = 1024,
        height = 1024,
        aspectRatio = "1:1",
        promptUpsampling = true,
        safetyTolerance = 2
    )
)

final image = await replicate.generateFluxImage(
  prompt: "Professional product photography of a luxury watch",
  options: FluxOptions(
    model: FluxModel.pro,
    width: 1024,
    height: 1024,
    aspectRatio: "1:1",
    promptUpsampling: true,
    safetyTolerance: 2,
  ),
);

FLUX Dev (Development)

let image = try await replicate.generateFluxImage(
    prompt: "Watercolor painting of a mountain landscape",
    options: FluxOptions(
        model: .dev,
        numInferenceSteps: 28, // More steps = higher quality
        guidanceScale: 3.5
    )
)

val image = replicate.generateFluxImage(
    prompt = "Watercolor painting of a mountain landscape",
    options = FluxOptions(
        model = FluxModel.DEV,
        numInferenceSteps = 28,
        guidanceScale = 3.5
    )
)

final image = await replicate.generateFluxImage(
  prompt: "Watercolor painting of a mountain landscape",
  options: FluxOptions(
    model: FluxModel.dev,
    numInferenceSteps: 28,
    guidanceScale: 3.5,
  ),
);

SDXL Generation

let image = try await replicate.createPredictionAndWait(
    request: ReplicatePredictionRequest(
        model: "stability-ai/sdxl",
        input: [
            "prompt": "Futuristic city skyline at night, neon lights",
            "negative_prompt": "blurry, low quality",
            "width": 1024,
            "height": 1024,
            "num_inference_steps": 30,
            "guidance_scale": 7.5
        ]
    )
)

val image = replicate.createPredictionAndWait(
    request = ReplicatePredictionRequest(
        model = "stability-ai/sdxl",
        input = mapOf(
            "prompt" to "Futuristic city skyline at night, neon lights",
            "negative_prompt" to "blurry, low quality",
            "width" to 1024,
            "height" to 1024,
            "num_inference_steps" to 30,
            "guidance_scale" to 7.5
        )
    )
)

final image = await replicate.createPredictionAndWait(
  request: ReplicatePredictionRequest(
    model: "stability-ai/sdxl",
    input: {
      "prompt": "Futuristic city skyline at night, neon lights",
      "negative_prompt": "blurry, low quality",
      "width": 1024,
      "height": 1024,
      "num_inference_steps": 30,
      "guidance_scale": 7.5,
    },
  ),
);

Check Prediction Status

// Start a prediction
let prediction = try await replicate.createPrediction(
    request: ReplicatePredictionRequest(
        model: "stability-ai/sdxl",
        input: ["prompt": "Beautiful sunset"]
    )
)
 
// Check status later
let status = try await replicate.getPrediction(id: prediction.id)
 
switch status.status {
case "succeeded":
    print("Done: \(status.output!)")
case "failed":
    print("Error: \(status.error ?? "Unknown")")
case "processing":
    print("Still running...")
default:
    print("Status: \(status.status)")
}

val prediction = replicate.createPrediction(
    request = ReplicatePredictionRequest(
        model = "stability-ai/sdxl",
        input = mapOf("prompt" to "Beautiful sunset")
    )
)
 
val status = replicate.getPrediction(id = prediction.id)
 
when (status.status) {
    "succeeded" -> println("Done: ${status.output}")
    "failed" -> println("Error: ${status.error}")
    "processing" -> println("Still running...")
    else -> println("Status: ${status.status}")
}

final prediction = await replicate.createPrediction(
  request: ReplicatePredictionRequest(
    model: "stability-ai/sdxl",
    input: {"prompt": "Beautiful sunset"},
  ),
);
 
final status = await replicate.getPrediction(id: prediction.id);
 
switch (status.status) {
  case "succeeded":
    print("Done: ${status.output}");
    break;
  case "failed":
    print("Error: ${status.error}");
    break;
  case "processing":
    print("Still running...");
    break;
}

Cancel Prediction

try await replicate.cancelPrediction(id: prediction.id)

replicate.cancelPrediction(id = prediction.id)

await replicate.cancelPrediction(id: prediction.id);

Video Generation

let video = try await replicate.createPredictionAndWait(
    request: ReplicatePredictionRequest(
        model: "anotherjesse/zeroscope-v2-xl",
        input: [
            "prompt": "A spaceship flying through an asteroid field",
            "num_frames": 24,
            "fps": 8
        ]
    ),
    timeout: 300 // Videos take longer
)
 
print("Video URL: \(video.output!)")

val video = replicate.createPredictionAndWait(
    request = ReplicatePredictionRequest(
        model = "anotherjesse/zeroscope-v2-xl",
        input = mapOf(
            "prompt" to "A spaceship flying through an asteroid field",
            "num_frames" to 24,
            "fps" to 8
        )
    ),
    timeout = 300
)
 
println("Video URL: ${video.output}")

final video = await replicate.createPredictionAndWait(
  request: ReplicatePredictionRequest(
    model: "anotherjesse/zeroscope-v2-xl",
    input: {
      "prompt": "A spaceship flying through an asteroid field",
      "num_frames": 24,
      "fps": 8,
    },
  ),
  timeout: Duration(minutes: 5),
);
 
print("Video URL: ${video.output}");

Audio Generation

Music with MusicGen

let audio = try await replicate.createPredictionAndWait(
    request: ReplicatePredictionRequest(
        model: "meta/musicgen",
        input: [
            "prompt": "Upbeat electronic dance music with heavy bass",
            "duration": 10
        ]
    )
)

val audio = replicate.createPredictionAndWait(
    request = ReplicatePredictionRequest(
        model = "meta/musicgen",
        input = mapOf(
            "prompt" to "Upbeat electronic dance music with heavy bass",
            "duration" to 10
        )
    )
)

final audio = await replicate.createPredictionAndWait(
  request: ReplicatePredictionRequest(
    model: "meta/musicgen",
    input: {
      "prompt": "Upbeat electronic dance music with heavy bass",
      "duration": 10,
    },
  ),
);

Popular Models

Image Generation

Model	Description	Speed
`black-forest-labs/flux-schnell`	Fast FLUX generation	⚡ Fast
`black-forest-labs/flux-dev`	High quality FLUX	Medium
`black-forest-labs/flux-pro`	Best quality FLUX	Slower
`stability-ai/sdxl`	Stable Diffusion XL	Medium
`stability-ai/stable-diffusion-3`	SD3	Medium

Language Models

Model	Description
`meta/llama-2-70b-chat`	Llama 2 chat
`meta/llama-2-13b-chat`	Llama 2 smaller
`mistralai/mistral-7b-instruct-v0.2`	Mistral instruct

Video Models

Model	Description
`anotherjesse/zeroscope-v2-xl`	Text to video
`stability-ai/stable-video-diffusion`	Image to video

Audio Models

Model	Description
`meta/musicgen`	Music generation
`cjwbw/riffusion`	Music from spectrograms

FLUX Model Options

Option	Description	Default
`width`	Image width (256-1440)	1024
`height`	Image height (256-1440)	1024
`numOutputs`	Number of images (1-4)	1
`numInferenceSteps`	Denoising steps	4 (schnell), 28 (dev)
`guidanceScale`	Prompt adherence	3.5
`outputFormat`	png, jpg, webp	webp
`seed`	Reproducibility	Random
`promptUpsampling`	Enhance prompts	false

Pricing

Replicate charges per second of compute time. Pricing varies by model and hardware:

CPU: ~$0.000100/sec
GPU (T4): ~$0.000225/sec
GPU (A40): ~$0.000575/sec
GPU (A100): ~$0.001150/sec

Check their pricing page for current rates.

Together AI Fireworks AI