Dedicated Deployments

Run Your Vision Models on Dedicated Servers with Roboflow

About

Dedicated Deployments are private cloud servers, managed by Roboflow, that run your computer vision models and Workflows on resources allocated specifically to you. They let you serve inference without provisioning or maintaining your own infrastructure, with pay-per-hour billing and secure access through your workspace API key. Use them when you need consistent, dedicated performance for development, testing, or production traffic.

What are Dedicated Deployments?

Dedicated Deployments are private cloud servers managed by Roboflow, specifically designed to run your computer vision models. These models can include:

• Object detection

• Image segmentation

• Classification

• Keypoint detection

• Foundation models like CLIP (if trained on Roboflow)

• Roboflow Workflows (low-code vision applications)

• ...and many others!

Benefits of Dedicated Deployments

• Focus on your machine vision business problem, leave the infrastructure to us: Spin up inference serving infrastructure with a few clicks and without having to signup with cloud providers, installing and securing servers, managing TLS certificates or worrying about server management, patching, updates etc.

• Dedicated Resources: Get cloud servers allocated specifically for your use, ensuring consistent performance for your models.

• Secure Access: Dedicated Deployments are accessible with your workspace's unique API key and utilize HTTPS for secure communication.

• Easy Integration: Each deployment receives a subdomain within roboflow.cloud, simplifying integration with your applications.

• Pay-Per-Hour: You're only charged for the duration of the server's existence (billed in 1 minute intervals).

• Auto Pause & Resume: Your Dedicated Deployments will automatically pause after a configurable period of inactivity. For dev-cpu or dev-gpu deployment types, this period is fixed at 1 hour. They can be quickly resumed by sending a request with your API key. This feature is designed to help you save on costs.

Current Limitations

• All dedicated deployments are currently hosted in US-based data centers; users from other Geographies may see higher latencies. Please contact us for a customized solution if you are outside of US, we can help you to reduce the network latency.

• Dedicated Deployments are available to Core and Enterprise plan workspaces. See Roboflow plans.

Types of Dedicated Deployments

Roboflow offers 4 different types of Dedicated Deployments, i.e., dev-cpu, dev-gpu, prod-cpu, and prod-gpu. While dev-cpu and dev-gpu are designed for development and testing purposes, will be deleted automatically after a few hours, prod-cpu and prod-gpu are persistent, ideally for serving large-scale production traffic.

Type	Features
dev-cpu	Ephemeral: will be automatically deleted after 3 hours CPU: model inference can be done on the CPU Ideal for testing integrations and prototyping applications
dev-gpu	Ephemeral: will be automatically deleted after 3 hours Ideal for testing integrations and prototyping applications GPU: models need GPU acceleration (like Florence 2) Ideal for testing integrations and prototyping applications
prod-cpu	Persistent: dedicated subdomain <some-name>.roboflow.cloud CPU: model inference can be done on the CPU Ideal for serving production traffic
prod-gpu	Persistent: dedicated subdomain <some-name>.roboflow.cloud GPU: models need GPU acceleration (like Florence 2) Ideal for serving production traffic

Bill Information

The rate for GPU deployments (dev-gpu, prod-gpu) is 1 credit/hour, while the rate for CPU deployments (dev-cpu, prod-cpu) is 0.25 credit/hour.

If you prefer to be billed based on number of requests sent to your dedicated deployment server, please click here to contact our sales.

All dedicated deployment servers will run Roboflow Inference, our open-source inference server. Review the Roboflow Inference documentation to learn more about all of the features available.

Useful Links

• How to create a dedicated deployment (Roboflow App)

• How to create a dedicated deployment (Roboflow CLI)

• How to use a dedicated deployment

• HTTP APIs

HTTP API

Dedicated Deployments are managed GPU machines that run your Roboflow models with predictable latency and high throughput. They are managed by a dedicated service hosted at https://roboflow.cloud, separate from the main https://api.roboflow.com REST API.

This section documents the management endpoints (create, get, list, pause, resume, delete, logs, usage). For inference against a deployment once it's live, see Run a Model on an Image.

