Robocorp

3.1.1 · active · verified Wed Apr 15

Robocorp provides core Python libraries for robotic process automation (RPA), enabling developers to create and manage automated tasks. It includes modules for task orchestration, work item management, and integration with the Robocorp platform. The current version is 3.1.1, with regular updates typically released multiple times per quarter.

Warnings

breaking The `robocorp.browser` and `robocorp.windows` modules included directly in the `robocorp` package are frozen at older versions (1.x as of `robocorp` v3.x). For up-to-date and feature-rich browser or Windows automation, you must explicitly install `rpaframework-browser` and `rpaframework-windows` and import from those packages (e.g., `from rpaframework.browser import ...`).
Fix: For new projects or updated features, `pip install rpaframework-browser rpaframework-windows` and update imports to `from rpaframework.browser import ...` or `from rpaframework.windows import ...`.
breaking Major refactor in v2.0.0 moved primary task and work item functionalities into dedicated sub-packages. Old imports like `from robocorp import task` or `from robocorp import workitems` no longer work.
Fix: Update imports to `from robocorp.tasks import task` for task decorators and `from robocorp.workitems import inputs, outputs` for work item management.
gotcha Robocorp tasks operate within a specific environment, heavily relying on 'work items' for input and output data. When running tasks locally or debugging, ensure you provide valid `work-items/input.json` files to simulate the expected inputs, or tasks might fail attempting to access non-existent data.
Fix: Create a `work-items` directory in your project root with `input.json` (and optionally `output.json`) files containing sample data. Use `rcc` or `python -m robocorp.tasks run` commands for local execution to ensure the environment is correctly set up.
gotcha While `robocorp` is the core Python library, Robocorp's ecosystem includes other critical tools like `rcc` (Robocorp Command Center) for environment management and `Action Server` for exposing automations as APIs. These are separate installations and tools, and the `robocorp` library itself doesn't directly provide their functionality.
Fix: Understand the role of each tool in the Robocorp ecosystem. Install `rcc` separately for environment control, and `robocorp-action-server` if you need to create HTTP APIs for your automations.

Install

pip install robocorp Install Robocorp core libraries

Imports

task
wrong:
```
from robocorp import task
```
correct:
```
from robocorp.tasks import task
```
As of v2.0.0, the task decorator moved to the `robocorp.tasks` module.
inputs
wrong:
```
from robocorp import workitems
```
correct:
```
from robocorp.workitems import inputs
```
As of v2.0.0, work item management moved to the `robocorp.workitems` module.
outputs
```
from robocorp.workitems import outputs
```
Accesses the current output work item.
page
wrong:
```
from robocorp.browser import browser
```
correct:
```
from rpaframework.browser import page
```
While `robocorp.browser` (v1.x) is still bundled with `robocorp` v3.x, for the latest browser automation features, users should explicitly install `rpaframework-browser` and import from it.

Quickstart

This quickstart demonstrates creating a simple Robocorp task that reads data from an input work item, processes it, and then writes the result to an output work item. It highlights the core 'task' decorator and 'workitems' modules, which are central to Robocorp automations.

import os
from robocorp.tasks import task
from robocorp.workitems import inputs, outputs

@task
def minimal_task():
    """
    A basic Robocorp task that reads an input and writes an output.
    
    To run locally, create a 'work-items/input.json' file in the root of your project
    with content like: `{"message": "Hello Robocorp!"}`
    Then execute with `python -m robocorp.tasks run -t minimal_task`.
    """
    try:
        # Access current input work item payload
        input_payload = inputs.current.payload
        message = input_payload.get("message", "No message provided.")
        print(f"Received message: {message}")

        # Process the message
        processed_message = f"Processed by Robocorp: {message.upper()}"

        # Create an output work item and save processed data
        output_item = outputs.create()
        output_item.payload["processed_message"] = processed_message
        output_item.save()

        print(f"Wrote output: {processed_message}")

    except Exception as e:
        # In a real scenario, you'd handle errors more robustly for Control Room visibility
        print(f"Task failed: {e}")
        raise # Re-raise to indicate task failure

view raw JSON →