---
title: Outputs
url: https://docs.schemalabs.ai/outputs
description: The one response every pass returns: sector, column profile, cross-table map, imputation, predictions, and on endpoints the held-out block.
---

# Outputs

> The one response every pass returns: sector, column profile, cross-table map, imputation, predictions, and on endpoints the held-out block.

Every pass emits the full bundle: producing all outputs is one pass, so you always get all of them. A quick run returns the bundle for the tables you sent; an endpoint object carries the bundle computed over its pinned data; a serve returns it for the request data, scored by the endpoint; the held-out block is on the endpoint object. Field-by-field shapes are in the [API reference](https://docs.schemalabs.ai/api-reference/run).

> **Note: Atomic**
A pass either returns the full bundle or fails as `job_failed`. Slices scoped by contract (the cross-table map on one table, the prediction slice under `target.mode: "none"`) are documented `null`, never absent by failure. Failed jobs bill nothing.

## Sector

Vertical-agnostic sector identification: the industry sector of each table, from cell values alone, any domain, no metadata required. `top1 { name, confidence }` and `top5[]`, each entry with its own confidence. Blind to column names: it holds with headers stripped or coded. Per-model results on blind sector identification are in the [model registry](https://www.schemalabs.ai/model-card). Use it to catalog a data lake, route incoming files, or triage a dataset before anyone opens it.

## Column profile

Per column: `name`, `role`, `role_confidence`, `type`, `missing_pct`, `pii`.

| Field | Values |
|---|---|
| `role` | `email`, `phone`, `name`, `date`, `address`, `code`, `identifier`, `measure`, `category`, `text`, `boolean`, `currency`, `url`, `geo` |
| `type` | `categorical`, `numeric`, `datetime`, `text`, `boolean` |
| `missing_pct` | Fraction of missing cells, 0 to 1 |
| `pii` | `true` when the role is personally identifying (name, email, phone, address, national id, ...) |

Use `role` and `pii` to route, mask, or gate columns in your own systems.

## Cross-table map

Across any number of tables from any number of sources (two or more), the bundle relates the sources with no shared key, no lookup table, and no name matching:

- `column_alignment[]`: column pairs that carry the same attribute, each with `attribute`, `confidence`, and a verbatim `example` from the cells (`555-0142` and `+1 555 0142` under one `phone`).
- `entity_matches[]`: row pairs that are the same record (surfaced as **entity matches**), with `confidence` and `matched_on`, the aligned attributes that agreed for that pair.
- `unified_schema { shared, a_only, b_only }`: the proposed fold.
- `unified_rows`: the map materialized into joined records from the original cell values, one per matched entity, with `provenance` per column and `shared_variants` showing each source's raw value. When shared variants disagree beyond formatting, that flags a possible mis-alignment rather than silently picking one side. `total` is the full count; `rows` is a sample, paginated by cursor.

Alignments and matches are reported above your `options.confidence_threshold`. Every alignment and every match ships its confidence and its evidence (`example`, `matched_on`); the map is a proposal for your review, never auto-applied: act on high-confidence matches automatically and queue the rest at thresholds you choose.

On an endpoint, pin two or more datasets and the endpoint's bundle carries the map over the pinned data; a serve scores the request tables against the pinned context, and the held-out split is by matched entity. Per-model results for keyless entity matching and name-blind schema matching are in the [model registry](https://www.schemalabs.ai/model-card).

## Missing-value imputation

`filled[]` lists each reconstructed cell (`table`, `row`, `column`, `value`, `method`); confidence is **row-level, not per cell**, in `row_confidence[]` (`table`, `row`, `confidence`). Numeric and categorical gaps are both filled; a categorical fill is a class label, not the most common value. Identifying columns (`pii: true`) are never filled. Missing cells are metered like any other cell.

## Predictions

Three task types, all on the current base, all in-context: predictions use the labeled rows present (the request's, or the endpoint's pinned data). Nothing trains.

| Task | Per row |
|---|---|
| Classification | `label`, `confidence` (max class probability), full `probabilities` vector |
| Regression | `value`, `median`, `std`, `quantiles` |
| Anomaly | `anomaly_score`, `is_anomaly`, and the `threshold` used |

```json
{
"prediction": {
  "target": "cards_db.card_brand", "task_type": "classification", "tier": "in_context",
  "classes": ["Amex", "Mastercard", "Visa"],
  "dropped_rows": { "missing_target": 0 },
  "results": [ { "row": 0, "label": "Visa", "confidence": 0.94,
                 "probabilities": { "Amex": 0.01, "Mastercard": 0.05,
                                    "Visa": 0.94 } } ]
}
}
```

```json
{
"prediction": {
  "target": "credit_limit", "task_type": "regression", "tier": "in_context",
  "results": [ { "row": 0, "value": 12480.0, "median": 12010.0, "std": 3120.0,
                 "quantiles": { "0.1": 8400.0, "0.5": 12010.0, "0.9": 17900.0 } } ]
}
}
```

```json
{
"prediction": {
  "task_type": "anomaly", "threshold": 0.90,
  "results": [ { "row": 0, "anomaly_score": 0.97, "is_anomaly": true },
               { "row": 1, "anomaly_score": 0.12, "is_anomaly": false } ]
}
}
```

Use regression quantiles where you need the range and not a single number (pricing, claim severity, reserve setting). Anomaly runs unsupervised with no target, on explicit request only: fraud screening, equipment monitoring, data-quality checks with no labeled history.

**Missing targets.** Rows whose target is missing are counted in `dropped_rows.missing_target`; a missing value never enters `classes` and is never a predictable label.

**Two tiers.** A quick run prediction carries `held_out: null`; an endpoint's current held-out score is on the endpoint object and in the report.

## Target and task selection

Both are first-class on quick runs and on endpoint creation, with the same shapes; both default to `auto` and both explain themselves in the response.

```jsonc
"target": { "mode": "auto" }     // smart-target: Schema picks and explains
"target": { "column": "churn" }  // you pick; "table.column" on multi-table input
"target": { "mode": "none" }     // understanding-only: no prediction slice

"task": { "mode": "auto" }       // categorical -> classification, numeric -> regression
"task": { "type": "anomaly" }    // explicit only; needs no target
```

The response carries `target_selection { mode, column, reason, overridable, candidates[] }`, where `candidates` lists every column with whether it was selected or ruled out and a plain-language reason, and `task_selection { mode, type, reason, overridable }`. You see the decision and the rationale. On an endpoint you can override the target afterwards from the endpoint page in the platform; a target change is a configuration revision and triggers a re-score. Smart-target picks categorical targets; to predict a numeric column, name it in `target.column` and set `task.type` to `regression`. On a text-only table, name the target in `target.column`; the platform prompts for it.

`target.mode: "none"` is the understanding-only configuration: the bundle ships sector, column profile, cross-table map, and imputation, and `prediction` is `null`.

## Held-out (endpoints only)

```json
{
"held_out": {
  "score": 0.961, "auc": 0.974, "baseline_majority": 0.710,
  "split": { "method": "in_context_holdout", "train_rows": 17920,
             "test_rows": 4480, "seed": 7 },
  "data_version": "2026-08-12 09:31", "data_snapshot": "dsv_91f2",
  "weakest_slice": "tenure<3mo: 0.84", "report_url": "/v2/reports/r_a7d0"
}
}
```

Present on the endpoint object. See [Held-out reports](https://docs.schemalabs.ai/held-out).

## Confidence, everywhere

| Output | Confidence is |
|---|---|
| Sector | Per top-5 entry |
| Column profile | Per column, on the role |
| Cross-table map | Per column alignment and per entity match, above `confidence_threshold` |
| Imputation | Per row (not per cell) |
| Predictions | Per row (`confidence` for classification, distribution for regression, `anomaly_score` for anomaly) |

Confidences are probabilities; calibration results per model are in the [model card](https://www.schemalabs.ai/model-card/schema-2).

## Large outputs and evolution

`unified_rows.rows`, `prediction.results`, and `imputation.filled` return a first page inline (`sample_shown`) plus a cursor; `total` is always the full count. Retrieve the rest with cursor pagination on the endpoint or report resource, or direct a large run's bundle to a file or warehouse table with `options.out`. Adding fields to the bundle is non-breaking and announced; renaming or removing fields happens only at a new API version. Tolerate unknown fields. See [Pagination](https://docs.schemalabs.ai/api-reference#pagination).