Replicate

Delete a deployment via DELETE /deployments/{deployment_owner}/{deployment_name}. Delete a deployment. Deployment deletion has some restrictions. - You can only delete deployments that have been offline and unused for at least 15 minutes. The response will be an empty 204, indicating the deployment has been deleted

Delete a file via DELETE /files/{file_id}. Delete a file. Once a file has been deleted, subsequent requests to the file resource return 404 Not found

Delete a model via DELETE /models/{model_owner}/{model_name}. Delete a model. Model deletion has some restrictions. - You can only delete models you own. - You can only delete private models. - You can only delete models that have no versions associated with them. Currently you'll need to delete the model's versions before you can delete the model itself. The response will be an empty 204, indicating the model has been deleted

Delete a model version via DELETE /models/{model_owner}/{model_name}/versions/{version_id}. Delete a model version and all associated predictions, including all output files. Model version deletion has some restrictions. - You can only delete versions from models you own. - You can only delete versions from private models. - You cannot delete a version if someone other than you has run predictions with it. - You cannot delete a version if it is being used as the base model for a fine tune/training.

Get the authenticated account via GET /account. Returns information about the user or organization associated with the provided API token. The response will be a JSON object describing the account

List collections of models via GET /collections. The response will be a paginated JSON list of collection objects

Get a collection of models via GET /collections/{collection_slug}. The response will be a collection object with a nested list of the models in that collection

List deployments via GET /deployments. Get a list of deployments associated with the current account, including the latest release configuration for each deployment. The response will be a paginated JSON array of deployment objects, sorted with the most recent deployment first

Get a deployment via GET /deployments/{deployment_owner}/{deployment_name}. Get information about a deployment by name including the current release. The response will be a JSON object describing the deployment

List files via GET /files. Get a paginated list of all files created by the user or organization associated with the provided API token. The response will be a paginated JSON array of file objects, sorted with the most recent file first

Get a file via GET /files/{file_id}. Get the details of a file

Download a file via GET /files/{file_id}/download. WITHHELD: replicate_get_files_by_file_id_download is not offered. The route answers application/octet-stream -- unbounded bytes, which never enter a tool result -- and its required `signature` parameter is an HMAC-SHA256 of '{owner} {id} {expiry}' computed with Replicate's Files API signing secret, which Replicate publishes no endpoint to obtain (measured 2026-09-16: no query parameters answers 400 'Missing query parameters' and an invented signature answers 403 'Invalid signature'). Use replicate_get_files_by_file_id for the file's metadata and its `urls.get` address.

List available hardware for models via GET /hardware. The response will be a JSON array of hardware objects

List public models via GET /models. Get a paginated list of public models. The response will be a pagination object containing a list of model objects. See the `models.get` docs for more details about the model object. Sorting. You can sort the results using the `sort_by` and `sort_direction` query parameters. For example, to get the most recently created models. Available sorting options. - `model_created_at`.

Get a model via GET /models/{model_owner}/{model_name}. The response will be a model object in the following format. The model object includes the input and output schema for the latest version of the model. The `cover_image_url` string is an HTTPS URL for an image file. This can be. - An image uploaded by the model author. - The output file of the example prediction, if the model author has not set a cover image.

List examples for a model via GET /models/{model_owner}/{model_name}/examples. List example predictions made using the model. These are predictions that were saved by the model author as illustrative examples of the model's capabilities. If you want all the examples for a model, use this operation. If you just want the model's default example, you can use the `models.get` operation instead, which includes a `default_example` object.

Get a model's README via GET /models/{model_owner}/{model_name}/readme. Get the README content for a model. The response will be the README content as plain text in Markdown format

List model versions via GET /models/{model_owner}/{model_name}/versions. The response will be a JSON array of model version objects, sorted with the most recent version first

Get a model version via GET /models/{model_owner}/{model_name}/versions/{version_id}. The response will be the version object. Every model describes its inputs and outputs with OpenAPI Schema Objects in the `openapi_schema` property. The `openapi_schema.components.schemas.Input` property for the replicate/hello-world model looks like this. The `openapi_schema.components.schemas.Output` property for the replicate/hello-world model looks like this.

List predictions via GET /predictions. Get a paginated list of all predictions created by the user or organization associated with the provided API token. This will include predictions created from the API and the website. It will return 100 records per page. The response will be a paginated JSON array of prediction objects, sorted with the most recent prediction first. `id` will be the unique ID of the prediction.

