---
title: "Collibra Setup for Validatar"
slug: "collibra-setup-for-validatar"
updated: 2026-11-05T20:44:20Z
published: 2026-11-05T20:44:20Z
canonical: "docs.validatar.com/collibra-setup-for-validatar"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.validatar.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Collibra Setup for Validatar

## Overview

The [Collibra integration](/docs/collibra-integration) publishes Validatar's results into Collibra as **Data Quality Rule** assets. Collibra averages the **Passing Fraction** of those rules and shows the result in the **External Data Quality** section of the **Quality** tab on each column, table, schema and database. This article is for the Collibra admin who prepares Collibra for that, once.

Preparing Collibra takes five things:

| What | Why | Done by |
| --- | --- | --- |
| An identity for the integration | Validatar signs in to Collibra with it | You, in Collibra |
| A **Validatar** community and a **Validatar Data Quality** domain | Every rule Validatar publishes lives there, apart from your own assets | `collibra_setup.py`, or by hand |
| The attributes and relation types a rule needs | Each rule carries a Passing Fraction and row counts, governs a column or table, and is classified by a dimension | Checked by `collibra_setup.py`; you add anything missing |
| A Data Quality Dimension for each Validatar dimension, or a map to yours | So Collibra can break scores down by dimension | Checked by `collibra_setup.py`; you choose the map |
| One quality score aggregation path for rules that govern whole tables | Collibra's built-in paths roll scores up from columns only | You, in Collibra |

