Run AI
with an API .

Run and fine-tune models. Deploy custom models. All with one line of code.

"replicate"

                          
                            
                              const
                            
                             replicate = 
                            
                              new
                            
                             
                            
                              Replicate
                            
                            ({

                          
                              
                            
                              auth
                            
                            : process.
                            
                              env
                            
                            .
                            
                              REPLICATE_API_TOKEN

})

};

                          
                            
                              const
                            
                             [output] = 
                            
                              await
                            
                             replicate.
                            
                              run
                            
                            (model, { input });

A poolside patio at sunset with vintage lounge chairs.

black-forest-labs/flux-2-pro

A soft armchair shaped like a peeled banana.

google/nano-banana-pro

A woman relaxing in a french bookstore.

bytedance/seedream-4

A futuristic robot looking into the distance.

black-forest-labs/flux-pro

An abstract painting of a sunrise.

black-forest-labs/flux-pro

Thousands of models contributed by our community

All the latest models are on Replicate. They’re not just demos — they all actually work and have production-ready APIs.

AI shouldn’t be locked up inside academic papers and demos. Make it real by pushing it to Replicate.

How it works

You can get started with any model with just one line of code. But as you do more complex things, you can fine-tune models or deploy your own custom code.

Run models

Our community has already published thousands of models that are ready to use in production. You can run these with one line of code.

Explore models

                                  
                                    output = replicate.run(

                                  
                                      
                                    
                                      "black-forest-labs/flux-dev"
                                    
                                    ,

                                  
                                        
                                    
                                      "aspect_ratio"
                                    
                                    : 
                                    
                                      "1:1"
                                    
                                    ,

                                  
                                        
                                    
                                      "num_outputs"
                                    
                                    : 
                                    
                                      1
                                    
                                    ,

                                  
                                        
                                    
                                      "output_format"
                                    
                                    : 
                                    
                                      "jpg"
                                    
                                    ,

                                  
                                        
                                    
                                      "output_quality"
                                    
                                    : 
                                    
                                      80
                                    
                                    ,

                                  
                                        
                                    
                                      "prompt"
                                    
                                    : 
                                    
                                      "An astronaut riding a rainbow unicorn, cinematic, dramatic"
                                    
                                    ,

Fine-tune models with your own data

You can improve models with your own data to create new models that are better suited to specific tasks.

Image models like SDXL can generate images of a particular person, object, or style.

Fine-tune image models

Train a model:

                                    
                                      training = replicate.trainings.create(

                                    
                                        destination=
                                      
                                        "mattrothenberg/drone-art"

                                    
                                        version=
                                      
                                        "ostris/flux-dev-lora-trainer:e440909d3512c31646ee2e0c7d6f6f4923224863a6a10c494606e79fb5844497"
                                      
                                      ,

                                      
                                            
                                        
                                          "input_images"
                                        
                                        :

https://example.com/images.zip

                                    
                                          
                                      
                                        "trigger_word"
                                      
                                      : 
                                      
                                        "TOK"
                                      
                                      ,

},

This will result in a new model:

mattrothenberg / drone-art

Fantastical images of drones on land and in the sky

0 runs

mattrothenberg / drone-art

Fantastical images of drones on land and in the sky

0 runs

Then, you can run it with one line of code:

                                    
                                      output = replicate.run(

                                    
                                        
                                      
                                        "mattrothenberg/drone-art:abcde1234..."
                                      
                                      ,

                                    
                                        
                                      
                                        input
                                      
                                      ={
                                      
                                        "prompt"
                                      
                                      : 
                                      
                                        "a photo of TOK forming a rainbow in the sky"
                                      
                                      }),

Deploy custom models

You aren’t limited to the models on Replicate: you can deploy your own custom models using Cog , our open-source tool for packaging machine learning models.

Cog takes care of generating an API server and deploying it on a big cluster in the cloud. We scale up and down to handle demand, and you only pay for the compute that you use.

Learn more

First, define the environment your model runs in with cog.yaml:

                                        
                                          
                                            build:

                                        
                                            
                                          
                                            system_packages:

                                        
                                              
                                          
                                            -
                                          
                                           
                                          
                                            "libgl1-mesa-glx"

                                        
                                              
                                          
                                            -
                                          
                                           
                                          
                                            "libglib2.0-0"

                                        
                                            
                                          
                                            python_version:
                                          
                                           
                                          
                                            "3.10"

                                        
                                            
                                          
                                            python_packages:

                                        
                                              
                                          
                                            -
                                          
                                           
                                          
                                            "torch==1.13.1"

                                        
                                          
                                            predict:
                                          
                                           
                                          
                                            "predict.py:Predictor"

Next, define how predictions are run on your model with predict.py:

                                        
                                          
                                            from
                                          
                                           cog 
                                          
                                            import
                                          
                                           BasePredictor, Input, Path

                                        
                                          
                                            class
                                          
                                           
                                          
                                            Predictor
                                          
                                          (
                                          
                                            BasePredictor
                                          
                                          ):

                                        
                                                
                                          
                                            """Load the model into memory to make running multiple predictions efficient"""

                                        
                                                
                                          
                                            self
                                          
                                          .model = torch.load(
                                          
                                            "./weights.pth"
                                          
                                          )

                                        
                                            
                                          
                                            # The arguments and types the model takes as input

                                        
                                                  image: Path = Input(description=
                                          
                                            "Grayscale input image"
                                          
                                          )

                                        
                                            ) -> Path:

                                        
                                                
                                          
                                            """Run a single prediction on the model"""

                                        
                                                processed_image = preprocess(image)

                                        
                                                output = 
                                          
                                            self
                                          
                                          .model(processed_image)

                                        
                                                
                                          
                                            return
                                          
                                           postprocess(output)

