Services

Services directory.

Purpose-built, stateless services across six categories: governance, security, routing, data, analytics, and content. One API surface: point POST /v1/run at the service you need.

Data 3

curl -X POST https://api.chersus.com/v1/run \
  -H "Authorization: Bearer chrs_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "type": "text",
      "value": "Order 4821 for jane.doe@example.com arrived late, customer wants a refund."
    },
    "pipeline": [
      {
        "id": "extract",
        "service": "data.entity.extract",
        "params": {
          "schema": {
            "order_id": "string",
            "customer_email": "string",
            "issue": "string"
          }
        }
      }
    ]
  }'

const res = await fetch("https://api.chersus.com/v1/run", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHERSUS_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    input: {
      type: "text",
      value: "Order 4821 for jane.doe@example.com arrived late, customer wants a refund.",
    },
    pipeline: [
      {
        id: "extract",
        service: "data.entity.extract",
        params: {
          schema: { order_id: "string", customer_email: "string", issue: "string" },
        },
      },
    ],
  }),
});

const data = await res.json();

import os

import requests

res = requests.post(
    "https://api.chersus.com/v1/run",
    headers={"Authorization": f"Bearer {os.environ['CHERSUS_KEY']}"},
    json={
        "input": {
            "type": "text",
            "value": "Order 4821 for jane.doe@example.com arrived late, customer wants a refund.",
        },
        "pipeline": [
            {
                "id": "extract",
                "service": "data.entity.extract",
                "params": {
                    "schema": {
                        "order_id": "string",
                        "customer_email": "string",
                        "issue": "string",
                    }
                },
            }
        ],
    },
)

data = res.json()

200 · 34ms · 74 chars

{
  "trace_id": "chs_01J9X4Q7K2M8N3P5R6T7V8W9X7",
  "status": "completed",
  "output": {
    "type": "text",
    "value": "Order 4821 for jane.doe@example.com arrived late, customer wants a refund."
  },
  "results": {
    "extract": {
      "kind": "extract",
      "status": "ok",
      "data": {
        "order_id": "4821",
        "customer_email": "jane.doe@example.com",
        "issue": "late delivery, refund requested"
      }
    }
  },
  "usage": {
    "billed": [
      { "unit": "characters", "quantity": 74, "steps": ["extract"] }
    ]
  },
  "audit": { "region": "eu-nl-1", "retention": "none", "total_ms": 34 }
}

data.entity.extract is the bridge between unstructured input and your typed systems. Give it a schema of the fields you need via params.schema. It returns exactly those keys, with values pulled from the text and validated against your schema.

Your schema fixes the output shape, so the service can feed a database insert or a typed API call directly. No parsing layer of your own.

KIND: extract
MODEL: numind/NuExtract-tiny
LICENSE: Apache 2.0
LANGUAGES: English
REGION: 26 EU cities

curl -X POST https://api.chersus.com/v1/run \
  -H "Authorization: Bearer chrs_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "type": "text",
      "value": "Panamalaan 8-D, 1019 AZ Amsterdam, The Netherlands"
    },
    "pipeline": [
      { "id": "address", "service": "data.address.parse" }
    ]
  }'

const res = await fetch("https://api.chersus.com/v1/run", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHERSUS_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": {
      "type": "text",
      "value": "Panamalaan 8-D, 1019 AZ Amsterdam, The Netherlands"
    },
    "pipeline": [
      {
        "id": "address",
        "service": "data.address.parse"
      }
    ]
  }),
});

const data = await res.json();

import os

import requests

res = requests.post(
    "https://api.chersus.com/v1/run",
    headers={"Authorization": f"Bearer {os.environ['CHERSUS_KEY']}"},
    json={
      "input": {
        "type": "text",
        "value": "Panamalaan 8-D, 1019 AZ Amsterdam, The Netherlands"
      },
      "pipeline": [
        {
          "id": "address",
          "service": "data.address.parse"
        }
      ]
    },
)

data = res.json()

200 · 50 chars

{
  "trace_id": "chs_01J9X4Q7K2M8N3P5R6T7V8W9XG",
  "status": "completed",
  "output": {
    "type": "text",
    "value": "Panamalaan 8-D, 1019 AZ Amsterdam, The Netherlands"
  },
  "results": {
    "address": {
        "kind": "extract",
        "status": "ok",
        "data": {
          "house_number": "8-D",
          "road": "Panamalaan",
          "postcode": "1019 AZ",
          "city": "Amsterdam",
          "country": "The Netherlands"
        }
      }
  },
  "usage": {
    "billed": [
      { "unit": "characters", "quantity": 50, "steps": ["address"] }
    ]
  },
  "audit": { "region": "eu-nl-1", "retention": "none" }
}

data.address.parse splits a single line of address text into the components a database or a shipping API expects. It is libpostal underneath, a statistical parser trained on addresses from every inhabited country, so it copes with the orderings and abbreviations that vary between them rather than assuming one national format.

There is no model and no inference here, which is why it is quick and why its output is stable for a given input. It normalises and splits; it does not verify that an address exists.

KIND: extract
MODEL: libpostal (library, no model)
LICENSE: MIT
LANGUAGES: Multilingual
REGION: 26 EU cities

curl -X POST https://api.chersus.com/v1/run \
  -H "Authorization: Bearer chrs_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "type": "text",
      "value": "Geleverd op 12 maart 2026, retour voor 2 april."
    },
    "pipeline": [
      { "id": "dates", "service": "data.date.normalize" }
    ]
  }'

const res = await fetch("https://api.chersus.com/v1/run", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHERSUS_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": {
      "type": "text",
      "value": "Geleverd op 12 maart 2026, retour voor 2 april."
    },
    "pipeline": [
      {
        "id": "dates",
        "service": "data.date.normalize"
      }
    ]
  }),
});

const data = await res.json();

import os

import requests

res = requests.post(
    "https://api.chersus.com/v1/run",
    headers={"Authorization": f"Bearer {os.environ['CHERSUS_KEY']}"},
    json={
      "input": {
        "type": "text",
        "value": "Geleverd op 12 maart 2026, retour voor 2 april."
      },
      "pipeline": [
        {
          "id": "dates",
          "service": "data.date.normalize"
        }
      ]
    },
)

data = res.json()

200 · 47 chars

{
  "trace_id": "chs_01J9X4Q7K2M8N3P5R6T7V8W9XH",
  "status": "completed",
  "output": {
    "type": "text",
    "value": "Geleverd op 2026-03-12, retour voor 2026-04-02."
  },
  "results": {
    "dates": { "kind": "transform", "status": "ok", "changes": 2 }
  },
  "usage": {
    "billed": [
      { "unit": "characters", "quantity": 47, "steps": ["dates"] }
    ]
  },
  "audit": { "region": "eu-nl-1", "retention": "none" }
}

data.date.normalize rewrites date expressions in place, leaving the rest of the text alone. It reads the formats people actually type, in their own language, and writes ISO 8601 back, so what reaches your parser is a date rather than a guess.

It is dateparser underneath, which covers over two hundred language locales and the Gregorian, Jalali and Hijri calendars, and it is deterministic: no model, same answer every time. Relative expressions resolve against the time of the run, so pass an explicit date when you need the result to be reproducible later.

KIND: transform
MODEL: dateparser (library, no model)
LICENSE: BSD-3-Clause
LANGUAGES: Multilingual
REGION: 26 EU cities

Start redacting in minutes.

Create an account, copy your key, make your first run before your coffee cools.

Request access Read the chaining guide