`collibra_setup.py` ships in the [Collibra Metadata and Lineage Scripts](/docs/collibra-metadata-and-lineage-scripts) download from the Validatar marketplace ([get it here](https://admin.cloud.validatar.com/marketplace/93)). It reads Collibra and prints a plan by default, and creates only what is missing when you add `--apply`.

## Where Validatar's results appear

Each published Validatar test becomes one Data Quality Rule in the Validatar Data Quality domain:

| Part of the rule | Value |
| --- | --- |
| Name | `Validatar test <id>`, with the test's name, or the name its owner chose for Collibra, as the display name |
| Status | Accepted |
| Passing Fraction | The test's quality score under its Scoring Method in Validatar |
| Loaded Rows, Rows Passing, Rows Breaking | The row counts of the latest run, when the test counts rows |
| Description | The result, when the test last ran, and a **View in Validatar** link to the test |
| Relations | The column or table the rule governs, and the Data Quality Dimension that classifies it |

When the Collibra data source publishes one rule per table, or per table and dimension, the rule governs the Table asset and its display name says so, for example `Validatar quality: STAR_SCHEMA.FACT_SALES`.

Collibra identifies each rule by an external id that names the Validatar instance and the test, so a rule is updated in place on every run and never duplicated. Validatar never changes your own assets' attributes, statuses or responsibilities. The only writes outside the Validatar domain are the relations from its rules to the columns and tables they govern, and the optional score attributes described below.

## Create the integration's identity

Use an **Integration OAuth application**, so the integration has its own identity with its own permissions:

1. In Collibra, open **Settings > OAuth Applications** and register an application of type **Integration**.
2. Copy the client ID and the client secret. The secret is shown once.
3. Give the application's system user the roles below.

Collibra OAuth tokens last five minutes, and each application draws its tokens from a small pool. The integration keeps its token between runs and reuses it until shortly before it expires, so a busy schedule does not drain the pool. Use one application for Validatar alone; sharing it with other tools spends the same pool.

For self-hosted or older instances, the Collibra data source also accepts a Collibra user name and password (Basic sign-in), which uses no tokens.

### Permissions for the integration

| Permission | Needed for |
| --- | --- |
| Read access to the physical data dictionary domains of the databases in scope | The metadata and lineage scripts, matching tables when publishing, and the health checks |
| A role that can create and edit assets in the **Validatar Data Quality** domain | Publishing rules, and removing or retiring them |
| Permission to add relations from those rules to columns and tables | Placing each rule on the asset it governs |
| A role that can list users | The health check **Responsible users are active** |
| A role that can see every user's jobs and workflow tasks | The health checks **No failed jobs** and **No overdue workflow tasks**. Without it they see only the integration's own |

Use an admin only to run `collibra_setup.py --apply`. The integration itself should run with the smaller set above.

## Run the setup script

### Before you start

- Python 3.10 or later on any machine that can reach your Collibra instance over HTTPS. The script uses the Python standard library only.
- A Collibra admin, for `--apply`. Without `--apply` any user who can read the operating model will do.

### Steps

1. Unzip the download and open a terminal in its folder.
2. Tell the script where Collibra is and how to sign in:

```
export COLLIBRA_BASE_URL=https://acme.collibra.com
export COLLIBRA_AUTH_METHOD="OAuth Client"      # or: Basic
export COLLIBRA_OAUTH_CLIENT_ID=...
export COLLIBRA_OAUTH_CLIENT_SECRET=...
```

For Basic, set `COLLIBRA_USERNAME` and `COLLIBRA_PASSWORD` instead. On Windows, use `set NAME=value` in place of `export NAME=value`.
3. See the plan. This changes nothing:

```
python collibra_setup.py
```

It prints one line per item, with its state:

```
exists:        Community              Validatar
would create:  Domain                 Validatar Data Quality  (domain type Rulebook)
ok:            Rule attribute         Passing Fraction
missing:       Rule attribute         Rows Breaking  (add it to the Data Quality Rule assignment)
ok:            Relation type          governs a column or table
missing:       Dimension              Standards
```
4. Create what is missing:

```
python collibra_setup.py --apply
```

It creates the **Validatar** community and the **Validatar Data Quality** domain (domain type Rulebook) and prints the domain's id. Put that id in **Validatar Domain ID** on the Collibra data source in Validatar, or leave the setting blank and the template finds the domain by its name.
5. Work through what the plan reports as missing, as described in the next sections.
6. Add the aggregation path for table-level rules by hand. The script prints this step but cannot do it.

| Option | What it does |
| --- | --- |
| *(none)* | Prints the plan. Changes nothing |
| `--apply` | Creates the community, the domain and, with `--score-attributes`, the score attribute types |
| `--score-attributes` | Adds the optional table score attributes to the plan |
| `--csv <file>` | Also writes the plan as a CSV checklist |

The script is safe to run again. It creates only what is missing and never changes or deletes anything that exists. To try it without Collibra, set `COLLIBRA_DEMO_MODE=1`; it then runs against the built-in sample instance.

## Rule attributes

The script checks that the Data Quality Rule asset type carries the attributes Validatar writes: **Passing Fraction**, **Loaded Rows**, **Rows Passing**, **Rows Breaking** and **Description**. These ship with Collibra, but an operating model can leave some unassigned. Add a missing one to the Data Quality Rule asset type's assignment in **Settings > Operating Model**.

Until you do, each publish leaves that attribute out and lists it under `rule_attributes_not_assigned` in the summary the publish test prints. The rest of the rule is still written.

## Relation types

A rule needs two relation types: one that lets a Data Quality Rule govern a column or table, and one that classifies a rule by a Data Quality Dimension. The template finds both by their roles and asset types, so an operating model that renamed them still works. The script reports which relation type it found for each, and a missing one if it found none. Without the "governs" relation the rule is published but appears on no asset's Quality tab; without the dimension relation it is published without a dimension.

## Quality dimensions

Validatar has 13 [quality dimensions](/docs/quality-dimensions): Completeness, Uniqueness, Validity, Consistency, Accuracy, Timeliness, Standards, Relationships, Security, Precision, Performance, Processing and Compliance. Each published rule is classified by the Data Quality Dimension asset of the same name.

The script lists the Validatar dimensions with no Collibra dimension of that name, and the dimensions Collibra has. For each missing one, either create the dimension in Collibra, or map it to one of yours with **Dimension Map** on the Collibra data source in Validatar:

```
Validity=Conformity; Standards=Conformity; Relationships=Integrity
```

A rule whose dimension is neither found nor mapped is published without a dimension. A test owner can also pick the Collibra dimension for one test with its **Collibra Dimension** field.

## Aggregation paths

Collibra's built-in quality score aggregation paths start at columns: a column is governed by a rule, and its score rolls up to the table, schema and database. A rule that governs a Table directly needs one more path.

Rules govern tables when:

- **Publish Scope** is **Trust Score** (one rule per table) or **Trust + Dimensions** (one rule per table and dimension)
- a test is not linked to exactly one column in Validatar, and its **Collibra Target Asset ID** field does not name a column

Add the path **Table is governed by Data Quality Rule** in Collibra's quality score aggregation settings (**Settings > Data Quality > Quality score aggregations** in the current interface). For external data, Collibra allows a path to end at any asset type.

> **Note:** Collibra warns that editing an aggregation in the current interface removes assignments made in the classic interface. Check existing paths before you change one.

## Optional score attributes on tables

The rules are the supported route. The Collibra data source can also write Validatar's table scores as attributes on each matched Table asset, for teams who want them on the asset's summary:

| Attribute | Kind |
| --- | --- |
| Validatar Trust Score | Numeric (0 to 100; Validatar's 0 to 5 stars times 20) |
| Validatar Quality Score | Numeric |
| Validatar Coverage Score | Numeric |
| Validatar Last Run | Date |
| Validatar Link | Text |

1. Run `python collibra_setup.py --score-attributes --apply` to create the attribute types.
2. In **Settings > Operating Model**, add them to the assignment of the Table asset type, and of Database View if you publish views.
3. Turn on **Score Attributes** on the Collibra data source in Validatar.

These attributes go to your own Table assets, so Validatar writes them in a separate import that never removes anything. They are off by default.

## Choosing the Passing Fraction scale

Validatar writes each rule's Passing Fraction as a percentage (98.5) by default, or as a fraction (0.985) when **Passing Fraction Scale** on the Collibra data source is **Fraction (0-1)**. Collibra's documentation does not state which scale it expects from external tools. Use the scale your other Collibra data quality scores use, and check one rule's Quality tab after the first publish.

## Check the setup

1. In Validatar, run the Collibra data source's publish test with **Dry Run** on. Its rows list each rule it would publish, the asset it governs, its dimension and its Passing Fraction. The summary it prints names any attribute the rule asset type is missing.
2. Turn **Dry Run** off and run it again.
3. In Collibra, open the **Validatar Data Quality** domain: it lists the rules.
4. Open one of the governed columns or tables and its **Quality** tab. The **External Data Quality** section shows the score.

## Troubleshooting

| Symptom | Cause | Fix |
| --- | --- | --- |
| `collibra_setup.py --apply` fails with 401 | The OAuth secret was regenerated, the application deleted, or the password changed | Set the environment variables again with current credentials |
| `collibra_setup.py --apply` fails with 403 | The credential cannot create communities, domains or attribute types | Run it as an admin |
| The publish test's summary lists `rule_attributes_not_assigned` | The Data Quality Rule asset type lacks those attributes in your operating model | Add them to the asset type's assignment |
| Rules exist but no asset shows a score | No relation type lets a rule govern a column or table, or the integration may not add relations to those assets | Check the script's relation type lines; give the integration permission on the physical domains |
| Column scores show, table-level rules do not | The aggregation path for tables is missing | Add **Table is governed by Data Quality Rule** |
| Rules show without a dimension | No Collibra dimension has that name, and **Dimension Map** does not map it | Create the dimension, or map it |
| Scores look 100 times too large or too small | The Passing Fraction scale differs from what your Collibra instance shows | Change **Passing Fraction Scale** on the Collibra data source |
| "Collibra domain 'Validatar Data Quality' not found" | The domain was never created, or has another name | Run `collibra_setup.py --apply`, or set **Validatar Domain ID** |
| HTTP 429 | The OAuth application's token pool, or Collibra's throttling, was reached | The integration waits and retries. Do not share the application with other tools |

## Related

- [Collibra Integration](/docs/collibra-integration)
- [Collibra Data Source Template](/docs/collibra-data-source-template)
- [Collibra Metadata and Lineage Scripts](/docs/collibra-metadata-and-lineage-scripts)
- [Collibra Instance Health Checks](/docs/collibra-instance-health-checks)
- [Collibra Project Custom Fields](/docs/collibra-project-custom-fields)
- [Quality Dimensions](/docs/quality-dimensions)

> **Note:** This article describes the design of the Validatar and Collibra integration. The setup script has been built from Collibra's documentation and published OpenAPI specifications and tested offline against a built-in sample Collibra instance. It has not yet been run against a live Collibra instance, so menu names, relation types and the Passing Fraction scale may differ from those shown here. To discuss using it, contact your Validatar account team.