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

# Preview competitor exclusions

> Dry-run exact source exclusion rules against selected frozen inventories.

`preview_competitor_exclusions`

Dry-run exact source exclusion rules against selected frozen inventories. Returns before/after counts and bounded matched/collateral examples. Does not save rules, buy discovery, check links or alter evidence.

<Note>Available in the deployed MCP and HTTP bundle. Confirm access and inputs with your connected catalog. Workspace scopes and enabled providers still apply.</Note>

| Access           | Behavior         |
| ---------------- | ---------------- |
| `discovery:read` | Reads saved data |

This read does not start a verification job.

## Example request

Connect through [MCP](/guides/connect-mcp), [CLI](/guides/connect-cli), or [HTTP](/guides/connect-http). Replace example identifiers with records from your workspace.

<CodeGroup>
  ```json MCP theme={null}
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "preview_competitor_exclusions",
      "arguments": {
        "setId": "set_example",
        "revision": 1,
        "inventoryIds": [
          "inventory_example",
          "inventory_example_1"
        ],
        "grouping": "page"
      }
    }
  }
  ```

  ```bash CLI theme={null}
  agentlinkops call preview_competitor_exclusions --args '{"setId":"set_example","revision":1,"inventoryIds":["inventory_example","inventory_example_1"],"grouping":"page"}'
  ```

  ```bash HTTP theme={null}
  curl "$AGENTLINKOPS_API_URL/v1/commands/preview_competitor_exclusions" \
    -H "Authorization: Bearer $AGENTLINKOPS_API_KEY" \
    -H 'Content-Type: application/json' \
    --data '{"setId":"set_example","revision":1,"inventoryIds":["inventory_example","inventory_example_1"],"grouping":"page"}'
  ```
</CodeGroup>

## Returned result

Illustrative data validated against the documented response schema. IDs and dates are examples, not a live account capture. MCP returns this data in `structuredContent` and in a text content block; generic HTTP and CLI return the JSON result directly.