The "edge devices" documentation under Deployment Manager is a separate product. Dedicated Deployments are managed GPU machines in Roboflow's cloud; Deployment Manager devices are on-prem hardware running Roboflow Inference.

Base URL: https://roboflow.cloud

api_key is passed as a query parameter (or in the request body for POST endpoints) on every request. Check the response code: if it's 200, decode the response body as a JSON object; otherwise, the response body contains an error message as a string.

List Machine Types

GET /machine_types

curl "https://roboflow.cloud/machine_types?api_key=$ROBOFLOW_API_KEY"

Response

{
  "machine_types": [
    { "name": "gpu-small",  "description": "1× T4, 4 vCPU, 16 GB RAM" },
    { "name": "gpu-medium", "description": "1× L4, 8 vCPU, 32 GB RAM" }
  ]
}

Create a Deployment

POST /add

Body (JSON)

Name	Type	Description	Required
api_key	string	Workspace API key.
creator_email	string	Email of a workspace member.
deployment_name	string	Unique name within the workspace.
machine_type	string	From /machine_types.
duration	float	Hours before auto-cleanup. Default 3.
delete_on_expiration	boolean	true to delete on expiration; false to pause.
inference_version	string	Inference server version. Default latest.
min_replicas	integer	Minimum replicas. Default 1.
max_replicas	integer	Maximum replicas. Default 1.

curl -X POST "https://roboflow.cloud/add" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "'$ROBOFLOW_API_KEY'",
    "creator_email": "[e-mail]",
    "deployment_name": "my-deployment",
    "machine_type": "gpu-small",
    "duration": 8,
    "delete_on_expiration": true
  }'

The deployment provisions asynchronously. Poll GET /get until status == "ready".

Response Example

{
	"deployment_id": "IwzJ5YLQ0iDhwzqoh3Ae",
	"deployment_name": "dev-testing",
	"machine_type": "dev-gpu",
	"creator_email": YOUR_EMAIL_ADDRESS,
	"creator_id": YOUR_USER_ID,
	"subdomain": "dev-testing",
	"domain": "dev-testing.roboflow.cloud",
	"duration": 3.0,
	"inference_version": "0.45.0",
	"max_replicas": 1,
	"min_replicas": 1,
	"num_replicas": 0,
	"status": "pending",
	"workspace_id": YOUR_WORKSPACE_ID,
	"workspace_url": YOUR_WORKSPACE_URL
}

Response Schema

Field	Type	Description
deployment_id	string	Unique identifier for the deployment.
deployment_name	string	Name you gave the deployment.
machine_type	string	One of dev-cpu, dev-gpu, prod-cpu, prod-gpu.
creator_email	string	Email of the user who created the deployment.
creator_id	string	User ID corresponding to creator_email.
subdomain	string	Not always the same as deployment_name - a suffix is added if the subdomain is taken.
domain	string	Full domain of the deployment endpoint.
duration	float	Hours the deployment has been running.
inference_version	string	Inference server version running on the deployment.
min_replicas	integer	Minimum replica count.
max_replicas	integer	Maximum replica count.
num_replicas	integer	Currently available replicas.
status	string	Current deployment status.
workspace_id	string	ID of the owning workspace.
workspace_url	string	URL slug of the owning workspace.

Get a Deployment

GET /get?api_key=...&deployment_name=...

Query Parameters

Name	Type	Required	Description
api_key	string	Yes	Workspace API key.
deployment_name	string	Yes	Name of the deployment to fetch.

curl "https://roboflow.cloud/get?api_key=$ROBOFLOW_API_KEY&deployment_name=my-deployment"

Response (same schema as the Create a Deployment response)

{
  "deployment_name": "my-deployment",
  "status": "ready",
  "machine_type": "gpu-small",
  "public_url": "https://my-deployment.roboflow.cloud",
  "created_at": "2026-05-01T17:05:33.000Z",
  "expires_at": "2026-05-02T01:05:33.000Z"
}

List Deployments

GET /list?api_key=...

Query Parameters

