> 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

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.

### API Keys

A Dedicated Deployment runs on the workspace API key you created it with. If you roll that key, Roboflow moves the deployment onto the new key and keeps it running. If the move fails, the old key stays active so your deployment keeps serving traffic, and you can try the roll again.

You cannot roll a key that backs a Dedicated Deployment while the key is disabled or its [billing folder](https://docs.roboflow.com/platform/billing-and-plans/billing-folders) is paused. Enable the key, or resume the folder, then roll it.

### **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 data-search="false"><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](/deployment/self-hosted/self-hosted.md), our open-source inference server. Review the [Roboflow Inference documentation](/deployment/self-hosted/self-hosted.md) 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 are managed by their own service at `https://roboflow.cloud`, not by the Platform API at `https://api.roboflow.com`. Use these endpoints to create, inspect, pause, resume, and delete deployments, and to read their logs and usage. To run models on a deployment once it is ready, see [Make Requests to a Dedicated Deployment](/deployment/roboflow-cloud/dedicated-deployments/make-requests-to-a-dedicated-deployment.md).

{% hint style="info" %}
[Deployment Manager](/deployment/self-hosted/enterprise/deployment-manager.md#http-api) is a separate product. Dedicated Deployments are servers in Roboflow's cloud. Deployment Manager devices are your own hardware running [Roboflow Inference](/deployment/self-hosted/self-hosted.md).
{% endhint %}

GET requests take your workspace API key in the `api_key` query parameter. POST requests take it in the `api_key` field of the JSON body. A `200` response has a JSON body. Any other status has an error message, usually as plain text, so check the status before you parse the body.

### List Machine Types

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/machine\_types" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Create a Deployment

The deployment starts in the background, so the response has `status` set to `pending`. Call [Get a Deployment](#get-a-deployment) every 30 seconds until `status` is `ready`, then send requests to its `domain`.

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/add" method="post" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Get a Deployment

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/get" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### List Deployments

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/list" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Get Deployment Logs

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/get\_log" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Get Workspace Usage

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/usage\_workspace" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Get Deployment Usage

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/usage\_deployment" method="get" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Pause a Deployment

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/pause" method="post" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Resume a Deployment

A paused deployment also resumes when it gets a request with your API key. A deployment that paused after [startup script failures](/deployment/roboflow-cloud/dedicated-deployments/startup-scripts.md#failures) resumes only through this endpoint or the web app.

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/resume" method="post" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Delete a Deployment

{% openapi src="/files/K3DUIH0gghloNOVXYSpi" path="/delete" method="post" %}
[dedicated-deployments.yaml](https://1583372177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-5a9ac8d83d243fff919b6268e8440d704e3b93d1%2Fdedicated-deployments.yaml?alt=media)
{% endopenapi %}

### Update a Startup Script

To change the startup script of an existing deployment, see [Startup Scripts](/deployment/roboflow-cloud/dedicated-deployments/startup-scripts.md#http-api).

## Python SDK

[Dedicated Deployments](/deployment/roboflow-cloud/dedicated-deployments.md) 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:
        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="dev-gpu",
    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["domain"])
```

### 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:
    print(entry["timestamp"], entry["payload"])
```

### 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 `domain` (returned by `get_deployment`):

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

client = InferenceHTTPClient(
    api_url=f"https://{body['domain']}", api_key="YOUR_API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))
result = client.infer("photo.jpg", model_id="my-detector/3")
```

## CLI

You can create, monitor, and manage [Dedicated Deployments](/deployment/roboflow-cloud/dedicated-deployments.md) 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 dev-gpu -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
```