<Accordion title="Full response example">
  ```json theme={null}
  {
    "v": 1,
    "set_id": "set_example",
    "set_revision": 1,
    "grouping": "page",
    "comparison": {
      "mode": "observed_overlap_only",
      "reasons": [
        "incomplete_query_coverage"
      ],
      "absence_claim": "not_supported"
    },
    "absence_claim": "not_supported",
    "whole_web_coverage": false,
    "coverage_scope": "selected_inventory_datasets",
    "verification_view": "captured_at_snapshot",
    "max_retrieval_skew_ms": 86400000,
    "selected_inventory_ids": [
      "inventory_example",
      "inventory_example_1"
    ],
    "unselected_member_ids": [],
    "exclusions": {
      "scope": "request_only",
      "policy": "any_source_row_hides_group",
      "rules": []
    },
    "inventories": [
      {
        "v": 1,
        "id": "inventory_example",
        "workspace_id": "ws_example",
        "project_id": "pr_example",
        "set_id": "set_example",
        "set_revision": 1,
        "set_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
        "member_id": "cm_customer",
        "member_role": "customer",
        "target_scope_id": "ts_example",
        "captured_at": "2026-09-13T12:00:00.000Z",
        "provider_retrieved_from": "2026-09-13T12:00:00.000Z",
        "provider_retrieved_to": "2026-09-13T12:00:00.000Z",
        "run": {
          "v": 1,
          "id": "dr_example",
          "workspace_id": "ws_example",
          "project_id": "pr_example",
          "provider": "linktrail_corpus",
          "data_mode": "owned_corpus",
          "query": {
            "target_kind": "domain",
            "target": "example.com",
            "include_subdomains": true,
            "backlinks_status_type": "live",
            "exclude_internal_backlinks": true,
            "mode": "as_is",
            "filters": null,
            "order_by": [
              "first_seen,desc"
            ],
            "rank_scale": null,
            "page_limit": 100,
            "row_limit": 100
          },
          "status": "succeeded",
          "created_at": "2026-09-13T12:00:00.000Z",
          "started_at": "2026-09-13T12:00:00.000Z",
          "finished_at": "2026-09-13T12:00:00.000Z",
          "coverage": "complete_for_query",
          "coverage_reason": null,
          "provider_total_count": 1,
          "usage": {
            "unit": "discovery",
            "currency": "USD",
            "quote_id": "owned_example",
            "max_cost_microusd": 0,
            "reserved_cost_microusd": 0,
            "provider_reported_cost_microusd": 0,
            "request_count": 1,
            "returned_rows": 1,
            "accepted_candidates": 1,
            "rejected_rows": 0,
            "duplicate_rows": 0
          },
          "operation": "backlinks",
          "coverage_scope": "corpus_subset",
          "whole_web_coverage": false
        },
        "content_hash": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
        "absence_claim": "not_supported",
        "verification_view": "captured_at_snapshot"
      },
      {
        "v": 1,
        "id": "inventory_example_1",
        "workspace_id": "ws_example",
        "project_id": "pr_example",
        "set_id": "set_example",
        "set_revision": 1,
        "set_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
        "member_id": "cm_competitor",
        "member_role": "competitor",
        "target_scope_id": "ts_example",
        "captured_at": "2026-09-13T12:00:00.000Z",
        "provider_retrieved_from": "2026-09-13T12:00:00.000Z",
        "provider_retrieved_to": "2026-09-13T12:00:00.000Z",
        "run": {
          "v": 1,
          "id": "dr_example",
          "workspace_id": "ws_example",
          "project_id": "pr_example",
          "provider": "linktrail_corpus",
          "data_mode": "owned_corpus",
          "query": {
            "target_kind": "domain",
            "target": "competitor.example.org",
            "include_subdomains": true,
            "backlinks_status_type": "live",
            "exclude_internal_backlinks": true,
            "mode": "as_is",
            "filters": null,
            "order_by": [
              "first_seen,desc"
            ],
            "rank_scale": null,
            "page_limit": 100,
            "row_limit": 100
          },
          "status": "succeeded",
          "created_at": "2026-09-13T12:00:00.000Z",
          "started_at": "2026-09-13T12:00:00.000Z",
          "finished_at": "2026-09-13T12:00:00.000Z",
          "coverage": "partial",
          "coverage_reason": "row_limit",
          "provider_total_count": 1,
          "usage": {
            "unit": "discovery",
            "currency": "USD",
            "quote_id": "owned_example",
            "max_cost_microusd": 0,
            "reserved_cost_microusd": 0,
            "provider_reported_cost_microusd": 0,
            "request_count": 1,
            "returned_rows": 1,
            "accepted_candidates": 1,
            "rejected_rows": 0,
            "duplicate_rows": 0
          },
          "operation": "backlinks",
          "coverage_scope": "corpus_subset",
          "whole_web_coverage": false
        },
        "content_hash": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
        "absence_claim": "not_supported",
        "verification_view": "captured_at_snapshot"
      }
    ],
    "baseline_report_hash": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "preview_hash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "dry_run": true,
    "before_counts": {
      "groups": 1,
      "rows": 2,
      "observed_overlap_groups": 1,
      "dataset_gap_groups": null,
      "comparison_unknown_groups": 0,
      "excluded_groups": 0,
      "excluded_rows": 0
    },
    "after_counts": {
      "groups": 1,
      "rows": 2,
      "observed_overlap_groups": 1,
      "dataset_gap_groups": null,
      "comparison_unknown_groups": 0,
      "excluded_groups": 0,
      "excluded_rows": 0
    },
    "per_rule": [],
    "per_rule_counts_overlap": true,
    "examples": [],
    "examples_truncated": false,
    "example_limits": {
      "groups": 10,
      "matches_per_group": 3
    }
  }
  ```
</Accordion>

## Input fields

Omit optional fields when you do not want to supply them. Null is accepted only where listed. Unknown input properties are rejected.

| Field                   | Type    | Presence | Meaning and constraints                                                                                                           |
| ----------------------- | ------- | -------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `setId`                 | string  | Required | Identifier of the set returned by its create or list operation. minLength: 1; maxLength: 200                                      |
| `revision`              | integer | Required | Immutable set revision to read or compare. minimum: 1; maximum: 9007199254740990                                                  |
| `inventoryIds`          | array   | Required | Frozen inventory IDs to compare; records must belong to the approved set. minItems: 2; maxItems: 11                               |
| `grouping`              | string  | Required | Grouping dimension used to aggregate the selected inventories. values: "page", "source\_host"                                     |
| `exclusions`            | array   | Optional | Customer-approved exclusions to apply to this report. maxItems: 100; default: \[]                                                 |
| `exclusions[].grouping` | string  | Required | values: "page", "source\_host"                                                                                                    |
| `exclusions[].value`    | string  | Required | minLength: 1; maxLength: 4096                                                                                                     |
| `maxRetrievalSkewMs`    | integer | Optional | Maximum permitted difference between inventory retrieval times, in milliseconds. minimum: 0; maximum: 86400000; default: 86400000 |
| `exclusionRevision`     | integer | Optional | Saved exclusion revision to apply; historical revisions remain immutable. minimum: 1; maximum: 9007199254740990                   |

