# Export Manifest Check (`hayoso/export-manifest-check`) Actor

Find missing, duplicate and unexpected IDs in JSON exports against your supplied expected-ID list. $0.05 per completed report, not per row.

- **URL**: https://apify.com/hayoso/export-manifest-check.md
- **Developed by:** [Hayoso](https://apify.com/hayoso) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 completed reports

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

## Export Manifest Check

Short introductions: [Español](#es--español) · [Português brasileiro](#pt-br--português-brasileiro) · [Français](#fr--français) · [Deutsch](#de--deutsch) · [Norsk bokmål](#nb--norsk-bokmål) · [日本語](#ja--日本語) · [简体中文](#zh-hans--简体中文) · [हिन्दी](#hi--हिन्दी) · [العربية](#ar--العربية). The English specification below and active pricing panel remain the reference.

Check whether a JSON export contains every expected identifier exactly once. Find missing, duplicate and unexpected identifiers even when the total row count looks right.

This is a deterministic data check. It does not use an LLM, fetch websites, guess missing values or change your source data.

### Pricing

The launch price is **$0.05 per completed report** ($50 per 1,000 reports), not per record. The active Apify pricing panel is authoritative. A completed PASS, FAIL or UNKNOWN report is one result. Invalid input rejected before a report is saved produces no report event. There is no separate start event or platform-usage charge in this pricing configuration.

### Example

```json
{
  "recordsJson": "[{\"id\":\"A\"},{\"id\":\"A\"}]",
  "expectedIdsJson": "[\"A\",\"B\"]",
  "idField": "id",
  "exampleLimit": 10
}
```

Both arrays contain two entries, but the report is `FAIL`: A is duplicated and B is missing.

### What you receive

One JSON report with counts and bounded examples of missing, unexpected and duplicate identifiers, plus rows with missing or invalid IDs. The result is one of:

- `PASS_RELATIVE_TO_MANIFEST`: every supplied expected ID is present exactly once, with no unexpected or invalid IDs.
- `FAIL`: a discrepancy was found. A valid negative report is a successfully completed check, not a crashed run.
- `UNKNOWN`: no expected-ID manifest was supplied and no structural discrepancy was found. Completeness has not been established.

Malformed input or an invalid expected-ID manifest is rejected rather than silently repaired.

### Input and comparison rules

Supply the records and expected IDs as JSON **strings**, as shown above. This preserves numeric precision before comparison. `idField` selects one top-level field; compound keys are not supported.

String IDs and numeric IDs remain distinct. Numeric equality is exact decimal equality: `1` equals `1.00`, while `0.100000000000000005` does not equal `0.1`. Strings are not trimmed or case-folded. Null, boolean, empty and composite identifiers are unsupported.

The expected-ID list must contain unique, valid IDs. It is supplied by you; the tool cannot verify that it completely represents the source system.

### Limits

Up to 50,000 records and 50,000 expected IDs, subject to a 2,000,000-byte UTF-8 limit for each JSON string. Identifier strings are limited to 1,024 characters, numeric tokens to 256 characters, and nesting to 64 levels. Returned examples are capped by `exampleLimit` (0–100); discrepancy counts cover the full accepted input.

This checks identifier coverage and uniqueness only. It does not compare other fields, verify source freshness or real-world correctness, or prove the manifest is complete. CSV, spreadsheets, URLs and fuzzy matching are outside this version's input format.

### Data and support

Inputs and reports use the run's Apify storage and remain subject to its sharing and retention settings. The checker does not send them to external model or analytics providers. Use synthetic or non-sensitive data for initial evaluation and keep confidential runs private.

For a failed run, retain the run ID and error message. Share only a small synthetic example in public support discussions. Restarting the same run with retained storage reuses an existing matching report; a conflicting saved report is rejected rather than appended. This is not a guarantee about every interrupted network operation. Starting a new run is a new request, even with identical input. Retrieve an existing output before deciding to start again.

This version uses only its own run input and default dataset. It requests no access to unrelated Actors, stores, external accounts, or credentials. An API caller can provide the same JSON input and retrieve the report from the run dataset; use the API tab for Apify-generated invocation examples.

Developed with substantial AI assistance. Functionality and limitations are described above; no independent certification is claimed.

### Abbreviated introductions in other languages

These nine introductions are AI-assisted and have not received independent language review. They are abbreviated introductions, not full specification translations or claims that the UI or output is localized. The English specification above and active pricing panel remain the reference.

### ES — Español

**El número de filas puede coincidir aunque falten registros.** Si esperas A y B, pero recibes A y A, falta B y A está duplicado. Export Manifest Check compara tus registros JSON con una lista de identificadores esperados que tú proporcionas. Informa de identificadores ausentes, duplicados e inesperados; no comprueba otros campos ni la exactitud de la lista de referencia. Sin esa lista, no puede confirmar que la exportación esté completa. Usa `recordsJson`, `expectedIdsJson` e `idField` como en el ejemplo. Precio: **0,05 USD por informe completado**, no por fila; un informe `FAIL` o `UNKNOWN` también se cobra. No usa un modelo de lenguaje durante la ejecución. Empieza con datos ficticios.

[Ver herramienta, límites y precio vigente](https://apify.com/hayoso/export-manifest-check). Herramienta propia de pago; texto y traducción asistidos por IA, sin revisión lingüística independiente. La especificación en inglés es la referencia.

### PT-BR — Português brasileiro

**A quantidade de linhas pode estar certa mesmo com registros faltando.** Você espera A e B, mas recebe A e A: falta B e A está duplicado. O Export Manifest Check compara seus registros JSON com uma lista de identificadores esperados fornecida por você. O relatório aponta identificadores ausentes, duplicados e inesperados; não verifica outros campos nem a exatidão da lista de referência. Sem essa lista, não é possível confirmar que a exportação está completa. Use `recordsJson`, `expectedIdsJson` e `idField` como no exemplo. Preço: **US$ 0,05 por relatório concluído**, não por linha; relatórios `FAIL` e `UNKNOWN` também são cobrados. Nenhum modelo de linguagem é usado durante a execução. Comece com dados fictícios.

[Ver ferramenta, limites e preço atual](https://apify.com/hayoso/export-manifest-check). Ferramenta própria paga; texto e tradução com auxílio de IA, sem revisão linguística independente. A especificação em inglês é a referência.

### FR — Français

**Un nombre de lignes correct ne garantit pas que tous les enregistrements sont présents.** Vous attendez A et B, mais recevez A et A : B manque et A apparaît deux fois. Export Manifest Check compare vos enregistrements JSON à une liste d’identifiants attendus que vous fournissez. Le rapport signale les identifiants manquants, en double ou inattendus ; il ne vérifie ni les autres champs ni l’exactitude de votre liste de référence. Sans cette liste, il ne peut pas établir que l’export est complet. Utilisez `recordsJson`, `expectedIdsJson` et `idField` comme dans l’exemple. Prix : **0,05 USD par rapport terminé**, pas par ligne ; les rapports `FAIL` et `UNKNOWN` sont également facturés. Aucun modèle de langage n’est utilisé à l’exécution. Commencez avec des données fictives.

[Outil, limites et tarif en vigueur](https://apify.com/hayoso/export-manifest-check). Notre propre outil payant ; texte et traduction assistés par IA, sans révision linguistique indépendante. La spécification anglaise fait référence.

### DE — Deutsch

**Die Zeilenzahl kann stimmen, obwohl Datensätze fehlen.** Erwartet werden A und B, geliefert werden A und A: B fehlt, A ist doppelt. Export Manifest Check vergleicht Ihre JSON-Datensätze mit einer von Ihnen bereitgestellten Liste erwarteter IDs. Der Bericht zeigt fehlende, doppelte und unerwartete IDs; andere Felder und die Richtigkeit der Referenzliste werden nicht geprüft. Ohne diese Liste lässt sich die Vollständigkeit nicht feststellen. Verwenden Sie `recordsJson`, `expectedIdsJson` und `idField` wie im Beispiel. Preis: **0,05 USD pro abgeschlossenem Bericht**, nicht pro Zeile; auch `FAIL`- und `UNKNOWN`-Berichte werden berechnet. Zur Laufzeit wird kein Sprachmodell verwendet. Beginnen Sie mit erfundenen Beispieldaten.

[Tool, Grenzen und aktuellen Preis ansehen](https://apify.com/hayoso/export-manifest-check). Unser eigenes kostenpflichtiges Tool; Text und Übersetzung sind KI-unterstützt und wurden nicht unabhängig sprachlich geprüft. Maßgeblich ist die englische Spezifikation.

### NB — Norsk bokmål

**Riktig antall rader betyr ikke at alle postene er med.** Du forventer A og B, men får A og A: B mangler, og A forekommer to ganger. Export Manifest Check sammenligner JSON-postene dine med en liste over forventede ID-er som du selv oppgir. Rapporten viser manglende, dupliserte og uventede ID-er; den kontrollerer ikke andre felt eller om referanselisten er riktig. Uten listen kan den ikke fastslå at eksporten er komplett. Bruk `recordsJson`, `expectedIdsJson` og `idField` som i eksemplet. Pris: **0,05 USD per ferdig rapport**, ikke per rad; også `FAIL`- og `UNKNOWN`-rapporter koster penger. Ingen språkmodell brukes under kjøring. Start med fiktive data.

[Se verktøyet, begrensningene og gjeldende pris](https://apify.com/hayoso/export-manifest-check). Vårt eget betalingsverktøy; teksten og oversettelsen er laget med KI-hjelp og har ikke fått uavhengig språkvask. Den engelske spesifikasjonen er referansen.

### JA — 日本語

**行数が一致しても、必要なレコードが揃っているとは限りません。** 期待するIDがAとBなのに、出力がAとAなら、Bが欠け、Aが重複しています。Export Manifest Checkは、JSONレコードを、利用者が用意した期待IDの一覧と比較し、欠落・重複・想定外のIDを報告します。他のフィールドや、参照一覧そのものの正確性は検証しません。一覧を指定しなければ、完全性は確認できません。入力は例の `recordsJson`、`expectedIdsJson`、`idField` を使います。料金は行ごとではなく、**完了したレポート1件につき0.05米ドル**です。`FAIL` や `UNKNOWN` のレポートも課金対象です。実行時に言語モデルは使いません。最初は架空のデータで試してください。

[ツール・制限・現在の料金](https://apify.com/hayoso/export-manifest-check)。自作の有料ツールの紹介です。文章と翻訳にはAIを使用しており、独立した言語レビューは受けていません。英語の仕様を参照してください。

### ZH-HANS — 简体中文

**行数相同，不代表记录齐全。** 预期ID是A和B，实际导出却是A和A：B缺失，A重复。Export Manifest Check将JSON记录与你提供的预期ID清单进行比较，报告缺失、重复和清单之外的ID。它不检查其他字段，也不验证参考清单本身是否准确。没有这份清单，就无法确认导出是否完整。请按示例使用 `recordsJson`、`expectedIdsJson` 和 `idField`。价格为**每份已完成的报告0.05美元**，不是按行收费；`FAIL` 和 `UNKNOWN` 报告也会收费。运行时不使用语言模型。首次测试请使用虚构数据。

[查看工具、限制和当前价格](https://apify.com/hayoso/export-manifest-check)。这是我们自己的付费工具。文字和翻译使用了AI辅助，未经独立语言审核。请以英文规格说明为参考。

### HI — हिन्दी

**पंक्तियों की संख्या सही होने पर भी रिकॉर्ड गायब हो सकते हैं।** अपेक्षित ID हैं A और B, लेकिन निर्यात में A और A हैं: B गायब है और A दो बार आया है। Export Manifest Check आपके JSON रिकॉर्ड की तुलना आपके द्वारा दी गई अपेक्षित ID की सूची से करता है। रिपोर्ट गायब, दोहराई गई और सूची से बाहर की ID दिखाती है; यह दूसरे फ़ील्ड या संदर्भ सूची की सटीकता नहीं जाँचता। उस सूची के बिना निर्यात के पूरा होने की पुष्टि नहीं की जा सकती। उदाहरण की तरह `recordsJson`, `expectedIdsJson` और `idField` इस्तेमाल करें। कीमत **प्रति पूरी हुई रिपोर्ट 0.05 अमेरिकी डॉलर** है, प्रति पंक्ति नहीं; `FAIL` और `UNKNOWN` रिपोर्ट के लिए भी शुल्क लगता है। चलने के दौरान कोई भाषा मॉडल इस्तेमाल नहीं होता। शुरुआत काल्पनिक डेटा से करें।

[टूल, सीमाएँ और मौजूदा कीमत देखें](https://apify.com/hayoso/export-manifest-check)। यह हमारा अपना सशुल्क टूल है। लेखन और अनुवाद में AI की मदद ली गई है; स्वतंत्र भाषा समीक्षा नहीं हुई है। अंग्रेज़ी विनिर्देश को संदर्भ मानें।

### AR — العربية

**تساوي عدد الصفوف لا يعني أن جميع السجلات موجودة.** إذا كانت المعرّفات المتوقعة A وB، لكن التصدير يحتوي على A وA، فإن B مفقود وA مكرر. يقارن Export Manifest Check سجلات JSON بقائمة المعرّفات المتوقعة التي تقدمها أنت، ويعرض المعرّفات المفقودة والمكررة وغير الموجودة في القائمة. لا يفحص الحقول الأخرى ولا يتحقق من دقة القائمة المرجعية نفسها. من دون هذه القائمة، لا يمكنه إثبات اكتمال التصدير. استخدم `recordsJson` و`expectedIdsJson` و`idField` كما في المثال. السعر **0.05 دولار أمريكي لكل تقرير مكتمل**، وليس لكل صف؛ وتُحتسب الرسوم أيضًا على تقارير `FAIL` و`UNKNOWN`. لا يستخدم نموذجًا لغويًا أثناء التشغيل. ابدأ ببيانات وهمية.

[عرض الأداة والحدود والسعر الحالي](https://apify.com/hayoso/export-manifest-check). هذه أداتنا المدفوعة. أُعد النص والترجمة بمساعدة الذكاء الاصطناعي، ولم يخضعا لمراجعة لغوية مستقلة. المواصفات الإنجليزية هي المرجع.

# Actor input Schema

## `recordsJson` (type: `string`):

A JSON array of records. JSON text preserves number precision. Max 2,000,000 UTF-8 bytes and 50,000 records.

## `expectedIdsJson` (type: `string`):

An authoritative JSON array of unique expected IDs. Omit for structural checks only; absence cannot establish completeness.

## `idField` (type: `string`):

Top-level field containing the record identifier.

## `exampleLimit` (type: `integer`):

Maximum examples retained for each finding type.

## Actor input object example

```json
{
  "recordsJson": "[{\"id\":\"A\"},{\"id\":\"A\"}]",
  "expectedIdsJson": "[\"A\",\"B\"]",
  "idField": "id",
  "exampleLimit": 10
}
```

# Actor output Schema

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

Link to the full default-dataset JSON array: status, counts, bounded discrepancy examples, equality rules and limits. This link does not grant permission to access private run data.

# 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 = {
    "recordsJson": "[{\"id\":\"A\"},{\"id\":\"A\"}]",
    "expectedIdsJson": "[\"A\",\"B\"]"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hayoso/export-manifest-check").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 = {
    "recordsJson": "[{\"id\":\"A\"},{\"id\":\"A\"}]",
    "expectedIdsJson": "[\"A\",\"B\"]",
}

# Run the Actor and wait for it to finish
run = client.actor("hayoso/export-manifest-check").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 '{
  "recordsJson": "[{\\"id\\":\\"A\\"},{\\"id\\":\\"A\\"}]",
  "expectedIdsJson": "[\\"A\\",\\"B\\"]"
}' |
apify call hayoso/export-manifest-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hayoso/export-manifest-check"
        }
    }
}
```

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/y1cRLFMvO9bjMP23l/builds/IdfZPzztgc4SgTTv1/openapi.json