Name	Type	Required	Description
api_key	string	Yes	Workspace API key.
show_expired	string	No	Include expired deployments. Default false.
show_deleted	string	No	Include deleted deployments. Default false.

curl "https://roboflow.cloud/list?api_key=$ROBOFLOW_API_KEY"

Response

A list of dedicated deployment entries, where each entry has the same schema as the Create a Deployment response.

[
{
	"deployment_id": "IwzJ5YLQ0iDhwzqoh3Ae",
	"deployment_name": "dev-testing",
	"machine_type": "dev-gpu",
	"creator_email": YOUR_EMAIL_ADDRESS,
	"creator_id": YOUR_USER_ID,
	"subdomain": "dev-testing",
	"domain": "dev-testing.roboflow.cloud",
	"duration": 3.0,
	"inference_version": "0.45.0",
	"max_replicas": 1,
	"min_replicas": 1,
	"num_replicas": 0,
	"status": "pending",
	"workspace_id": YOUR_WORKSPACE_ID,
	"workspace_url": YOUR_WORKSPACE_URL
}
]

Logs

GET /get_log?api_key=...&deployment_name=...&from_timestamp=...&to_timestamp=...&max_entries=...

Query Parameters

Name	Type	Required	Description
api_key	string	Yes	Workspace API key.
deployment_name	string	Yes	Deployment to read logs from.
max_entries	integer	No	Number of log entries to return. Default 50.
from_timestamp	string	No	ISO 8601 start time. Default 1 hour ago.
to_timestamp	string	No	ISO 8601 end time. Default now.

curl "https://roboflow.cloud/get_log?api_key=$ROBOFLOW_API_KEY&deployment_name=my-deployment&max_entries=200"

from_timestamp and to_timestamp are ISO-8601 strings. Omit them to fetch the most recent logs up to max_entries.

Response Example

[
	{
		"insert_id": "gpwrgrw55p7b9jdq",
		"payload": "INFO:     10.18.0.38:46296 - \"GET /info HTTP/1.1\" 200 OK",
		"severity": "INFO",
		"timestamp": "2025-01-22T13:23:14.209436+00:00"
	},
	{
		"insert_id": "mbieh16zdjvqp81j",
		"payload": "INFO:     10.18.0.38:46294 - \"GET /info HTTP/1.1\" 200 OK",
		"severity": "INFO",
		"timestamp": "2025-01-22T13:23:14.208738+00:00"
	}
]

Response Schema

A list of log entries, where each entry has the following attributes:

Field	Type	Description
insert_id	string	Unique identifier for the log entry.
payload	string	Log content.
severity	string	Log level.
timestamp	string	When the entry was written.

Usage

Workspace-wide:

GET /usage_workspace?api_key=...&from_timestamp=...&to_timestamp=...

Per-deployment:

GET /usage_deployment?api_key=...&deployment_name=...&from_timestamp=...&to_timestamp=...

curl "https://roboflow.cloud/usage_workspace?api_key=$ROBOFLOW_API_KEY&from_timestamp=2026-04-01T00:00:00Z&to_timestamp=2026-05-01T00:00:00Z"

Pause / Resume / Delete

POST /pause POST /resume POST /delete

Body (JSON)

Name	Type	Required	Description
api_key	string	Yes	Workspace API key.
deployment_name	string	Yes	Deployment to act on.

curl -X POST "https://roboflow.cloud/pause" \
  -H "Content-Type: application/json" \
  -d '{"api_key": "'$ROBOFLOW_API_KEY'", "deployment_name": "my-deployment"}'

The same body shape applies to /resume and /delete.

Response Example

{
	"message": "OK"
}

Python SDK

Dedicated Deployments are managed GPU machines that run your Roboflow models with predictable latency and high throughput. The SDK manages them through the roboflow.adapters.deploymentapi adapter - the high-level Workspace class doesn't currently expose deployment methods.

Each function returns a (status_code, body) tuple so you can branch on the HTTP result:

from roboflow.adapters import deploymentapi

