# Fabric API - Jobs

run\_job, wait\_for\_job, get\_job and cancel\_job, the job types for notebooks, pipelines and report refreshes, and the statuses.

Running a notebook, running a pipeline and refreshing a report's data are all jobs in Fabric, and the four methods below start, wait for, check and cancel them. Each method takes the workspace ID and the ID of the item the job belongs to.

## Job types {#job-types}

| Item | Job type | What it does |
| --- | --- | --- |
| Notebook | `RunNotebook` | Runs the notebook once |
| Pipeline | `Pipeline` | Runs the pipeline once |
| A report's dataset | `DefaultSemanticModelRefresh` | Refreshes the report's data from the tables it reads |

## Statuses {#statuses}

`get_job` reports one of these in `status`:

| Status | Meaning |
| --- | --- |
| `NotStarted` | Accepted, not yet running |
| `InProgress` | Running |
| `Completed` | Ended without error |
| `Failed` | Ended with an error, details in `failureReason` |
| `Cancelled` | Stopped with `cancel_job` or from Fabric |
| `Deduped` | Not started, because the same job was already running |

The first two mean the job is still going, everything else means it has ended.

## run\_job {#run_job}

```python
conn.run_job(workspace_id, item_id, job_type, payload=None)
```

Starts a job and returns without waiting for it.

| Parameter | Type | Meaning |
| --- | --- | --- |
| `workspace_id` | str | The workspace the item is in |
| `item_id` | str | The notebook, pipeline or dataset |
| `job_type` | str | One of the job types above |
| `payload` | dict | Parameters for the job, or none |

Returns the job's ID as a string, for `get_job` and `cancel_job`.

Parameters go under `executionData`. A notebook takes them with a value and a type each, a pipeline takes plain values:

```python
# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class RunNotebook(Service):

    def handle(self):

        workspace_id = '262ddd3d-3d0d-4495-b80f-6dddda1e23a1'
        notebook_id = 'ba7b1e23-b680-4fe7-a982-2a979b125604'

        conn = self.microsoft.fabric['Zato Fabric']

        payload = {
            'executionData': {
                'parameters': {
                    'location': {'value': 'Riverside', 'type': 'string'},
                    'days_ahead': {'value': '1', 'type': 'int'},
                }
            }
        }

        job_id = conn.run_job(workspace_id, notebook_id, 'RunNotebook', payload)

        self.response.payload = {'job_id': job_id}
```

```python
payload = {
    'executionData': {
        'parameters': {
            'source_table': 'admissions',
            'target_table': 'occupancy',
        }
    }
}

job_id = conn.run_job(workspace_id, pipeline_id, 'Pipeline', payload)
```

A report refresh takes no parameters:

```python
job_id = conn.run_job(workspace_id, dataset_id, 'DefaultSemanticModelRefresh')
```

## wait\_for\_job {#wait_for_job}

```python
conn.wait_for_job(workspace_id, item_id, job_id, timeout=1800, interval=10.0)
```

Waits until a job ends and returns its final state, checking with `get_job` every `interval` seconds.

| Parameter | Type | Meaning |
| --- | --- | --- |
| `workspace_id` | str | The workspace the item is in |
| `item_id` | str | The item the job belongs to |
| `job_id` | str | The ID `run_job` returned |
| `timeout` | int | How many seconds to wait at most, 30 minutes by default |
| `interval` | float | How many seconds between two checks, 10 by default |

Returns the same dict as `get_job` once the status is `Completed`. A job that ends with any other status raises an exception with the job's details, and so does one that is still running when the timeout passes, the job itself keeps running in Fabric then.

```python
# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class RunAndWait(Service):

    def handle(self):

        workspace_id = '262ddd3d-3d0d-4495-b80f-6dddda1e23a1'
        pipeline_id = 'bf4868aa-05c8-4213-ab4d-8dcbe3189767'

        conn = self.microsoft.fabric['Zato Fabric']

        job_id = conn.run_job(workspace_id, pipeline_id, 'Pipeline')
        job = conn.wait_for_job(workspace_id, pipeline_id, job_id, timeout=600)

        self.response.payload = {'status': job['status'], 'ended': job['endTimeUtc']}
```

```json
{"status": "Completed", "ended": "2026-09-02T02:34:11Z"}
```

## get\_job {#get_job}

```python
conn.get_job(workspace_id, item_id, job_id)
```

Returns the job's current state without waiting for it.

| Parameter | Type | Meaning |
| --- | --- | --- |
| `workspace_id` | str | The workspace the item is in |
| `item_id` | str | The item the job belongs to |
| `job_id` | str | The ID `run_job` returned |

Returns a dict with `id`, `itemId`, `jobType`, `invokeType`, `status`, `startTimeUtc`, `endTimeUtc` and, for a failed job, `failureReason`.

```python
# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class GetJob(Service):

    input = 'job_id'

    def handle(self):

        workspace_id = '262ddd3d-3d0d-4495-b80f-6dddda1e23a1'
        notebook_id = 'ba7b1e23-b680-4fe7-a982-2a979b125604'

        # The ID of a job that run_job returned earlier
        job_id = self.request.input.job_id

        conn = self.microsoft.fabric['Zato Fabric']

        job = conn.get_job(workspace_id, notebook_id, job_id)

        self.response.payload = {
            'status': job['status'],
            'started': job['startTimeUtc'],
            'ended': job['endTimeUtc'],
        }
```

```json
{"status": "Completed", "started": "2026-09-02T02:30:04Z", "ended": "2026-09-02T02:34:11Z"}
```

## cancel\_job {#cancel_job}

```python
conn.cancel_job(workspace_id, item_id, job_id)
```

Stops a running job. Returns nothing, the job's status becomes `Cancelled` once it has stopped.

| Parameter | Type | Meaning |
| --- | --- | --- |
| `workspace_id` | str | The workspace the item is in |
| `item_id` | str | The item the job belongs to |
| `job_id` | str | The ID `run_job` returned |

```python
# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class CancelJob(Service):

    input = 'job_id'

    def handle(self):

        workspace_id = '262ddd3d-3d0d-4495-b80f-6dddda1e23a1'
        notebook_id = 'ba7b1e23-b680-4fe7-a982-2a979b125604'

        # The ID of a job that run_job returned earlier
        job_id = self.request.input.job_id

        conn = self.microsoft.fabric['Zato Fabric']

        conn.cancel_job(workspace_id, notebook_id, job_id)
```

## See also {#see-also}

- [Fabric notebooks and pipelines](https://zato.io/docs/dev/examples/cloud/fabric/notebooks-and-pipelines.html) - run\_job and wait\_for\_job for a notebook, a pipeline and a report refresh
- [Fabric API - Workspaces](https://zato.io/docs/dev/examples/cloud/fabric/api/workspaces.html) - Finding the item IDs the jobs need

## Learn more {#learn-more}

- [Development documentation](https://zato.io/docs/dev/) - The complete reference for writing services
- [Requests and responses](https://zato.io/docs/dev/request-response/) - What a service receives, what it returns and how both are structured
- [Integration examples](https://zato.io/docs/dev/examples/) - Ready-made code for the systems you are likely to connect to
- [IDE and debugging](https://zato.io/docs/dev/ide/) - Write services in the Dashboard or in your own editor
- [Data models](https://zato.io/docs/dev/model/) - Declare inputs and outputs and have them validated for you
- [In-depth API tutorial](https://zato.io/tutorials/main/01.html) - The full platform tutorial, from installation to production patterns