Scale on Replicate

Thousands of businesses are building their AI products on Replicate. Your team can deploy an AI feature in a day and scale to millions of users, without having to be machine learning experts.

Learn more about our enterprise plans

Automatic scale

If you get a ton of traffic, Replicate scales up automatically to handle the demand. If you don't get any traffic, we scale down to zero and don't charge you a thing.

CPU $0.000100/sec
Nvidia T4 GPU $0.000225/sec
Nvidia L40S GPU $0.000975/sec
2x Nvidia L40S GPU $0.001950/sec
Nvidia A100 (80GB) GPU $0.001400/sec
8x Nvidia A100 (80GB) GPU $0.011200/sec
Learn more about pricing

Pay for what you use

Replicate only bills you for how long your code is running. You don't pay for expensive GPUs when you're not using them.

Forget about infrastructure

Deploying machine learning models at scale is hard. If you've tried, you know. API servers, weird dependencies, enormous model weights, CUDA, GPUs, batching.

Prediction throughput (requests per second)

Logging & monitoring

Metrics let you keep an eye on how your models are performing, and logs let you zoom in on particular predictions to debug how your model is behaving.

Explore

FLUX.2 [pro]

Black Forest Labs' most advanced image generation model yet.

How to prompt Grok Imagine Video 1.5

How to make remarkable videos with Seedance 2.0

How to prompt Seedream 5.0

Featured models

Official models

google / nano-banana-2-lite

qwen / qwen3-7-plus

bytedance / seedance-2.0-mini

alibaba / happyhorse-1.1

sourceful / riverflow-v2.5-pro

sourceful / riverflow-v2.5-fast

luma / ray-3.2

anthropic / claude-fable-5

ideogram-ai / ideogram-v4-quality

ideogram-ai / ideogram-v4-balanced

runwayml / aleph-2

xai / grok-imagine-video-1.5

krea / krea-2-large

krea / krea-2-medium

anthropic / claude-sonnet-4.6

bytedance / video-upscaler

google / gemini-3.5-flash

heygen / avatar-v

ibm-granite / granite-vision-4.1-4b

prunaai / p-video-animate

I want to…

Latest models

Run AI with an API .