status, body = deploymentapi.list_deployment("YOUR_API_KEY")
if status == 200:
    for d in body.get("deployments", []):
        print(d["deployment_name"], d["status"])
else:
    print("Failed:", body)

List available machine types

from roboflow.adapters import deploymentapi

status, body = deploymentapi.list_machine_types("YOUR_API_KEY")
for m in body.get("machine_types", []):
    print(m["name"], m.get("description"))

Create a deployment

status, body = deploymentapi.add_deployment(
    api_key="YOUR_API_KEY",
    creator_email="[e-mail]",          # must be a workspace member
    machine_type="gpu-small",
    duration=8,                                # hours
    delete_on_expiration=True,
    deployment_name="my-deployment",
    inference_version=None,                    # None → latest
)

The deployment provisions asynchronously. Poll get_deployment until status == "ready".

Get deployment details

status, body = deploymentapi.get_deployment("YOUR_API_KEY", "my-deployment")
print(body["status"], body.get("public_url"))

Pause / resume / delete

deploymentapi.pause_deployment("YOUR_API_KEY", "my-deployment")
deploymentapi.resume_deployment("YOUR_API_KEY", "my-deployment")
deploymentapi.delete_deployment("YOUR_API_KEY", "my-deployment")

Logs

import datetime as dt

status, body = deploymentapi.get_deployment_log(
    api_key="YOUR_API_KEY",
    deployment_name="my-deployment",
    from_timestamp=dt.datetime.utcnow() - dt.timedelta(hours=1),
    to_timestamp=dt.datetime.utcnow(),
    max_entries=200,
)
for entry in body.get("logs", []):
    print(entry["timestamp"], entry["message"])

Usage

status, ws_usage = deploymentapi.get_workspace_usage(
    api_key="YOUR_API_KEY",
    from_timestamp=dt.datetime(2026, 4, 1),
    to_timestamp=dt.datetime(2026, 5, 1),
)

status, dep_usage = deploymentapi.get_deployment_usage(
    api_key="YOUR_API_KEY",
    deployment_name="my-deployment",
    from_timestamp=dt.datetime(2026, 4, 1),
    to_timestamp=dt.datetime(2026, 5, 1),
)

Running inference against a dedicated deployment

Once a deployment is ready, point inference SDK calls at its public_url (returned by get_deployment):

from inference_sdk import InferenceHTTPClient

client = InferenceHTTPClient(api_url=body["public_url"], api_key="YOUR_API_KEY")
result = client.infer("photo.jpg", model_id="my-detector/3")

CLI

You can create, monitor, and manage Dedicated Deployments from the command line.

List Deployments

roboflow deployment list

List Machine Types

roboflow deployment machine-type

Create a Deployment

roboflow deployment create <name> -m <machine-type> -e <email>

Options

Flag	Description
-m, --machine-type	Machine type (required). Run deployment machine-type to see options
-e, --email	Your email, must be a workspace member (required)
--duration	Duration in hours (default: 3)
--inference-version	Inference server version (default: latest)
--no-delete-on-expiration	Keep deployment when it expires
--wait	Wait until deployment is ready

Example:

roboflow deployment create my-deployment -m gpu-small -e [e-mail] --duration 8

Get Deployment Details

roboflow deployment get <name>

Wait for a pending deployment to be ready:

roboflow deployment get my-deployment --wait

View Logs

roboflow deployment log <name>

Follow logs in real-time:

roboflow deployment log my-deployment -f

Options

Flag	Description
-d, --duration	Log window in seconds (default: 3600)
-n, --tail	Lines to show from end (max 50, default: 10)
-f, --follow	Follow log output

Usage Statistics

Get workspace-wide usage:

roboflow deployment usage

Get usage for a specific deployment:

roboflow deployment usage my-deployment

Options

Flag	Description
--from	Start time (ISO 8601)
--to	End time (ISO 8601)

Pause, Resume, and Delete

roboflow deployment pause my-deployment
roboflow deployment resume my-deployment
roboflow deployment delete my-deployment

JSON Output

All deployment commands support --json:

roboflow deployment list --json
roboflow deployment get my-deployment --json