How to Deploy RF-DETR to an NVIDIA Jetson

RF-DETR is a state-of-the-art, real-time object detection model developed by Roboflow. RF-DETR is the first model to achieve over 60% mAP on the Microsoft COCO benchmark, and achieves the best recorded results on the new RF100-VL benchmark. RF-DETR is licensed under an Apache 2.0 license.

RF-DETR was designed with edge deployment in mind, especially on the NVIDIA Jetson devices commonly used to deploy vision models. In this guide, we’re going to walk through how to deploy an RF-DETR model to an NVIDIA Jetson.

We’ll build and run an application that counts boxes that cross a line, like this:

Without further ado, let’s get started!

Requirements

To follow this guide, you will need:

1. A free Roboflow account.
2. A trained RF-DETR model.
3. An NVIDIA Jetson with:
   1. Jetpack version 5 or greater installed.
   2. Python 3.12 or greater installed.

Don’t have an RF-DETR model yet? Follow our guide to train a model on the Roboflow platform, or our guide to train an RF-DETR model in a notebook.

For this guide, we are going to demonstrate how to deploy a model that identifies packages on an assembly line. You can use the same model as we are in this guide by using the model ID “conveyor-belt-box-identification/1” as your model.

Step #1: Create a Workflow with an RF-DETR Model

Once you have an RF-DETR model, you can deploy it with Roboflow Workflows, a tool for building computer vision applications. You can build a Workflow in a web-based application builder, then deploy it to your edge device.

Open your Roboflow dashboard, then click “Workflows” in the left sidebar. Click “Create Workflow”. You will then have a blank Workflow:

Click “Add a Model”, then choose “Object Detection Model”:

Then, choose your RF-DETR model, or set the model ID to “conveyor-belt-box-identification/1” if you want to use our model:

For this guide, we are going to build an application that tracks when boxes pass a specific point on an assembly line. For this, we will need two Workflow blocks:

• Byte Track
• Line Counter

Add the Byte Track block after your model:

Then, add a Line Counter block:

Click “Set Polygon Zone” in the block configuration:

Then, draw a line where you want to count objects that cross it:

Click “Save” to save the line.

Finally, update the “Output” of your Workflow to return the count_out value from the line counter:

We now have an application that tracks when objects cross our line. We can deploy this application on our NVIDIA Jetson.

Step #2: Install Inference

To deploy our RF-DETR model and application, we first need to install Docker. To install Docker, refer to the official Docker installation instructions.

Next, we need to install the CLI for Inference, Roboflow’s open source computer vision inference server. You can install the Inference CLI on an NVIDIA Jetson with the following command:

pip install inference-cli

Then, run:

inference server start

With Docker and Inference installed and an Inference server running, we can start to run our application.

Step #3: Run RF-DETR on Your Jetson

Let’s run our Workflow on a Jetson. Create a new Python file and add the following code:

from inference import InferencePipeline
import cv2

client = InferenceHTTPClient(
    api_url="http://localhost:9001",
    api_key="<ROBOFLOW-API-KEY>"
)

pipeline = client.start_inference_pipeline_with_workflow(
    video_reference=["rtsp://0.0.0.0:8000/rtsp"],
    workspace_name="your-workspace-id",
    workflow_id="your-workflow-id",
)

last_count = 0

print(client.get_inference_pipeline_status(pipeline["context"]["pipeline_id"]))

while True:
    result = client.consume_inference_pipeline_result(pipeline_id=pipeline["context"]["pipeline_id"])
    if len(result["outputs"]) > 0:
        print(result["outputs"][0]["count"])
    if result.get("outputs") and result.get("count"): # and result["count"] != last_count:
        last_count = result["count"]
        print(result["count"], "boxes crossed line as of", datetime.now())

Above, set:

• rtsp://0.0.0.0:8000/rtsp with your RTSP stream ID and name, or 0 to use your default webcam. If you use a webcam, make sure your Inference Docker container has access to your device webcams.
• ROBOFLOW_API_KEY to your Roboflow API key.
• YOUR_WORKSPACE_ID to your Workspace ID.
• YOUR_WORKFLOW_ID to your Workflow ID.

You can find your Workflow and Workspace ID by clicking “Deploy” in the Workflow editor and copying the Workflow and Workspace IDs:

If you are using our conveyor belt demo model, you can download an example video for use in trying the application.

Then, run the script on your Jetson.

When you run the script, the inference pipeline will be set up. Then, you will see a statement printed to the console every time an object crosses the line:

1 boxes crossed line as of 2025-06-25 16:41:38.131605
2 boxes crossed line as of 2025-06-25 16:41:39.225315
3 boxes crossed line as of 2025-06-25 16:41:40.126959
4 boxes crossed line as of 2025-06-25 16:41:42.010929
5 boxes crossed line as of 2025-06-25 16:41:43.176459
6 boxes crossed line as of 2025-06-25 16:41:44.808888
7 boxes crossed line as of 2025-06-25 16:41:46.817398
8 boxes crossed line as of 2025-06-25 16:41:48.448223
9 boxes crossed line as of 2025-06-25 16:41:49.701839

We successfully deployed RF-DETR on a Jetson in an application that counts boxes crossing an assembly line!

We can show predictions in real time by adding a Bounding Box Visualization that reads predictions from the detection model, and a Line Counter Visualization that reads the image returned by the Bounding Box Visualization and the detections from the Line Counter:

You can fork this Workflow if you want a pre-made template without having to build the Workflow manually.

Here is an example of the Workflow running:

We can see the counter increment every time an object crosses a line. For production applications, we recommend not using visualizations as they add overhead to processing time. But for demo purposes, visualizations give you insight into how your system is performing.

Conclusion

RF-DETR is an open source, real-time, state-of-the-art object detection model. You can deploy RF-DETR on an NVIDIA Jetson. In this guide, we built an application that uses a pre-trained model to identify boxes on an assembly line, then deployed the application on a Jetson.

To learn more about RF-DETR, refer to the RF-DETR announcement and project GitHub repository.

Cite this Post

Use the following entry to cite this post in your research:

James Gallagher. (Jun 26, 2025). How to Deploy RF-DETR to an NVIDIA Jetson. Roboflow Blog: https://blog.roboflow.com/how-to-deploy-rf-detr-to-an-nvidia-jetson/