A manifest in 15 minutes

At the end of this tutorial you will have written a manifest for a data source, validated it against the dated JSON Schema, and know what happens next. You need a text editor, Rust (stable via rustup) and Git; every command runs from the root of the corpus checkout.

1. What a manifest is

A manifest is plain JSON in exactly one normalised shape: a profile on DCAT-AP-CH with the AI-interface extension, clean RDF at the same time thanks to the JSON-LD context. Nine fields are mandatory; the reference Manifest standard names them field by field.

2. Create the file

Create a file whose name is the slug of your identifier, for example my-source.json. The content is the association's parked manifest, cut to the mandatory fields plus tier and probe; replace identifier, title, publisher, licence and endpoint with your own. The command creates the file exactly as shown:

cat > my-source.json <<'EOF'
{
  "$schema": "https://ld.openhelvetia.swiss/ns/manifest/schema/2026-08-15/manifest.schema.json",
  "@context": "https://ld.openhelvetia.swiss/ns/manifest/v1",
  "@id": "https://ld.openhelvetia.swiss/registry/my-source",
  "@type": "Manifest",
  "title": {
    "de": "Meine Quelle — SPARQL-Zugang",
    "en": "My source — SPARQL access"
  },
  "publisher": "https://ld.openhelvetia.swiss/org/my-organisation",
  "license": "https://dcat-ap.ch/vocabulary/licenses/terms_open",
  "interfaces": [
    {
      "@type": "SparqlInterface",
      "endpoint": "https://example.org/sparql",
      "auth": {
        "authType": "none"
      },
      "tier": "base",
      "probe": {
        "kind": "sparql-ask",
        "expect": "boolean"
      }
    }
  ],
  "issued": "2026-09-02"
}
EOF

The file is in the standard's canonical form (fixed key order, two spaces, LF); any other formatting is reported by the second stage as an error, and --write produces it. Three things often go wrong here: @context is exactly one string, not an array; title is a language map, not a string; license is an IRI, not a name.

3. Validate against the schema

You can run the first of the four validation stages yourself. The dated schema is public; any validator for JSON Schema 2020-12 will do. With the association's validator from the checkout:

cargo run --locked --manifest-path registry/standard/oh-validate/Cargo.toml -- registry/standard/schema/manifest.schema.json my-source.json

Expected output on success:

checked 1 file(s): OK

An unknown key is an error, not a warning. The message names the path in the document.

4. The other three stages

JSON-LD round trip, SHACL shapes and the whole graph run at the association, as a gate before every change to the register. You can run them locally too:

cargo run --locked --manifest-path registry/standard/oh-validate/Cargo.toml -- registry/standard/schema/manifest.schema.json my-source.json --stage2 registry/standard/context/v1.jsonld --stage3 registry/standard/shapes/manifest-v1.ttl --stage4

The stages are described in How it is validated.

5. Submit

One of three routes leads into the directory; the guide The three admission routes describes them. Today that means: manifest and declaration in written form to the association's contact address. This page names no processing period; none has been decided.

What you have now

A manifest that passes the first validation stage, and the commands for the other three. Next: Read the directory by machine, to see how your entry will be served later.