### Validation and omitted values

grouping is required: there is no implicit page/host grouping. Select exclusionRevision explicitly to apply saved rules; omitted exclusionRevision uses only request exclusions.

Selected inventories must be distinct, compatible with the approved revision and include the required customer inventory. Missing dataset edges cannot establish web-wide absence.

### Defaults when omitted

| Field                | Default    |
| -------------------- | ---------- |
| `exclusions`         | `[]`       |
| `maxRetrievalSkewMs` | `86400000` |

## Output fields

Fields inside optional or nullable parents apply only when that parent exists. [Common schema conventions](/reference/schemas) explain evidence states, empty lists and extensions.

* **`v`** (number, required).
* **`set_id`** (string, required): Identifier returned by the related operation.
* **`set_revision`** (number, required).
* **`grouping`** (string, required).
* **`comparison`** (object, required).
* **`absence_claim`** (string, required): not\_supported: missing dataset rows cannot prove link absence. must equal "not\_supported"
* **`whole_web_coverage`** (boolean, required): False: these results do not measure the whole web. must equal false
* **`coverage_scope`** (string, required).
* **`verification_view`** (string, required).
* **`max_retrieval_skew_ms`** (number, required).
* **`selected_inventory_ids`** (array, required).
* **`unselected_member_ids`** (array, required).
* **`exclusions`** (object, required).
* **`inventories`** (array, required).
* **`baseline_report_hash`** (string, required).
* **`preview_hash`** (string, required).
* **`dry_run`** (boolean, required): must equal true
* **`before_counts`** (object / null, required).
* **`after_counts`** (object / null, required).
* **`per_rule`** (array, required).
* **`per_rule_counts_overlap`** (boolean, required).
* **`examples`** (array, required).
* **`examples_truncated`** (boolean, required).
* **`example_limits`** (object, required).

