# NEXUS – AI Extracted Claim & Quote Checker (`vad_tot_i86/nexus-v06-private-cloud-test`) Actor

Check AI-extracted claims and values against exact quotes and field labels in supplied English source text. Returns structured supported, review or rejected results for AI agent workflows. Does not independently verify factual truth or document authenticity.

- **URL**: https://apify.com/vad_tot_i86/nexus-v06-private-cloud-test.md
- **Developed by:** [Donca Sergiu](https://apify.com/vad_tot_i86) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NEXUS Evidence Preflight

### AI-extracted claim and source quote verification

NEXUS is a deterministic lexical preflight for AI-extracted claims. It compares caller-supplied, pre-extracted English text with quoted passages, page anchors, claimed values, and controlled-field labels, then returns structured results for human review. It does not establish factual truth, document authenticity, source provenance, or general semantic entailment.

Use NEXUS when an AI agent needs to:

- Check whether an extracted price appears in its cited source text.
- Compare extracted values with supporting source quotes.
- Detect unsupported values before taking automated actions.
- Route uncertain or conflicting extracted claims for human review.

The Actor returns structured supported, rejected, or review results. Use them to flag items for a human reviewer before a downstream workflow proceeds—not to make the decision for that reviewer.

### Suitable uses

- Check page, quote, value, and controlled-field consistency in already extracted public text.
- Produce structured claim-level flags for a human review queue.
- Add a deterministic, limited preflight step before an agent proposes a consequential action.

### Do not use it for

- Establishing factual truth, general semantic entailment, legal validity, financial accuracy, or compliance.
- Verifying document authenticity, source identity, provenance, signatures, or whether a source is authoritative.
- OCR, PDF parsing, layout/table interpretation, document fetching, or extracting claims from documents.
- Private/confidential documents, personal data, credentials, secrets, or any content you are not authorized to process.
- Replacing professional judgment or human review in legal, financial, safety, identity, fraud, or other consequential decisions.

### Input

Submit JSON matching the Actor's Input schema. Required fields are `request_id` (canonical UUID), `public_non_sensitive_confirmed` (`true` is a caller declaration, not a privacy scanner), `source` (`document_id` and caller-declared `provenance`), `pages` (1–25 page objects with pre-extracted English `text`, 1–40,000 characters each), and `claims` (1–100 structured claims). Each claim contains `claim_id`, `field`, `semantic_field`, `page`, a short exact `evidence` quote (1–220 characters), and `value`. Extra properties are rejected. The complete constraints and controlled field requirements are in the Input schema.

The Actor does not fetch the document or verify the caller's source declaration. Keep submitted material public, non-sensitive, and authorized for processing. Runs execute on Apify infrastructure and are billed under the native PPE events described below. The current Store listing shows no separate platform-usage fee for this Actor; post-run dataset operations may still incur standard platform storage charges.

### Output and statuses

Successful reports are items in the default dataset (`reports`). A failed request writes a sanitized structured error to the default key-value store record `OUTPUT`; failed requests are not dataset report items. Inspect the Output and Dataset schemas for the exact machine-readable fields.

- `supported_by_schema_anchored_text`: a narrow quote/page/value and controlled-field match against supplied text only. **It does not mean the claim is true.**
- `review`: NEXUS abstained or detected uncertainty/contradiction, an unsupported field/anchor, incompatible units, ambiguous candidates, or unknown provenance. A human must review it.
- `rejected`: the supplied quote/page/value consistency check failed. This does not prove the underlying real-world claim is false.

Every successful result has `truth_verified: false`, `document_authenticity_verified: false`, `source_provenance_verified: false`, and `requires_human_review: true`. Output may include the caller's claim values and document identifier, but not the full supplied page text or evidence quote. A text hash is not an authenticity check.

### Synthetic example

For the synthetic input with page text `Unit price: $100. Total price: $500.`, a claim quoting `Unit price: $100` for controlled field `unit_price` and value `$100` can receive `supported_by_schema_anchored_text`. A claim associating the same quote with `total_price` should not be treated as supported. These are text-consistency examples only; neither result validates a real document or fact.

### Calling the Actor

The published Actor can be called by an authenticated Apify API client using its Store ID, then the run's default dataset can be read. This example loads the included synthetic sample input:

```python
import json

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
with open("examples/sample_input.json", encoding="utf-8") as f:
    run_input = json.load(f)
run = client.actor("vad_tot_i86/nexus-v06-private-cloud-test").call(
    run_input=run_input,
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

Never put an API token in this README, input, source text, or a public repository. To let an MCP client discover Store Actors without granting run access, configure the official Apify MCP discovery tools:

```json
{
  "mcpServers": {
    "apify-discovery": {
      "url": "https://mcp.apify.com?tools=search-actors,fetch-actor-details"
    }
  }
}
```

An authenticated Apify MCP client can additionally use `call-actor`; read-only discovery uses `search-actors` and `fetch-actor-details`. Discovery does not imply autonomous-payment eligibility.

### Pricing and support

The public Store listing currently uses native Apify **Pay Per Event (PPE)** billing:

- **Result:** `$0.002` for each item saved to the default dataset (`apify-default-dataset-item`).
- **Actor Start:** `$0.00005` per event (`apify-actor-start`). The number of start events depends on allocated memory: one event per GB, with a minimum of one. At the current default of 1 GB, one start event is charged.

At the current default memory, a run that writes one report incurs `$0.00205` in listed PPE event charges. These are the rates returned for the FREE user tier on 2026-09-29; check the live Store price before quoting them because pricing may change.

The current public listing shows no separate platform-usage fee for this Actor; its run infrastructure is represented by the listed PPE pricing. Standard post-run dataset operations may still incur platform storage charges. The custom `context-check-report` charging path in this codebase is limited to Apify's local billing simulation and fails closed in hosted runs; it is not used for the public Actor's native PPE events.

For questions about this community-maintained Actor, contact **nexus.preflight@gmail.com**. NEXUS is an independent project and is not an Apify-maintained Actor or an endorsement by Apify.

# Actor input Schema

## `request_id` (type: `string`):

A new canonical UUID for this logical request; reuse only for a technical retry.

## `public_non_sensitive_confirmed` (type: `boolean`):

Required. Do not submit personal data, credentials, private contracts, or confidential documents.

## `source` (type: `object`):

Caller-supplied identifier and provenance declaration; NEXUS does not verify either.

## `pages` (type: `array`):

1-25 page objects; each text is 1-40000 characters. No PDF and no OCR.

## `claims` (type: `array`):

1-100 strictly structured claims.

## Actor input object example

```json
{
  "request_id": "123e4567-e89b-42d3-a456-426614174000",
  "public_non_sensitive_confirmed": true,
  "source": {
    "document_id": "public-demo-document-1",
    "provenance": "public_source"
  },
  "pages": [
    {
      "page": 1,
      "text": "Unit price: $100. Total price: $500. Quantity 5. Phase 1 Total Project Amount: $6,113,575."
    }
  ],
  "claims": [
    {
      "claim_id": "c1",
      "field": "unit_price_right",
      "semantic_field": "unit_price",
      "page": 1,
      "evidence": "Unit price: $100",
      "value": "$100"
    },
    {
      "claim_id": "c2",
      "field": "total_price_right",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Total price: $500",
      "value": "$500"
    },
    {
      "claim_id": "c3",
      "field": "false_field_association",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Unit price: $100",
      "value": "$100"
    },
    {
      "claim_id": "c4",
      "field": "fake_numeric_value",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Total price: $500",
      "value": "$900"
    },
    {
      "claim_id": "c5",
      "field": "phase_number_as_money",
      "semantic_field": "phase_total",
      "page": 1,
      "evidence": "Phase 1 Total Project Amount: $6,113,575",
      "value": "1"
    }
  ]
}
```

# Actor output Schema

## `reports` (type: `string`):

Default dataset items. Each item is one successful NEXUS 0.6 report with claim-level results; see the Dataset schema for exact fields and status meanings.

## `error` (type: `string`):

Present on failed requests only. Structured error JSON (code, sanitized message, retryable, request_id); never contains supplied page text or evidence.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "request_id": "123e4567-e89b-42d3-a456-426614174000",
    "public_non_sensitive_confirmed": true,
    "source": {
        "document_id": "public-demo-document-1",
        "provenance": "public_source"
    },
    "pages": [
        {
            "page": 1,
            "text": "Unit price: $100. Total price: $500. Quantity 5. Phase 1 Total Project Amount: $6,113,575."
        }
    ],
    "claims": [
        {
            "claim_id": "c1",
            "field": "unit_price_right",
            "semantic_field": "unit_price",
            "page": 1,
            "evidence": "Unit price: $100",
            "value": "$100"
        },
        {
            "claim_id": "c2",
            "field": "total_price_right",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Total price: $500",
            "value": "$500"
        },
        {
            "claim_id": "c3",
            "field": "false_field_association",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Unit price: $100",
            "value": "$100"
        },
        {
            "claim_id": "c4",
            "field": "fake_numeric_value",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Total price: $500",
            "value": "$900"
        },
        {
            "claim_id": "c5",
            "field": "phase_number_as_money",
            "semantic_field": "phase_total",
            "page": 1,
            "evidence": "Phase 1 Total Project Amount: $6,113,575",
            "value": "1"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vad_tot_i86/nexus-v06-private-cloud-test").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "request_id": "123e4567-e89b-42d3-a456-426614174000",
    "public_non_sensitive_confirmed": True,
    "source": {
        "document_id": "public-demo-document-1",
        "provenance": "public_source",
    },
    "pages": [{
            "page": 1,
            "text": "Unit price: $100. Total price: $500. Quantity 5. Phase 1 Total Project Amount: $6,113,575.",
        }],
    "claims": [
        {
            "claim_id": "c1",
            "field": "unit_price_right",
            "semantic_field": "unit_price",
            "page": 1,
            "evidence": "Unit price: $100",
            "value": "$100",
        },
        {
            "claim_id": "c2",
            "field": "total_price_right",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Total price: $500",
            "value": "$500",
        },
        {
            "claim_id": "c3",
            "field": "false_field_association",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Unit price: $100",
            "value": "$100",
        },
        {
            "claim_id": "c4",
            "field": "fake_numeric_value",
            "semantic_field": "total_price",
            "page": 1,
            "evidence": "Total price: $500",
            "value": "$900",
        },
        {
            "claim_id": "c5",
            "field": "phase_number_as_money",
            "semantic_field": "phase_total",
            "page": 1,
            "evidence": "Phase 1 Total Project Amount: $6,113,575",
            "value": "1",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("vad_tot_i86/nexus-v06-private-cloud-test").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "request_id": "123e4567-e89b-42d3-a456-426614174000",
  "public_non_sensitive_confirmed": true,
  "source": {
    "document_id": "public-demo-document-1",
    "provenance": "public_source"
  },
  "pages": [
    {
      "page": 1,
      "text": "Unit price: $100. Total price: $500. Quantity 5. Phase 1 Total Project Amount: $6,113,575."
    }
  ],
  "claims": [
    {
      "claim_id": "c1",
      "field": "unit_price_right",
      "semantic_field": "unit_price",
      "page": 1,
      "evidence": "Unit price: $100",
      "value": "$100"
    },
    {
      "claim_id": "c2",
      "field": "total_price_right",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Total price: $500",
      "value": "$500"
    },
    {
      "claim_id": "c3",
      "field": "false_field_association",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Unit price: $100",
      "value": "$100"
    },
    {
      "claim_id": "c4",
      "field": "fake_numeric_value",
      "semantic_field": "total_price",
      "page": 1,
      "evidence": "Total price: $500",
      "value": "$900"
    },
    {
      "claim_id": "c5",
      "field": "phase_number_as_money",
      "semantic_field": "phase_total",
      "page": 1,
      "evidence": "Phase 1 Total Project Amount: $6,113,575",
      "value": "1"
    }
  ]
}' |
apify call vad_tot_i86/nexus-v06-private-cloud-test --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vad_tot_i86/nexus-v06-private-cloud-test"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/y8Ca9fCObq92TKZuz/builds/e9YzsCaFUDykKOY3g/openapi.json