# ARD Catalog Validator (`vincesoft/ard-catalog-validator`) Actor

Validate an inline or public HTTPS ARD catalog and return stable repair-grade JSON diagnostics for coding agents.

- **URL**: https://apify.com/vincesoft/ard-catalog-validator.md
- **Developed by:** [VinceSoft](https://apify.com/vincesoft) (community)
- **Categories:** Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / catalog validation

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does ARD Catalog Validator do?

**ARD Catalog Validator determines whether an Agentic Resource Discovery catalog conforms and returns exactly what a coding agent must fix.** Supply either a raw JSON object for fully offline validation or a public HTTPS URL. The Actor returns stable rule codes, JSON Pointer paths, expected and actual values, severities, and deterministic repair suggestions through Apify API, schedules, integrations, or hosted MCP tooling.

It uses the same pinned schema and semantic engine as ARD Catalog Resolver, with no LLM, browser, paid API, or automatic mutation of your document.

### Why use ARD Catalog Validator?

The official ARD project provides a free conformance CLI. This paid primitive is for workflows that need an independently deployable Apify/MCP contract, one versioned JSON result, stable diagnostics rather than Ajv-specific prose, remote URL safety, and parity with the Resolver’s production interpretation. Typical agent queries include “Is this ARD catalog valid?”, “Why does this ai-catalog.json fail?”, and “Return machine-readable repairs for this ARD manifest.”

### How to use ARD Catalog Validator

1. Open the Input tab.
2. Paste a `catalog` JSON object or provide one public HTTPS `url`, never both.
3. Select strict mode for conformance or permissive mode while investigating extensions.
4. Run and consume the single dataset envelope.

### Input

```json
{
    "catalog": {
        "specVersion": "1.0",
        "entries": []
    },
    "validationMode": "strict"
}
```

Raw input causes no network request. Strict mode rejects fields that the pinned upstream schema forbids. Permissive mode demotes only those `additionalProperties` failures to warnings; entry extension fields that the ARD schema explicitly permits remain valid in both modes. An unsupported catalog version remains invalid.

### Output

```json
{
    "contractVersion": "1.0",
    "ok": true,
    "valid": false,
    "ardSpecVersion": "0.9",
    "catalogSpecVersion": "1.0",
    "schemaRevision": "5fa2f5aef790b478319f6a3b43adf4661b0ed0e0",
    "errorCount": 1,
    "errors": [
        {
            "code": "INVALID_IDENTIFIER",
            "path": "/entries/0/identifier",
            "severity": "error",
            "suggestion": "Use a valid ARD identifier beginning with urn:air:."
        }
    ]
}
```

You can download the dataset in formats such as JSON, HTML, CSV, or Excel; JSON is recommended for repair automation.

### Data table

| Field                | Meaning                                 |
| -------------------- | --------------------------------------- |
| `valid`              | Conformance in the selected mode.       |
| `ardSpecVersion`     | Pinned ARD prose draft version.         |
| `catalogSpecVersion` | Manifest version declared by the input. |
| `schemaRevision`     | Exact upstream Git revision.            |
| `errors`             | Repair-grade blocking issues.           |
| `validationWarnings` | Non-blocking issues.                    |

### Pricing / Cost estimation

The provisional price is **$0.01 for one `catalog-validation` event**. Valid and invalid completed determinations are billable. Input rejection and URL network/resource/internal failures are free. Check the live Actor details for current pricing.

### Tips and limits

Prefer inline input in CI and code-generation workflows: it is faster, deterministic, and removes network uncertainty. The Actor never emits a patched catalog, so downstream automation must apply and review its own changes. Remote URL responses are limited to public HTTPS, bounded redirects, and 1 MiB decoded content. DNS is resolved and pinned per request, private/local/link-local targets are blocked again after redirects, and URL query values are redacted from result provenance and logs.

Invalid JSON and schema-invalid catalogs are completed validation determinations (`ok: true`, `valid: false`). Invalid Actor input and URL retrieval failures return `ok: false` with a stable machine error and are not charged.

### FAQ, disclaimers, and support

The supported baseline is [ARD draft 0.9](https://agenticresourcediscovery.org/spec/) and catalog manifest 1.0 at schema revision `5fa2f5aef790b478319f6a3b43adf4661b0ed0e0`. This is not a replacement for reviewing the official specification or [free conformance tooling](https://github.com/ards-project/ard-spec/tree/main/conformance). Use the Actor’s Issues tab for a diagnostic that differs from the pinned upstream behavior, including a minimal anonymized catalog.

# Actor input Schema

## `catalog` (type: `object`):

Raw ARD catalog object. Validation is fully offline when supplied. Provide catalog or url, never both.

## `url` (type: `string`):

Public HTTPS URL of an ARD catalog to retrieve and validate. Provide url or catalog, never both.

## `validationMode` (type: `string`):

Strict rejects fields forbidden by the pinned schema; permissive reports those fields as warnings. Entry extensions allowed by the ARD schema remain valid in both modes.

## Actor input object example

```json
{
  "catalog": {
    "specVersion": "1.0",
    "entries": [
      {
        "identifier": "urn:air:example.com:tools:weather",
        "displayName": "Weather",
        "type": "application/json",
        "url": "https://example.com/weather"
      }
    ]
  },
  "validationMode": "strict"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing the single ARD catalog validation envelope.

# 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 = {
    "catalog": {
        "specVersion": "1.0",
        "entries": [
            {
                "identifier": "urn:air:example.com:tools:weather",
                "displayName": "Weather",
                "type": "application/json",
                "url": "https://example.com/weather"
            }
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vincesoft/ard-catalog-validator").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 = { "catalog": {
        "specVersion": "1.0",
        "entries": [{
                "identifier": "urn:air:example.com:tools:weather",
                "displayName": "Weather",
                "type": "application/json",
                "url": "https://example.com/weather",
            }],
    } }

# Run the Actor and wait for it to finish
run = client.actor("vincesoft/ard-catalog-validator").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 '{
  "catalog": {
    "specVersion": "1.0",
    "entries": [
      {
        "identifier": "urn:air:example.com:tools:weather",
        "displayName": "Weather",
        "type": "application/json",
        "url": "https://example.com/weather"
      }
    ]
  }
}' |
apify call vincesoft/ard-catalog-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vincesoft/ard-catalog-validator"
        }
    }
}

```

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/mdtmV9bYdZW3AWptb/builds/E4JHQf6radmuKnXQV/openapi.json