<Accordion title="All fields and nested objects">
  | Field                                                     | Type           | Presence | Meaning and constraints                                                                                                                                                                                                                                                                                                                                                             |
  | --------------------------------------------------------- | -------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `v`                                                       | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `set_id`                                                  | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `set_revision`                                            | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `grouping`                                                | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `comparison`                                              | object         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `comparison.mode`                                         | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `comparison.reasons`                                      | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `comparison.absence_claim`                                | string         | Required | not\_supported: missing dataset rows cannot prove link absence. must equal "not\_supported"                                                                                                                                                                                                                                                                                         |
  | `absence_claim`                                           | string         | Required | not\_supported: missing dataset rows cannot prove link absence. must equal "not\_supported"                                                                                                                                                                                                                                                                                         |
  | `whole_web_coverage`                                      | boolean        | Required | False: these results do not measure the whole web. must equal false                                                                                                                                                                                                                                                                                                                 |
  | `coverage_scope`                                          | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `verification_view`                                       | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `max_retrieval_skew_ms`                                   | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `selected_inventory_ids`                                  | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `unselected_member_ids`                                   | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions`                                              | object         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.scope`                                        | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.policy`                                       | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.rules`                                        | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.rules[].grouping`                             | string         | Required | values: "page", "source\_host"                                                                                                                                                                                                                                                                                                                                                      |
  | `exclusions.rules[].value`                                | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.saved_revision`                               | number         | Optional |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `exclusions.set_revision_at_save`                         | number         | Optional |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories`                                             | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].v`                                         | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].id`                                        | string         | Required | Resource identifier returned by the operation.                                                                                                                                                                                                                                                                                                                                      |
  | `inventories[].workspace_id`                              | string         | Required | Workspace that owns this record.                                                                                                                                                                                                                                                                                                                                                    |
  | `inventories[].project_id`                                | string         | Required | Project that owns this record.                                                                                                                                                                                                                                                                                                                                                      |
  | `inventories[].set_id`                                    | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `inventories[].set_revision`                              | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].set_hash`                                  | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].member_id`                                 | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `inventories[].member_role`                               | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].target_scope_id`                           | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `inventories[].captured_at`                               | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].provider_retrieved_from`                   | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].provider_retrieved_to`                     | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run`                                       | object         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.v`                                     | number         | Required | must equal 1                                                                                                                                                                                                                                                                                                                                                                        |
  | `inventories[].run.id`                                    | string         | Required | Resource identifier returned by the operation. minLength: 1; maxLength: 128; pattern: "^\[a-zA-Z0-9\_-]+\$"                                                                                                                                                                                                                                                                         |
  | `inventories[].run.workspace_id`                          | string         | Required | Workspace that owns this record. minLength: 1; maxLength: 128; pattern: "^\[a-zA-Z0-9\_-]+\$"                                                                                                                                                                                                                                                                                       |
  | `inventories[].run.project_id`                            | string         | Required | Project that owns this record. minLength: 1; maxLength: 128; pattern: "^\[a-zA-Z0-9\_-]+\$"                                                                                                                                                                                                                                                                                         |
  | `inventories[].run.provider`                              | string         | Required | values: "linktrail\_corpus", "dataforseo", "imported"                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.data_mode`                             | string         | Required | values: "synthetic", "owned\_corpus", "provider\_index", "imported"                                                                                                                                                                                                                                                                                                                 |
  | `inventories[].run.query`                                 | object         | Required | additional fields rejected                                                                                                                                                                                                                                                                                                                                                          |
  | `inventories[].run.query.target_kind`                     | string         | Required | values: "domain", "exact\_url"                                                                                                                                                                                                                                                                                                                                                      |
  | `inventories[].run.query.target`                          | string         | Required | minLength: 1; maxLength: 4096                                                                                                                                                                                                                                                                                                                                                       |
  | `inventories[].run.query.include_subdomains`              | boolean        | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.query.backlinks_status_type`           | string         | Required | values: "live", "lost", "all"                                                                                                                                                                                                                                                                                                                                                       |
  | `inventories[].run.query.exclude_internal_backlinks`      | boolean        | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.query.mode`                            | string         | Required | must equal "as\_is"                                                                                                                                                                                                                                                                                                                                                                 |
  | `inventories[].run.query.filters`                         | null           | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.query.order_by`                        | array          | Required | minItems: 1; maxItems: 1                                                                                                                                                                                                                                                                                                                                                            |
  | `inventories[].run.query.rank_scale`                      | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.query.page_limit`                      | integer        | Required | minimum: 1; maximum: 1000                                                                                                                                                                                                                                                                                                                                                           |
  | `inventories[].run.query.row_limit`                       | integer        | Required | minimum: 1; maximum: 1000                                                                                                                                                                                                                                                                                                                                                           |
  | `inventories[].run.status`                                | string         | Required | Resource lifecycle status. values: "queued", "running", "succeeded", "partial", "failed", "reconciliation\_required"                                                                                                                                                                                                                                                                |
  | `inventories[].run.created_at`                            | string         | Required | UTC timestamp when the record was created. format: "date-time"; pattern: "^(?:(?:\d\d\[2468]\[048]\|\d\d\[13579]\[26]\|\d\d0\[48]\|\[02468]\[048]00\|\[13579]\[26]00)-02-29\|\d\{4}-(?:(?:0\[13578]\|1\[02])-(?:0\[1-9]\|\[12]\d\|3\[01])\|(?:0\[469]\|11)-(?:0\[1-9]\|\[12]\d\|30)\|(?:02)-(?:0\[1-9]\|1\d\|2\[0-8])))T(?:(?:\[01]\d\|2\[0-3]):\[0-5]\d:\[0-5]\d\\.\d\{3}(?:Z))\$" |
  | `inventories[].run.started_at`                            | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.finished_at`                           | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.coverage`                              | string         | Required | Dataset scope and completeness, including limits on what these results establish. values: "pending", "complete\_for\_query", "capped", "partial", "unknown"                                                                                                                                                                                                                         |
  | `inventories[].run.coverage_reason`                       | string / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.provider_total_count`                  | integer / null | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.usage`                                 | object         | Required | additional fields rejected                                                                                                                                                                                                                                                                                                                                                          |
  | `inventories[].run.usage.unit`                            | string         | Required | must equal "discovery"                                                                                                                                                                                                                                                                                                                                                              |
  | `inventories[].run.usage.currency`                        | string         | Required | must equal "USD"                                                                                                                                                                                                                                                                                                                                                                    |
  | `inventories[].run.usage.quote_id`                        | string         | Required | Identifier returned by the related operation. minLength: 1; maxLength: 128; pattern: "^\[a-zA-Z0-9\_-]+\$"                                                                                                                                                                                                                                                                          |
  | `inventories[].run.usage.max_cost_microusd`               | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.reserved_cost_microusd`          | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.provider_reported_cost_microusd` | integer / null | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.usage.request_count`                   | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.returned_rows`                   | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.accepted_candidates`             | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.rejected_rows`                   | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.usage.duplicate_rows`                  | integer        | Required | minimum: 0; maximum: 9007199254740991                                                                                                                                                                                                                                                                                                                                               |
  | `inventories[].run.operation`                             | string         | Required | must equal "backlinks"                                                                                                                                                                                                                                                                                                                                                              |
  | `inventories[].run.coverage_scope`                        | string         | Required | values: "customer\_import", "corpus\_subset", "provider\_query"                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].run.whole_web_coverage`                    | boolean        | Required | False: these results do not measure the whole web. must equal false                                                                                                                                                                                                                                                                                                                 |
  | `inventories[].run.replayed`                              | boolean        | Optional | True when the response reuses an earlier request with the same idempotency value.                                                                                                                                                                                                                                                                                                   |
  | `inventories[].content_hash`                              | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `inventories[].absence_claim`                             | string         | Required | not\_supported: missing dataset rows cannot prove link absence. must equal "not\_supported"                                                                                                                                                                                                                                                                                         |
  | `inventories[].verification_view`                         | string         | Required | must equal "captured\_at\_snapshot"                                                                                                                                                                                                                                                                                                                                                 |
  | `inventories[].replayed`                                  | boolean        | Optional | True when the response reuses an earlier request with the same idempotency value.                                                                                                                                                                                                                                                                                                   |
  | `baseline_report_hash`                                    | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `preview_hash`                                            | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `dry_run`                                                 | boolean        | Required | must equal true                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts`                                           | object / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.groups`                                    | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.rows`                                      | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.observed_overlap_groups`                   | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.dataset_gap_groups`                        | number / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.comparison_unknown_groups`                 | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.excluded_groups`                           | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `before_counts.excluded_rows`                             | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts`                                            | object / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.groups`                                     | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.rows`                                       | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.observed_overlap_groups`                    | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.dataset_gap_groups`                         | number / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.comparison_unknown_groups`                  | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.excluded_groups`                            | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `after_counts.excluded_rows`                              | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule`                                                | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule[].rule`                                         | object         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule[].rule.grouping`                                | string         | Required | values: "page", "source\_host"                                                                                                                                                                                                                                                                                                                                                      |
  | `per_rule[].rule.value`                                   | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule[].matched_rows`                                 | number / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule[].hidden_groups`                                | number / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule[].hidden_rows`                                  | number / null  | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `per_rule_counts_overlap`                                 | boolean        | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples`                                                | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].group_key`                                    | string         | Required | Exact group identifier used to retrieve contributor rows.                                                                                                                                                                                                                                                                                                                           |
  | `examples[].relation`                                     | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].hidden_rows`                                  | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].matched_rows`                                 | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].collateral_rows`                              | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].matches`                                      | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].matches[].candidate_id`                       | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `examples[].matches[].source_url`                         | string         | Required | Publisher page URL recorded in this evidence.                                                                                                                                                                                                                                                                                                                                       |
  | `examples[].matches[].target_url`                         | string         | Required | Destination URL recorded in this evidence.                                                                                                                                                                                                                                                                                                                                          |
  | `examples[].matches[].inventory_id`                       | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `examples[].matches[].member_id`                          | string         | Required | Identifier returned by the related operation.                                                                                                                                                                                                                                                                                                                                       |
  | `examples[].matches[].member_role`                        | string         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].matches[].rule_indexes`                       | array          | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples[].matches_truncated`                            | boolean        | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `examples_truncated`                                      | boolean        | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `example_limits`                                          | object         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `example_limits.groups`                                   | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
  | `example_limits.matches_per_group`                        | number         | Required |                                                                                                                                                                                                                                                                                                                                                                                     |
</Accordion>

[Download input schema](/schemas/preview_competitor_exclusions.input.json) · [Download output schema](/schemas/preview_competitor_exclusions.output.json)

## Errors and retries

The command is annotated idempotent. Reuse an accepted idempotency key when the input provides one; changing the payload under a reused key can conflict.

See [error recovery](/reference/errors) for status, scope, cooldown, cursor and retry handling. Unknown observations are result data and do not establish loss.

## HTTP resource routes

These existing resource routes share the operation’s domain behavior. Their parameter placement, status and response envelope can differ from generic invocation. See [HTTP route details](/reference/http/routes).

| Method and route                                      | Success | Details                                       |
| ----------------------------------------------------- | ------- | --------------------------------------------- |
| `POST /v1/competitor-sets/{setId}/exclusions/preview` | 200     | Remaining arguments go in a JSON object body. |

## Continue

[get\_competitor\_exclusions](/reference/commands/get_competitor_exclusions)

Follow the [related workflow](/guides/competitor-research), inspect [capability status](/capability-status), or return to the [command index](/reference/index).
