> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments.md).

# 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](https://roboflow.com/pricing).

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

<table><thead><tr><th width="184">Type</th><th>Features</th></tr></thead><tbody><tr><td>dev-cpu</td><td><p><strong>Ephemeral</strong>: will be automatically deleted after 3 hours</p><p><strong>CPU</strong>: model inference can be done on the CPU</p><p>Ideal for <strong>testing integrations</strong> and <strong>prototyping</strong> applications</p></td></tr><tr><td>dev-gpu</td><td><p><strong>Ephemeral</strong>: will be automatically deleted after 3 hours</p><p><strong>Ideal for testing integrations</strong> and <strong>prototyping</strong> applications</p><p><strong>GPU</strong>: models need GPU acceleration (like Florence 2)</p><p>Ideal for <strong>testing integrations</strong> and <strong>prototyping</strong> applications</p></td></tr><tr><td>prod-cpu</td><td><p><strong>Persistent</strong>: dedicated subdomain <code>&#x3C;some-name>.roboflow.cloud</code></p><p><strong>CPU</strong>: model inference can be done on the CPU</p><p>Ideal for <strong>serving production traffic</strong></p></td></tr><tr><td>prod-gpu</td><td><p><strong>Persistent</strong>: dedicated subdomain <code>&#x3C;some-name>.roboflow.cloud</code></p><p><strong>GPU</strong>: models need GPU acceleration (like Florence 2)</p><p>Ideal for <strong>serving production traffic</strong></p></td></tr></tbody></table>

### **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](https://roboflow.com/sales).

All dedicated deployment servers will run [Roboflow Inference](https://inference.roboflow.com/), our open-source inference server. Review the [Roboflow Inference documentation](https://inference.roboflow.com/) 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)](/deployment/roboflow-cloud/dedicated-deployments/create-a-dedicated-deployment.md)
* [How to create a dedicated deployment (Roboflow CLI)](/deployment/roboflow-cloud/dedicated-deployments/create-a-dedicated-deployment.md#create-a-dedicated-deployment-with-the-cli)
* [How to use a dedicated deployment](/deployment/roboflow-cloud/dedicated-deployments/make-requests-to-a-dedicated-deployment.md)
* [HTTP APIs](#http-api)

## HTTP API

[Dedicated Deployments](https://docs.roboflow.com/deployment/roboflow-cloud/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](/deployment/roboflow-cloud/serverless-api.md#http-api).

{% hint style="info" %}
The "edge devices" documentation under [Deployment Manager](/deployment/edge-devices/deployment-manager.md#http-api) is a separate product. Dedicated Deployments are managed GPU machines in Roboflow's cloud; Deployment Manager devices are on-prem hardware running [Roboflow Inference](https://inference.roboflow.com).
{% endhint %}

**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

<mark style="color:green;">`GET`</mark> `/machine_types`

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

**Response**

```json
{
  "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

<mark style="color:green;">`POST`</mark> `/add`

**Body** (JSON)

<table><thead><tr><th width="200">Name</th><th width="120">Type</th><th>Description</th><th data-type="checkbox">Required</th></tr></thead><tbody><tr><td><code>api_key</code></td><td>string</td><td>Workspace API key.</td><td>true</td></tr><tr><td><code>creator_email</code></td><td>string</td><td>Email of a workspace member.</td><td>true</td></tr><tr><td><code>deployment_name</code></td><td>string</td><td>Unique name within the workspace.</td><td>true</td></tr><tr><td><code>machine_type</code></td><td>string</td><td>From <code>/machine_types</code>.</td><td>true</td></tr><tr><td><code>duration</code></td><td>float</td><td>Hours before auto-cleanup. Default <code>3</code>.</td><td>false</td></tr><tr><td><code>delete_on_expiration</code></td><td>boolean</td><td><code>true</code> to delete on expiration; <code>false</code> to pause.</td><td>false</td></tr><tr><td><code>inference_version</code></td><td>string</td><td>Inference server version. Default <code>latest</code>.</td><td>false</td></tr><tr><td><code>min_replicas</code></td><td>integer</td><td>Minimum replicas. Default <code>1</code>.</td><td>false</td></tr><tr><td><code>max_replicas</code></td><td>integer</td><td>Maximum replicas. Default <code>1</code>.</td><td>false</td></tr></tbody></table>

```bash
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**

```json
{
	"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

<mark style="color:green;">`GET`</mark> `/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. |

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

**Response** (same schema as the [Create a Deployment](#create-a-deployment) response)

```json
{
  "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

<mark style="color:green;">`GET`</mark> `/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`. |

```bash
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](#create-a-deployment) response.

```json
[
{
	"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

<mark style="color:green;">`GET`</mark> `/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](https://en.wikipedia.org/wiki/ISO_8601) start time. Default 1 hour ago. |
| `to_timestamp`    | string  | No       | [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) end time. Default now.          |

```bash
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**

```json
[
	{
		"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:

<mark style="color:green;">`GET`</mark> `/usage_workspace?api_key=...&from_timestamp=...&to_timestamp=...`

Per-deployment:

<mark style="color:green;">`GET`</mark> `/usage_deployment?api_key=...&deployment_name=...&from_timestamp=...&to_timestamp=...`

```bash
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

<mark style="color:green;">`POST`</mark> `/pause`   <mark style="color:green;">`POST`</mark> `/resume`   <mark style="color:red;">`POST`</mark> `/delete`

**Body** (JSON)

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

```bash
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**

```json
{
	"message": "OK"
}
```

### SDK and CLI equivalents

* SDK: `roboflow.adapters.deploymentapi.*` - see [Manage Dedicated Deployments (SDK)](#python-sdk).
* CLI: the `roboflow deployment` command group - see [Manage Deployments (CLI)](#cli).

## Python SDK

[Dedicated Deployments](https://docs.roboflow.com/deployment/roboflow-cloud/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:

```python
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

```python
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

```python
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

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

### Pause / resume / delete

```python
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

```python
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

```python
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`):

```python
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")
```

### REST and CLI equivalents

* REST: see [Dedicated Deployments (REST)](#http-api).
* CLI: see [Manage Deployments (CLI)](#cli).

## CLI

You can create, monitor, and manage [Dedicated Deployments](https://docs.roboflow.com/deployment/roboflow-cloud/dedicated-deployments) from the command line.

### List Deployments

```bash
roboflow deployment list
```

### List Machine Types

```bash
roboflow deployment machine-type
```

### Create a Deployment

```bash
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:

```bash
roboflow deployment create my-deployment -m gpu-small -e me@company.com --duration 8
```

### Get Deployment Details

```bash
roboflow deployment get <name>
```

Wait for a pending deployment to be ready:

```bash
roboflow deployment get my-deployment --wait
```

### View Logs

```bash
roboflow deployment log <name>
```

Follow logs in real-time:

```bash
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:

```bash
roboflow deployment usage
```

Get usage for a specific deployment:

```bash
roboflow deployment usage my-deployment
```

#### Options

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

### Pause, Resume, and Delete

```bash
roboflow deployment pause my-deployment
roboflow deployment resume my-deployment
roboflow deployment delete my-deployment
```

### JSON Output

All deployment commands support `--json`:

```bash
roboflow deployment list --json
roboflow deployment get my-deployment --json
```