Get a prediction via GET /predictions/{prediction_id}. Get the current state of a prediction. The response will be the prediction object. `source` will indicate how the prediction was created. Possible values are `web` or `api`. `status` will be one of. - `starting`. the prediction is starting up. If this status lasts longer than a few seconds, then it's typically because a new worker is being started to run the prediction. - `processing`.

Search models, collections, and docs (beta) via GET /search. Search for public models, collections, and docs using a text query. For models, the response includes all model data, plus a new `metadata` object with the following fields. - `generated_description`. A longer and more detailed AI-generated description of the model - `tags`. An array of tags for the model - `score`. A score for the model's relevance to the search query.

List trainings via GET /trainings. Get a paginated list of all trainings created by the user or organization associated with the provided API token. This will include trainings created from the API and the website. It will return 100 records per page. The response will be a paginated JSON array of training objects, sorted with the most recent training first. `id` will be the unique ID of the training.

Get a training via GET /trainings/{training_id}. Get the current state of a training. The response will be the training object. `status` will be one of. - `starting`. the training is starting up. If this status lasts longer than a few seconds, then it's typically because a new worker is being started to run the training. - `processing`. the `train()` method of the model is currently running. - `succeeded`. the training completed successfully. - `failed`.

Get the signing secret for the default webhook via GET /webhooks/default/secret. Get the signing secret for the default webhook endpoint. This is used to verify that webhook requests are coming from Replicate. The response will be a JSON object with a `key` property

Update a deployment via PATCH /deployments/{deployment_owner}/{deployment_name}. Update properties of an existing deployment, including hardware, min/max instances, and the deployment's underlying model version. The response will be a JSON object describing the deployment. Updating any deployment properties will increment the `number` field of the `current_release`

Update metadata for a model via PATCH /models/{model_owner}/{model_name}. Update select properties of an existing model. You can update the following properties. - `description` - Model description - `readme` - Model README content - `github_url` - GitHub repository URL - `paper_url` - Research paper URL - `weights_url` - Model weights URL - `license_url` - License URL. The response will be the updated model object with all of its properties

Create a deployment via POST /deployments. Create a new deployment. The response will be a JSON object describing the deployment

Create a prediction using a deployment via POST /deployments/{deployment_owner}/{deployment_name}/predictions. Create a prediction for the deployment and inputs you provide. The request will wait up to 60 seconds for the model to run. If this time is exceeded the prediction will be returned in a `"starting"` state and need to be retrieved using the `predictions.get` endpoint.

Create a file via POST /files. Create a file by uploading its content and optional metadata. The request must include. - `content`. The file content (required) - `type`. The content / MIME type for the file (defaults to `application/octet-stream`) - `filename`. The filename (required, ≤ 255 bytes, valid UTF-8) - `metadata`. User-provided metadata associated with the file (defaults to `{}`, must be valid JSON)

Create a model via POST /models. Create a model. The response will be a model object in the following format. Note that there is a limit of 1,000 models per account. For most purposes, we recommend using a single model and pushing new versions of the model as you make changes to it

Create a prediction using an official model via POST /models/{model_owner}/{model_name}/predictions. Create a prediction using an official model. If you're _not_ running an official model, use the `predictions.create` operation instead. The request will wait up to 60 seconds for the model to run. If this time is exceeded the prediction will be returned in a `"starting"` state and need to be retrieved using the `predictions.get` endpoint.

Create a training via POST /models/{model_owner}/{model_name}/versions/{version_id}/trainings. Start a new training of the model version you specify. The response will be the training object. As models can take several minutes or more to train, the result will not be available immediately. To get the final result of the training you should either provide a `webhook` HTTPS URL for us to call when the results are ready, or poll the get a training endpoint until it has finished.

Create a prediction via POST /predictions. Create a prediction for the model version and inputs you provide. The request will wait up to 60 seconds for the model to run. If this time is exceeded the prediction will be returned in a `"starting"` state and need to be retrieved using the `predictions.get` endpoint. For a complete overview of the `predictions.create` API check out our documentation on creating a prediction which covers a variety of use cases

Cancel a prediction via POST /predictions/{prediction_id}/cancel. Cancel a prediction that is currently running

Cancel a training via POST /trainings/{training_id}/cancel. Cancel a training