Dedicated Deployments

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.

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 <a href="#provision-and-manage-dedicated-deployments-web-application" id="provision-and-manage-dedicated-deployments-web-application"></a>

• 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.

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)

curl -X POST "https://roboflow.cloud/add" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "'$ROBOFLOW_API_KEY'",
    "creator_email": "me@company.com",
    "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

Get a Deployment

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

Query Parameters

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

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

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:

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)

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="me@company.com",          # 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

Example:

roboflow deployment create my-deployment -m gpu-small -e me@company.com --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

Usage Statistics

Get workspace-wide usage:

roboflow deployment usage

Get usage for a specific deployment:

roboflow deployment usage my-deployment

Options

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