---
title: "DOBOT integration: drive robot arms directly"
description: "DOBOT integration for Core: 22 native blocks drive arm, gripper and camera over TCP. From pick-and-place to an autonomous cell, tested in simulation first."
url: "https://rual.nl/en/integrations/dobot"
locale: en
alternate: "https://rual.nl/integrations/dobot"
updated: 2026-09-11
source: "https://rual.nl"
---

[Integrations](https://rual.nl/en/integrations) > DOBOT

# Drive DOBOT robot arms directly from Core.

Core talks to DOBOT robotics natively: 22 blocks drive the arm, the gripper and the camera straight over TCP, with no control layer in between. For anyone looking at pick-and-place or a full robot cell, from one arm at a packing table to an autonomous line.

[Book a demo](https://rual.nl/en/demo)

[See all integrations](https://rual.nl/en/integrations)

## The arm does what the flow says

- **The instruction comes from your flow** — What the robot does follows from your process: an order, a task or a signal in Core decides the movement. You build that logic in the same editor as the rest of your application.

- **Arm, gripper and camera over TCP** — The blocks talk straight over TCP to the arm, the gripper and the camera. No layer from an outside vendor in between.

- **Vision reports back into the flow** — The camera sees what is in front of the arm and where it sits, and that picture arrives live in your flow. Your process decides the next movement from there.

- **From pick-and-place to an autonomous cell** — Start with one arm doing repetitive picking and placing, around the clock if that is what the line needs. Grow into a cell that uses vision to pick its own next step. Same blocks, same control.

## How the integration works

Every DOBOT block is a building block in Core: drag it into your flow and connect it to your orders, your stock or your camera. The blocks address the robot directly over TCP, so no extra control sits between your process and the arm.

Before any hardware moves, the cell runs in our simulator. Grip points, cycle times and exceptions are tested digitally, so the physical installation holds no surprises.

- **Blocks** — 22 native DOBOT blocks in the Core 14 block library.

- **Protocol** — Straight over TCP, with no vendor layer in between.

- **Driven** — Robot arm, gripper and camera.

- **Direction** — Instructions out, camera feed and status in.

- **Scale** — From one pick-and-place arm to a fully autonomous cell.

- **First** — The cell runs in simulation before it reaches your floor.

## The questions we get most about the DOBOT integration

Three questions we hear in nearly every first conversation.

### Is there no extra controller between Core and the robot?

No. The DOBOT blocks in Core talk straight over TCP to arm, gripper and camera, with no layer from an outside vendor in between. The same control layer already runs entire distribution lines at our customers.

### How do I know the cell works before it stands on my floor?

We rebuild the cell in our simulator first. Grip points, cycle times and exceptions are tested digitally, so you see how the cell performs before you commit to anything.

### What if a command I need has no block yet?

File a request and the block is in there within a week, built and maintained by us. And if a connection truly goes off the beaten path, you can write your own block in ReactJS.

## The integration does not stop at the arm

- **[Robotics](https://rual.nl/en/robotics)** — From a single arm at a packing table to a complete line: this is how we build robot cells that see what is in front of them and pick the next step through Core.

## Wondering what a robot cell would do in your process?

Name your process and we will show you in the demo how the control runs, from flow to gripper.

[Book a demo](https://rual.nl/en/demo)

[Get in touch](https://rual.nl/en/contact)