# MANE API & webhooks

Versie v1 BETA · 19 oktober 2026

Gebruik het basisadres en de veldcatalogus uit je eigen werkruimte. Voorbeelden bevatten fictieve waarden.


# Koppelingen, API & webhooks

Verbind MANE met je andere toepassingen. Begin met één werkproces en ontdek welke gegevens, velden en gebeurtenissen je kunt gebruiken.

## Kies de route die bij je werk past

De MANE API leest of wijzigt gegevens op verzoek. Een webhook meldt dat er iets is veranderd. Make, n8n of je eigen toepassing bepaalt vervolgens wat daarmee gebeurt. Je hoeft hiervoor geen complete nieuwe app te bouwen.

Een voorbeeld: een formulier levert een aanvraag aan, je workflow zoekt de juiste klant en maakt een project aan. Een andere workflow ontvangt een wijziging van een taak en werkt de planning in een ander systeem bij. Deze voorbeelden zijn inrichtingen die je zelf bouwt, geen vooraf ingeschakelde automatiseringen.

Route | Gebruik
--- | ---
API | Gegevens ophalen, aanmaken, aanpassen of verwijderen binnen de gekozen rechten.
n8n-communitynodes | MANE-gegevens en skillinstructies beheren via het pakket n8n-nodes-mane@0.1.0-beta.2.
Webhook | Een externe workflow laten reageren op een opgeslagen wijziging.
Google-koppeling | Je persoonlijke Gmail of Google Agenda verbinden via de eigen verbindingsroute.
MANE-abonnement | Je MANE-pakket en AI-credits betalen. Voor klantfacturen koppel je apart je eigen Mollie-profiel in de app; de betaalstatus controleer je vanuit de factuur.

## MANE als community node in n8n

Voor self-hosted n8n is het communitypakket n8n-nodes-mane@0.1.0-beta.2 beschikbaar. Het bevat de node MANE met 115 acties voor je werkruimte en MAINE Skills met 5 acties voor het beheren van skillinstructies. Je kiest een gegevenssoort en handeling; de node toont daarbij methode, route en benodigde scope.

Dit is een community-BETA, niet een door n8n geverifieerde connector. De installatie loopt via Community nodes op je eigen n8n-instance. Voor Make blijft de HTTP- en webhookroute beschikbaar.

```
n8n-nodes-mane@0.1.0-beta.2
```

[Installeren en je eerste MANE-node gebruiken](/docs/api-n8n)

[Het pakket op npm](https://www.npmjs.com/package/n8n-nodes-mane/v/0.1.0-beta.2)

## Pakketten en AI-credits

API en webhooks horen bij ieder MANE-pakket, inclusief Basic ZZP. Gewone gegevensverzoeken en webhookmeldingen voeren geen AI-generatie uit en gebruiken geen MAINE-credits. De schrijfbaarheid van de werkruimte en de scopes van je sleutel blijven bepalend.

MAINE is tijdens de proefperiode beschikbaar en daarna vanaf Extended. Extended bevat 1.500 maandcredits, Team en Business 3.000. Een skill via de API opslaan is iets anders dan met MAINE een skill laten maken. AI-uitvoering via een externe flow is geen algemene publieke API-actie in deze versie.

[Pakketten, credits en geldigheid](/docs/pakketten-en-pilot)

[Actuele prijzen en creditkeuze](/prijzen)

## Je hoeft veldnamen niet te raden

Open Instellingen → API & webhooks. Onder Wat spreek je aan? kies je een object. Daar staan het endpoint, de technische veldsleutels, typen en JSON-paden van jouw werkruimte. Ook je eigen objecten en eigenschappen staan ertussen.

Dezelfde catalogus lees je via GET /api/v1/schema met schema:read. Een zichtbaar label zoals Cliënten kan veranderen; gebruik voor je koppeling de object-ID en veld-ID uit de catalogus. Projecten en trajecten gebruiken dezelfde verzameling /projects.

[Objecten, endpoints en veldnamen](/docs/api-objecten-en-velden)

## Begin met een kleine, leesbare koppeling

Maak als eigenaar een servicesleutel voor één toepassing en één MANE. Selecteer alleen de benodigde scopes. Begin met een leesverzoek en controleer of je de verwachte werkruimte en dossiers terugkrijgt. Voeg daarna pas schrijven en webhooks toe.

[Je eerste API-verzoek](/docs/api-snelstart)

[Servicesleutels en rechten](/docs/api-servicesleutels-en-scopes)

## Van voorbeeld naar dagelijks gebruik

Bouw eerst met fictieve dossiers. Bewaar externe referenties zodat dezelfde aanvraag niet telkens een nieuwe klant oplevert. Gebruik voor elke wijziging de gelezen revisie en een vaste Idempotency-Key. Bekijk fouten en activiteit voordat je je workflow activeert.

[MANE verbinden met n8n](/docs/api-n8n)

[MANE verbinden met Make](/docs/api-make)

[Webhooks ontvangen en controleren](/docs/api-webhooks)

[Fouten, herhalen en paginering](/docs/api-fouten-en-paginering)

## Wat de API wel en niet uitvoert

De API BETA gebruikt dezelfde dossiercontrole en bescherming van vastgelegde documenten als MANE. Een schrijfverzoek is geen automatische toestemming voor het versturen van mail, accepteren namens een klant of uitvoeren van een bankbetaling. Persoonlijke Gmail-inhoud en accountrechten zijn geen algemene dossiercollecties.

Je kunt gegevens voor je eigen processen verbinden, inclusief eigen objecten en velden. In n8n kun je daarvoor het MANE-communitypakket of HTTP Request gebruiken; Make gebruikt HTTP en webhooks. Een publieke MANE CLI, bulkendpoint en publieke AI-uitvoering zijn in deze versie niet beschikbaar. Het communitypakket voegt geen extra API-rechten toe.

[Alle routes en de OpenAPI-download](/docs/api-referentie)

# Je eerste API-verzoek

Van servicesleutel naar een gecontroleerd leesverzoek en je eerste wijziging, met concrete headers en JSON.


## 1. Neem het basisadres uit je eigen MANE

Open Instellingen → API & webhooks en kopieer het basisadres. Het eindigt op /api/v1. In deze voorbeelden vervang je jouw-werkruimte.maneworks.com door dat adres. De sleutel hoort altijd bij één werkruimte; een adres van een andere tenant geeft geen toegang.

Maak een sleutel met workspace:read, schema:read, projects:read en projects:write voor dit voorbeeld. Bewaar de volledige sleutel meteen als geheim in je toepassing. Gebruik geen echte sleutel in gedeelde screenshots of broncode.


## 2. Controleer eerst de werkruimte

Doe een GET-verzoek met de Authorization-header. Het resultaat bevat data, revision en requestId. De responseheader ETag bevat dezelfde revisie. Het onderstaande token is een placeholder.

```http

GET https://jouw-werkruimte.maneworks.com/api/v1/workspace
Authorization: Bearer <JOUW_SERVICESLEUTEL>

```

```json

{
  "data": {"id": "co_…", "name": "Jouw MANE", "revision": 12},
  "revision": 12,
  "requestId": "…"
}

```


## 3. Lees objecten en projecten

GET /schema toont de inrichting, endpoints en veldpaden. GET /projects?limit=10 toont de eerste projecten of trajecten. Controleer de data voordat je wijzigingen toevoegt. De naam op het scherm en het technische endpoint hoeven niet hetzelfde woord te gebruiken.

```http

GET https://jouw-werkruimte.maneworks.com/api/v1/schema
Authorization: Bearer <JOUW_SERVICESLEUTEL>

GET https://jouw-werkruimte.maneworks.com/api/v1/projects?limit=10
Authorization: Bearer <JOUW_SERVICESLEUTEL>

```


## 4. Maak één fictief project aan

Gebruik POST, JSON en de revisie die je net hebt gelezen als If-Match. De Idempotency-Key kies je één keer voor deze specifieke wijziging. Maak bij een echte koppeling een stabiele sleutel op basis van bijvoorbeeld de externe aanvraag-ID en de handeling.

De voorbeeldrevisie 12 is illustratief. Gebruik de actuele revisie uit jouw antwoord. MANE maakt de dossier-ID; stuur bij POST geen eigen id mee.

```http

POST https://jouw-werkruimte.maneworks.com/api/v1/projects
Authorization: Bearer <JOUW_SERVICESLEUTEL>
Content-Type: application/json
If-Match: "12"
Idempotency-Key: aanvraag-demo-001-project

{"name":"Fictieve aanvraag","place":"Zwolle"}

```


## 5. Controleer de opgeslagen uitkomst

Een geslaagde POST geeft 201 met de nieuwe data.id en revision terug. Lees daarna GET /projects/<id>. Bewaar de MANE-ID bij je externe referentie. Een antwoord 200 bij een herhaald identiek verzoek kan replayed:true bevatten: je eerste wijziging is dan herkend en niet opnieuw aangemaakt.

Een PATCH wijzigt alleen meegegeven velden; geneste lijsten of objecten die je meegeeft vervangen hun oude waarde. Bij een conflict lees je eerst opnieuw en beoordeel je de wijziging. Verhoog If-Match nooit op goed geluk.

[Veilig omgaan met conflicten en herhalen](/docs/api-fouten-en-paginering)


# Servicesleutels & scopes

Bepaal per koppeling wat die mag lezen en wijzigen, hoe lang de sleutel werkt en wanneer je toegang intrekt.


## Een sleutel is toegang tot één MANE

Alleen een eigenaar beheert servicesleutels via Instellingen → API & webhooks. Geef elke sleutel een herkenbare naam, bijvoorbeeld n8n · projectplanning. Kies 7, 30, 90 of 365 dagen geldigheid. Per werkruimte zijn maximaal twintig actieve sleutels toegestaan.

De volledige msk_-sleutel verschijnt één keer. De opgeslagen controlewaarde laat het origineel niet opnieuw zien. Ben je hem kwijt, maak dan een nieuwe sleutel en trek de oude in. Een servicesleutel kan zelf geen andere servicesleutels aanmaken.


## Lezen en wijzigen zijn aparte rechten

Een scope bestaat uit een onderdeel en een handeling, bijvoorbeeld projects:read. Wijzigrechten geven niet automatisch leesrechten. Voor het lezen van revisies voeg je workspace:read of een passend leesrecht toe. Voor de veldcatalogus gebruik je schema:read.

Scope | Wat dit toestaat

--- | ---

projects:read / projects:write | Projecten én trajecten lezen / wijzigen.

records:read / records:write | Alle relatie- en eigen dossierrecords lezen / wijzigen.

objects.installaties:read / :write | Alleen records van het object installaties, via /objects/installaties/records.

schema:read / schema:write | Objectinrichting bekijken / objecten en eigenschappen inrichten.

tasks:read / tasks:write | Taken lezen / wijzigen binnen een project.

relations:read / relations:write | Dossierverbanden lezen / toevoegen of verwijderen.

webhooks:read / webhooks:write | Webhookconfiguratie bekijken / beheren.

events:read | Gebeurtenissen ophalen als alternatief voor pushmeldingen.

files:read / files:write | Bestanden lezen / uploaden.


## Zo klein mogelijk kiezen

Wil je uitsluitend installaties synchroniseren, gebruik dan objects.installaties:read en eventueel :write. Geef niet ook records:read als je de sleutel wilt beperken tot dat object: records:read geeft toegang tot de brede verzameling.

Een exacte objectscope hoort bij de objectroute. Hij verleent geen toegang tot GET /records, andere objecten of de volledige catalogus. Je kunt schema:read afzonderlijk toevoegen als je toepassing de inrichting moet kunnen ontdekken.


## Intrekken, vervangen en verlopen

Klik Intrekken bij de betreffende sleutel. Volgende verzoeken worden geweigerd. De sleutel blijft gekoppeld aan de eigenaar die hem aanmaakte: verliest die het eigenaarschap of wordt de MANE verwijderd, dan stopt de toegang ook.

Een webhook is een apart beheerd abonnement. Trek je een API-sleutel in, pauzeer of verwijder dan ook de bijbehorende webhook als de externe workflow geen meldingen meer mag ontvangen. Een webhookmelding die al onderweg is kan nog aankomen.

Vervang bij rotatie eerst het geheim in je externe toepassing, controleer een leesverzoek en trek daarna de oude sleutel in. Log geen Authorization-header en zet sleutels niet in URL-queryparameters.


## Limieten en gebruik

De grens is 120 API-verzoeken per minuut per sleutel. Bij 429 wacht je volgens Retry-After. Schrijfverzoeken vereisen een actieve, schrijfbare werkruimte. Na afloop van een proef of abonnement kunnen bewaarde gegevens nog leesbaar zijn terwijl wijzigen wordt geweigerd.

Gewone API-dossierverzoeken voeren geen AI-generatie uit. Een skill opslaan is dus geen skill met MAINE laten schrijven. Kosten of limieten van Make en n8n zijn afhankelijk van je eigen abonnement daar.


# Objecten, endpoints & veldnamen

Weten wat je aanspreekt: van Cliënten op je scherm naar het juiste endpoint, record-ID en properties-veld in JSON.


## Vier namen die je uit elkaar houdt

Het label is de naam die je in MANE ziet. De object-ID benoemt het type dossier. Het endpoint is de route naar die dossiers. Een veld-ID is de sleutel van een eigenschap binnen één dossier. Neem technische sleutels letterlijk over; verzin geen contact.email als de catalogus een andere sleutel geeft.

Onderdeel | Voorbeeld | Waarvoor

--- | --- | ---

Label | Cliënten | Herkenbare naam in de interface.

Object-ID | contacts (alleen als jouw catalogus dit aangeeft) | Type dossier; kan afwijken van het label.

Endpoint | /api/v1/objects/contacts/records | De verzameling dossiers.

Record-ID | api_… | Eén specifieke cliënt.

Veldpad | properties["E-mail"] | De eigenschap in de JSON-body en respons.


## De catalogus van jouw werkruimte

Open Instellingen → API & webhooks → Wat spreek je aan? Kies het object, zoek op veldnaam en kopieer het endpoint of JSON-pad. Je ziet veldtype, verplichte eigenschappen en eventuele omschrijving.

Via GET /schema ontvang je dezelfde inrichting. Iedere catalogusrij bevat id, name, endpoint, readScope, writeScope, attributes en fields. attributes zijn directe JSON-velden zoals name en status; fields zijn de ingerichte eigenschappen onder properties. Een specifiek object lees je via GET /objects/<object-id>.

De catalogus toont bruikbare basisattributen en alle ingerichte eigenschappen. Complexe financiële documentstructuren vragen daarnaast hun eigen documentvalidatie; de veldlijst is geen mogelijkheid om beschermd akkoord of een vastgelegde factuur te omzeilen.


## Een cliënt of bedrijf benaderen

Relaties en eigen objecten staan onder /objects/<object-id>/records. GET /records is de brede verzameling en vereist records:read. De precieze relatie-object-ID vind je in jouw catalogus, niet in dit voorbeeld.

Als jouw object contacts heet en een veld-ID E-mail heeft, ziet een aanmaakbody er zo uit. Gebruik ook de verplichte velden van je eigen object. Neem properties als object op in JSON; zet niet letterlijk een veld met de naam properties.E-mail in de body.

```json

{
  "name": "Fictieve cliënt",
  "properties": {
    "E-mail": "voorbeeld@example.com"
  }
}

```

```javascript

// Voorbeeld: het eerste dossier uit een lijstantwoord
response.data[0].id
response.data[0].name
response.data[0].properties["E-mail"]

```


## Standaardobjecten en eigen eigenschappen

Projecten en trajecten gebruiken allebei /projects. De naam van het werktype verandert je endpoint niet. Een projecttitel kun je direct schrijven als name. Ingerichte eigenschappen kun je ook via properties aanleveren. Stuur hetzelfde veld niet tweemaal met verschillende waarden.

GET-antwoorden kunnen bestaande opslagvelden zoals values en customValues bevatten. Gebruik voor jouw veldmapping properties: dat houdt de lees- en schrijfroute gelijk. customValues is geen toegestane schrijfbody; MANE bewaart de eigenschap na validatie op de juiste plek.


## Typen en lege waarden

Tekst en e-mail zijn JSON-strings. Getallen zijn JSON-getallen, dus 1.5 en niet "1,5". Een checkbox is true of false. Een datum is YYYY-MM-DD. Een keuzelijst gebruikt een bestaande optie; multiselect is een array van bestaande opties. Een relation-veld verwijst naar een bestaand relatie-ID.

Een ontbrekend PATCH-veld blijft staan. Een expliciete lege waarde kan een niet-verplicht veld leegmaken. Een verplicht veld mag niet leeg worden. Gebruik bij lege tekst ""; verwacht niet dat null overal een apart opgeslagen type is.

Uren zijn decimale uren. Bedragseenheden zijn niet overal gelijk: amountCents en shippingCents zijn centen, terwijl de genoemde price, cost en invoice amount eurovelden zijn. Controleer de veldomschrijving en het dossiermodel.


## Eigen objecten en verbanden

Je kunt eigen objecten en eigenschappen inrichten, bijvoorbeeld Installaties met serienummer en onderhoudsdatum. De nieuwe technische sleutel verschijnt in de catalogus en krijgt een eigen objectroute.

[Eigen objecten, eigenschappen en relaties bouwen](/docs/api-eigen-objecten-en-relaties)

[Alle routes bekijken](/docs/api-referentie)


# Eigen objecten & dossierkoppelingen

Maak een eigen informatiestructuur en verbind die met klanten, projecten of andere dossiers.


## Eerst je gegevensstructuur kiezen

Bepaal welk dossier je nodig hebt en wat erin hoort. Een installatie heeft bijvoorbeeld een naam, serienummer en onderhoudsdatum. Geef het object een korte technische ID die je koppeling blijft gebruiken, ook wanneer het zichtbare label verandert.

Object-ID’s beginnen met een kleine letter en bevatten maximaal 61 kleine letters, cijfers, onderstrepingen of streepjes. Een object heeft maximaal zestig eigenschappen. Geef iedere eigenschap een unieke sleutel en zichtbare naam.


## Een eigen object aanmaken

Gebruik POST /objects/installaties met schema:write, If-Match en een vaste Idempotency-Key. Dit is een voorbeeldschema. Het eerste request maakt de inrichting; een volgend request maakt pas een installatiedossier.

```json

{
  "name": "Installaties",
  "singular": "Installatie",
  "fields": [
    {"id":"serial","name":"Serienummer","type":"text","required":true},
    {"id":"onderhoud","name":"Onderhoudsdatum","type":"date"},
    {"id":"categorie","name":"Categorie","type":"select","options":["Ketel","Warmtepomp"]}
  ]
}

```


## Een dossier vullen

Gebruik daarna POST /objects/installaties/records met objects.installaties:write of records:write. Lees de nieuwste revisie na het maken van het schema. Een verplicht serienummer wordt ook gecontroleerd als je properties helemaal weglaat.

```json

{
  "name": "Warmtepomp fictief",
  "properties": {
    "serial": "DEMO-001",
    "onderhoud": "2027-04-01",
    "categorie": "Warmtepomp"
  }
}

```


## Eigenschappen later aanpassen

Lees eerst GET /objects/installaties. Stuur bij PATCH /objects/installaties de volledige schemadefinitie met alle te behouden velden, name en singular. Dit is geen losse toevoeging van één veld. Bestaande systeemvelden behouden hun id, type, native en valueKey.

Ondersteunde veldtypen zijn text, email, number, date, select, checkbox, multiselect en relation. select en multiselect vragen options. Het verwijderen van een object loopt via Eigen inrichting na controle van afhankelijkheden; DELETE op de schema-API is geblokkeerd.


## Twee dossiers verbinden

POST /relations maakt een verband tussen twee bestaande dossiers. from.scope en to.scope zijn object-ID’s; id is steeds een dossier-ID. Dit aanvullende verband verandert geen ondertekende offerte of financiële eigenaar.

Voor een directe projectklant gebruik je het daarvoor bedoelde projectveld relation met de klant-ID. Een aanvullend dossierverband is context en vervangt die commerciële koppeling niet.

```json

{
  "from": {"scope":"projects","id":"<PROJECT_ID>"},
  "to": {"scope":"installaties","id":"<INSTALLATIE_ID>"}
}

```


## Relaties lezen of verwijderen

GET /relations geeft opgeslagen aanvullende dossierkoppelingen terug. DELETE /relations/<link-id> verwijdert één koppeling, met de actuele If-Match en Idempotency-Key. De dossiers zelf blijven bestaan.

De huidige link-ID kan link:0 zijn. Dit is een positie binnen een revisie. Lees de koppeling opnieuw voordat je haar verwijdert; bewaar zulke link-ID’s niet als permanente externe dossiersleutel.


# Webhooks ontvangen & controleren

Laat MANE een melding sturen bij een wijziging, en verwerk die betrouwbaar met ondertekening, ontdubbelen en herstel.


## Een webhook meldt wat er veranderde

Een webhook is een HTTPS POST van MANE naar een adres dat jij beheert. De melding bevat metadata zoals gebeurtenis-ID, type, dossier-ID en revisie. De dossierinhoud haal je daarna op met een eigen servicesleutel en passend leesrecht.

Wijzigingen uit MANE en uit de API kunnen een melding opleveren. Eén handeling kan meerdere gebeurtenissen geven, bijvoorbeeld projects.updated én tasks.created. De bezorging is asynchroon: je moet rekening houden met vertraging, dubbele bezorging en een andere aankomstvolgorde.


## Een webhook instellen

Open Instellingen → API & webhooks → Webhook toevoegen. Vul naam en het publieke HTTPS-ontvangstadres in. Kies de onderdelen met de selectievakjes. Bewaar de ondertekeningssleutel, controleer je ontvanger en schakel de webhook bewust in.

Het adres gebruikt HTTPS op poort 443, zonder gebruikersnaam, wachtwoord of fragment. Lokale/private adressen, IP-literals en doorverwijzingen worden niet gebruikt. Een webhook staat bij aanmaken standaard uit tenzij enabled:true is meegegeven.

Keuze | Betekenis

--- | ---

projects.* | Aanmaken, wijzigen en verwijderen van projecten of trajecten.

tasks.created | Alleen nieuw aangemaakte taken.

records.* | Alle relaties en eigen dossierrecords; filter in je workflow op het opgehaalde objecttype.

schema.* | Wijzigingen aan objectinrichting.

relations.* | Wijzigingen aan aanvullende dossierkoppelingen.

configuration.* | Configuratiewijzigingen, inclusief opgeslagen MAINE-skills.

* | Alle ondersteunde gebeurtenissen; alleen kiezen als je ze nodig hebt.


## Een voorbeeldmelding

Onderstaande waarden zijn fictief. Bewaar id als string. Voor een taak gebruik je data.projectId plus data.recordId om het detail op te halen. Bij een deleted-event is dat dossier mogelijk al niet meer op te halen.

companyId staat in het data-object van een bezorgde webhook. De events-ophaalroute geeft een lijst van metadata binnen de al geauthenticeerde werkruimte. sourceKeyId is null bij wijzigingen zonder API-sleutel.

```json

{
  "specversion":"1.0",
  "id":"1042",
  "type":"tasks.created",
  "source":"mane",
  "data":{
    "id":"1042",
    "type":"tasks.created",
    "companyId":"co_…",
    "resource":"tasks",
    "recordId":"api_…",
    "projectId":"project-…",
    "revision":42,
    "sourceKeyId":null,
    "occurredAt":"2026-10-19T08:00:00Z"
  }
}

```


## Controleer de afzender vóór verwerking

Gebruik de oorspronkelijke requestbody, exact zoals ontvangen. Maak er voor de controle geen opnieuw geserialiseerd JSON-object van. MANE stuurt X-MANE-Timestamp, X-MANE-Signature, X-MANE-Event-Id en X-MANE-Delivery-Id.

De verwachte signature is v1= plus de hex-uitvoer van HMAC-SHA256 met je mwh_-ondertekeningssleutel over timestamp + "." + de ongewijzigde body. Vergelijk met een constante-tijdvergelijking en accepteer alleen timestamps binnen vijf minuten. Bescherm je ontvanger daarnaast tegen herhaalde event-ID’s.

Kan je Make- of n8n-configuratie geen exacte raw body of veilige HMAC-controle bieden, plaats er dan een eigen verificatie-endpoint voor. Een geheim ontvangst-URL alleen is geen controle van de MANE-handtekening.

```javascript

import {createHmac, timingSafeEqual} from "node:crypto";
function valid(secret, timestamp, rawBody, signature) {
  if (!/^\d{10}$/.test(timestamp) ||
      Math.abs(Date.now()/1000 - Number(timestamp)) > 300 ||
      !/^v1=[a-f0-9]{64}$/.test(signature || "")) return false;
  const expected = "v1=" + createHmac("sha256", secret)
    .update(timestamp + ".").update(rawBody).digest("hex");
  return timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

```


## Ontvangen, bewaren en antwoorden

Controleer de signature, leg het event duurzaam vast met een unieke sleutel voor webhook plus event-ID en antwoord snel met 2xx. Verwerk het werk daarna uit je eigen wachtrij. Als duurzaam bewaren mislukt, geef geen succes terug.

Ontvang je dezelfde gebeurtenis opnieuw en was hij al opgeslagen, geef dan opnieuw 2xx zonder de zakelijke actie nogmaals uit te voeren. De inhoud kan inmiddels veranderd zijn: gebruik de revisie als je de gebeurtenisversie nodig hebt, of lees bewust de nieuwste versie.


## Fouten, pauzeren en opnieuw proberen

Een ontvanger heeft maximaal acht seconden voor een antwoord. MANE probeert een mislukte bezorging maximaal zes keer met oplopende wachttijd. Daarna zie je aandacht nodig bij de webhook. Opnieuw proberen zet mislukte bezorgingen weer klaar; het vervangt je eigen ontdubbeling niet.

Pauzeren stopt nieuwe bezorgingen en annuleert wachtende pogingen. Een netwerkverzoek dat al onderweg is kan nog aankomen. Opnieuw inschakelen haalt gepauzeerde meldingen niet automatisch in. Gebruik GET /events?after=<laatste-id> voor herstel en controleer wat je workflow al heeft verwerkt.

Pas een bestemming of de gebeurteniskeuze aan door een nieuwe webhook te maken en de oude te verwijderen. De API ondersteunt bij PATCH alleen enabled en retryFailed; geen stille sleutelrotatie of URL-wijziging.


# MANE verbinden met n8n

Installeer de MANE-communitynodes, verbind een servicesleutel en bouw een eerste flow. Met uitleg over velden, schrijven, MAINE Skills en webhooks.

## Wat zit er in het pakket?

Het npm-pakket n8n-nodes-mane@0.1.0-beta.2 bevat twee nodes: MANE met 115 acties en MAINE Skills met 5 acties. MANE omvat onder meer projecten en trajecten, taken, records, eigen objecten, offertes, facturen, uren, bestanden, schema’s, events en webhookconfiguraties. MAINE Skills beheert de opgeslagen instructies van je skills.

Deze community-BETA is bedoeld voor self-hosted n8n. Hij staat niet in de geverifieerde nodecatalogus van n8n Cloud. De beschikbare acties geven aan welke verzoeken je kunt opbouwen; de rechten en bedrijfsregels van MANE bepalen welke verzoeken jouw werkruimte accepteert.

[Pakket en versie op npm](https://www.npmjs.com/package/n8n-nodes-mane/v/0.1.0-beta.2)

## Installeren: gebruik de exacte pakketversie

Een eigenaar of beheerder kan communitypakketten installeren op een self-hosted n8n-instance waar dit is toegestaan. Gebruik de onderstaande vaste versie om deze handleiding te volgen. De npm-dist-tag beta volgt het beta-kanaal; gebruik de vaste versie om precies deze uitgave te installeren.

1. Open in n8n Settings → Community nodes en kies Install.
2. Vul n8n-nodes-mane@0.1.0-beta.2 in bij de pakketnaam.
3. Lees de melding over communitycode en bevestig de installatie als je die wilt gebruiken.
4. Open de nodekiezer in een workflow en zoek MANE of MAINE Skills.

```
n8n-nodes-mane@0.1.0-beta.2
```

```
n8n-nodes-mane@beta
```

[Officiële n8n-installatiehandleiding](https://docs.n8n.io/integrations/community-nodes/installation-and-management/gui-installation/)

## Je MANE API-credential instellen

Maak in MANE bij Instellingen → API & webhooks een servicesleutel met alleen de benodigde scopes. Kopieer ook het API-basisadres uit je eigen werkruimte; het eindigt op /api/v1.

Kies in de node een credential van het type MANE API. Vul het basisadres in bij Workspace API Base URL en de sleutel zelf bij Service Key. De node voegt Bearer toe. De verbinding maakt geen sleutel aan en geeft geen extra rechten.

De credentialtest leest GET /workspace en vraagt workspace:read. Een sleutel met alleen projects:read kan dus een project leesactie gebruiken terwijl de werkruimtetest niet is toegestaan. Voeg workspace:read alleen toe als je die werkruimtecontrole wilt gebruiken.

[Servicesleutels en scopes kiezen](/docs/api-servicesleutels-en-scopes)

## Je eerste leesflow: maximaal tien projecten

Maak een workflow met Manual Trigger en een MANE-node. Kies Project en Get Many, selecteer je credential en stel Limit in op 10. Laat Return All uit voor deze eerste controle. Gebruik projects:read. Projecten en trajecten gebruiken dezelfde technische projectroute.

Voer alleen deze leesstap uit en bekijk de echte uitvoer. De node splitst lijsten standaard in losse n8n-items. De projectnaam van zo’n item lees je met $json.data.name; de ID staat onder $json.data.id. Een lege lijst levert in deze stand geen items voor de volgende node.

Zet Split List Into Items uit wanneer je het oorspronkelijke pagina-antwoord met revision wilt bewaren, ook bij een lege lijst. Bij een pagina met projecten lees je de eerste projectnaam met $json.data[0].name. Controleer de getoonde uitvoer voordat je een veld mapt.

```
{{ $json.data.name }}
```

```
{{ $json.data[0].name }}
```

## Eigen objecten en velden koppelen

Gebruik Schema → Get Many met schema:read om de catalogus van je werkruimte op te halen. Zet Split List Into Items uit als je de catalogusrevisie wilt behouden. Kies daarna Object Record met de werkelijke objectId en record-ID uit MANE.

Bij Body (JSON) gebruik je de attributen en letterlijke properties-sleutels uit jouw catalogus. Een zichtbaar label zoals Cliënten is niet automatisch de technische object-ID. Getallen blijven getallen en een checkboxwaarde blijft true of false. Benodigde velden kunnen per inrichting verschillen.

Een naam van een cliëntveld kan bijvoorbeeld E-mail zijn. Alleen als dat veld werkelijk bestaat gebruik je bij een gesplitst record $json.data.properties["E-mail"]. Dit is een veldpadvoorbeeld, geen vooraf aangemaakt MANE-veld.

[Objecten en exacte veldpaden](/docs/api-objecten-en-velden)

## Gecontroleerd schrijven: revisie en idempotentie

Voor dossier- en schemawijzigingen vul je de gelezen Revision en een stabiele Idempotency Key in. Geef de revisie zonder aanhalingstekens; de node maakt daar de If-Match-header van. Hij leest niet stilletjes een nieuwe revisie en herhaalt schrijfverzoeken niet automatisch.

1. Lees de actuele werkruimterevisie met Workspace → Get en bewaar die in de flow.
2. Kies de bedoelde Create- of Update-actie en gebruik de juiste scope en technische ID’s.
3. Vul Body (JSON), de gelezen Revision en een unieke sleutel voor deze externe gebeurtenis plus handeling in.
4. Controleer het antwoord en bewaar data.id bij je externe dossier. Lees het detail opnieuw als het schrijfantwoord alleen de ID bevat.
5. Bij een conflict met status 409: lees opnieuw en beoordeel de wijziging. Bij een identieke herhaling na een timeout blijven body, revisie en sleutel gelijk.

[Conflicten, idempotentie en fouten](/docs/api-fouten-en-paginering)

## MAINE Skills: instructies beheren

De aparte node MAINE Skills heeft Get, Get Many, Create, Update en Delete voor /skills. De schrijfvelden zijn name en instructions. Gebruik skills:read om te lezen en skills:write om te wijzigen.

Hiermee kun je bijvoorbeeld een terugkerende werkwijze uit een ander systeem als skillinstructie bewaren. Deze node voert de skill niet uit, start geen AI-chat en genereert geen offerte. Een skill opslaan gebruikt geen MAINE-generatiecredits; AI-uitvoering is geen publieke actie van dit pakket.

[Meer over skills in MANE](/docs/skills)

## Webhooks beheren en events ophalen

MANE heeft acties voor webhookconfiguraties en het lezen van events. Het pakket bevat geen MANE Trigger-node. Een webhook aanmaken is dus iets anders dan een workflow hebben die meldingen veilig ontvangt.

Gebruik voor ontvangst een afzonderlijk ingericht HTTPS-endpoint. Controleer de handtekening over de exacte raw body, de tijdstempel en dubbele event-ID’s voordat een zakelijke actie volgt. Zie de webhookhandleiding voor die controle. Een webhookgeheim kan eenmalig in de uitvoer staan; houd rekening met wie je uitvoeringshistorie kan lezen.

Een alternatief is Event → Get Many op een eigen schema. Bewaar after als tekst en sla het laatst geaccepteerde event-ID duurzaam op. Verwerk hetzelfde event niet opnieuw en voorkom dat je eigen terugschrijfactie een synchronisatielus veroorzaakt.

[Webhooks ontvangen, controleren en herstellen](/docs/api-webhooks)

## Lijsten, bestanden en foutafhandeling

Return All haalt waar ondersteund meerdere pagina’s op. Limit is dan de paginagrootte. Max Pages staat standaard op 100; als er daarna nog pagina’s zijn, meldt de node een fout in plaats van een onvolledige lijst als geslaagd te tonen.

Read Retries staat standaard op nul en kan voor GET-verzoeken worden ingesteld. n8n Retry On Fail is een afzonderlijke workflowinstelling: zet die niet blind aan voor schrijfacties. Een fout kan status, code en request-ID bevatten; gebruik die om ontbrekende rechten, conflicten of limieten te onderzoeken.

Download File geeft de inhoud terug als binary.data. Upload File verwacht de beschreven JSON/base64-body. Uploads en webhookbeheer gebruiken niet dezelfde revisie- en idempotentieheaders als dossierwijzigingen. Gebruik de velden die bij de gekozen actie staan.

## HTTP Request blijft beschikbaar

Wil je zelf de verzoeken opbouwen, dan kun je ook de standaard HTTP Request-node blijven gebruiken. Gebruik Header Auth met naam Authorization en waarde Bearer gevolgd door je servicesleutel. Stel GET in naar je eigen API-basisadres plus /projects?limit=10.

Bij HTTP Request staat een lijst doorgaans onder data; met de volledige response-wrapper kan de body onder body staan. Gebruik de uitvoer van die node als uitgangspunt. De automatische opsplitsing van de MANE-communitynode is hier niet van toepassing.

[Officiële n8n-uitleg: HTTP Request](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/)

## Van test naar dagelijks gebruik

Begin met één leesflow en fictieve dossiers. Test daarna één bedoelde wijziging, een verouderde revisie en het opnieuw aanbieden van dezelfde gebeurtenis. Controleer de opgeslagen uitkomst voordat je een workflow activeert.

De pakketdocumentatie beschrijft lokale mocktests; dat is geen bewijs dat jouw verbinding en workflow zijn getest. De node is zichtbaar geïnstalleerd in een n8n-editor, maar elke eigen werkruimte vraagt haar eigen verbindings- en werkingstest. Houd servicesleutels in credentials en bepaal wie uitvoeringsgegevens kan inzien.

[Lees het verhaal over de MANE-communitynodes](/blog/mane-n8n-community-nodes)

[Versie, gebruik en grenzen op npm](https://www.npmjs.com/package/n8n-nodes-mane/v/0.1.0-beta.2)

# MANE verbinden met Make

Koppel MANE-dossiers met HTTP-verzoeken en maak een scenario dat gecontroleerd reageert op wijzigingen.


## Je eerste verzoek in Make

Gebruik een HTTP-module die een request kan uitvoeren. Stel GET in naar je MANE-basisadres plus /projects?limit=10. Voeg Authorization: Bearer <servicesleutel> toe en laat de JSON-respons uitlezen. Bewaar het geheim in de beveiligde verbindingsinstellingen van je scenario.

Bekijk de ontvangen data-array. Gebruik een iterator als je de dossiers één voor één wilt verwerken. Selecteer de MANE-ID en de velden die jouw volgende stap nodig heeft. Dit is jouw veldmapping; MANE bepaalt niet automatisch welk extern veld bij een cliënt of traject hoort.


## Relaties en eigen velden mappen

Kies in MANE bij Wat spreek je aan? het juiste object. Neem het endpoint en de properties-sleutels letterlijk over. Bij een object contacts kan de route /objects/contacts/records zijn; jouw eigen inrichting is leidend.

Bouw de JSON-body met een JSON-functie of JSON-module zodat aanhalingstekens en regeleinden in klantnamen veilig worden verwerkt. Gebruik properties als genest object. Een checkbox is een boolean, een bedrag een getal en een multiselect een array.


## Van aanvraag naar project

Een mogelijk scenario begint met een formulier en maakt na controle een project aan. Dit is een voorbeeld dat je zelf inricht, geen standaard ingeschakelde flow.

1. Gebruik de aanvraag-ID als externe referentie en controleer of je hem al hebt verwerkt.

2. Zoek de juiste relatie. Vergelijk de externe referentie; beslis bewust wat je doet bij meerdere resultaten.

3. Lees een actuele MANE-revisie.

4. Stuur POST /projects met name en eventueel relation met de bestaande klant-ID.

5. Voeg If-Match en een stabiele Idempotency-Key toe.

6. Bewaar data.id en de externe aanvraag-ID samen; gebruik voortaan die mapping bij updates.


## Meldingen ontvangen met een webhook

Make biedt Custom webhooks als ontvangstpunt. Gebruik het ontvangstadres bij Webhook toevoegen in MANE en kies alleen de benodigde gebeurtenissen. Ontvang eerst een fictieve wijziging om de structuur te controleren.

Controleer vóór verwerking timestamp en HMAC-handtekening over de exacte body. Als jouw Make-inrichting dit niet betrouwbaar kan doen, laat een eigen verificatie-endpoint de melding eerst controleren. Antwoord pas met succes nadat de gebeurtenis duurzaam is aangenomen.

[Officiële Make-uitleg: webhooks](https://help.make.com/webhooks)

[MANE-handtekening en bezorging](/docs/api-webhooks)


## Fouten en dubbele verwerking

Gebruik event-ID’s en je externe referentiemapping om dubbele acties te voorkomen. Een identieke timeout-herhaling gebruikt dezelfde Idempotency-Key, dezelfde body en dezelfde If-Match.

Een 409 vraagt een nieuwe leesstap en beoordeling. Een 429 vraagt wachten; een ongeldige veldwaarde vraagt correctie van je mapping. Laat een scenario niet eindeloos dezelfde ongeldige invoer herhalen. Bekijk in MANE Activiteit welke requeststatus de koppeling terugkreeg.


## Een koppeling onderhouden

Maak een afzonderlijke servicesleutel per scenario of toepassing als je de toegang los wilt beheren. Noteer welke flow welk object en veld gebruikt. Controleer de mapping na een inrichtingwijziging.

Deze route gebruikt Make HTTP en webhooks. Er is geen officiële native MANE-app of automatisch geïnstalleerd Make-template in deze API-versie. Het aantal bewerkingen en de kosten van je scenario horen bij je eigen Make-inrichting.


# Fouten, paginering & veilig herhalen

Voorkom dubbele dossiers en overschreven werk met revisies, idempotentie en herkenbare foutafhandeling.


## Een antwoord begrijpen

Een lijstantwoord heeft data, revision, total, nextCursor en requestId. Een detailantwoord heeft data, revision en requestId. Bij schrijfacties bevat data de aangemaakte of gewijzigde ID, niet automatisch het volledige dossier. Lees dat zo nodig na.

Fouten uit de API gebruiken error.code en error.message plus requestId. Bij bestandsfouten uit de bestaande opslagroute kan error een tekst zijn met een aparte code. Bewaar requestId of de correlatie-ID voor onderzoek, zonder sleutels en complete klantinhoud te loggen.


## Door een lijst bladeren

Gebruik limit tussen 1 en 100; standaard is 50. De eerste cursor is 0. Zolang nextCursor niet null is, haal je de volgende pagina op met die cursor én dezelfde revision. Je blijft daardoor door dezelfde gegevensversie bladeren terwijl het bedrijf verder werkt.

```http

GET /api/v1/projects?limit=50

# Stel: revision = 42 en nextCursor = 50
GET /api/v1/projects?limit=50&cursor=50&revision=42

```


## Zoeken en filteren

De ondersteunde lijstfilters zijn q, status, project, owner en type. q zoekt in naam, titel of nummer; de andere filters vergelijken de opgeslagen waarde exact. Gebruik type bij /records voor een object-ID, of liever de gerichte objectroute. Een onbekend filter geeft een fout.

URL-encode waarden, vooral spaties en veldsleutels met bijzondere tekens. Willekeurige properties-filters, sortering en een algemeen querytaaltje zijn in deze versie niet beschikbaar. Haal voor zo’n selectie de passende lijst op en filter in jouw toepassing.


## Revisie voorkomt overschrijven

Iedere dossierwijziging gebruikt If-Match met de revisie die je hebt gelezen. Wijzigt een collega intussen de werkruimte, dan kan jouw schrijfverzoek 409 teruggeven. Ook een wijziging in een ander dossier kan de werkruimterevisie verhogen.

Lees opnieuw, beoordeel of je voorgenomen wijziging nog klopt en maak vervolgens een nieuwe specifieke schrijfopdracht. Gebruik niet steeds blind de nieuwste revisie met dezelfde zakelijke aanname. De API biedt geen force-write.


## Idempotentie voorkomt dubbel aanmaken

Gebruik bij dossier- en schemawijzigingen een Idempotency-Key van 8–100 tekens met letters, cijfers, punt, liggend streepje, onderstreping of dubbele punt. Kies een vaste sleutel voor één concrete handeling, bijvoorbeeld intake-847-project-aanmaken.

Bij een netwerk-timeout herhaal je exact methode, pad, body, If-Match en Idempotency-Key. Als de wijziging al was opgeslagen, herkent MANE de ontvangstbevestiging en geeft replayed:true terug. Dezelfde sleutel met andere inhoud, route of revisie geeft een conflict.

Gebruik dus een nieuwe sleutel voor een bewust gewijzigde opdracht na een conflict. Bestandsuploads en webhookbeheer gebruiken een andere route en vragen deze headers niet. Uploads herkennen dezelfde bestandsinhoud, naam en MIME-type.


## Veelvoorkomende statuscodes

Status | Betekenis | Volgende stap

--- | --- | ---

400 | Ongeldige JSON, veldwaarde, filter of sleutel. | Lees error en corrigeer de invoer.

401 | Geen geldige, actieve servicesleutel. | Controleer credential, vervaldatum en eigenaar.

403 | Ontbrekende scope of alleen-lezen werkruimte. | Controleer rechten en abonnement; geen automatische retry.

404 | Dossier/route ontbreekt of verkeerde tenant. | Controleer ID, endpoint en basisadres.

405 | Deze methode is niet toegestaan. | Gebruik de route en methode uit de referentie.

409 | Revisie of idempotentiesleutel conflicteert. | Opnieuw lezen en de bedoelde wijziging beoordelen.

413 | Body of bestand te groot. | Verklein het verzoek.

428 | If-Match ontbreekt of is ongeldig. | Lees de revisie en stuur haar mee.

429 | Verzoeklimiet bereikt. | Wacht volgens Retry-After.

5xx | Verzoek kon op de server niet worden afgehandeld. | Beperkt herhalen; een schrijfverzoek identiek herhalen.


## Ontwerp je herstelroute

Beperk gelijktijdige schrijfacties op dezelfde MANE; serialiseer waar mogelijk. Gebruik een eigen wachtrij met maximale retrylimieten. Bekijk mislukte berichten en laat een mens beslissen bij tegenstrijdige gegevens.

Voor gebeurtenissen gebruik je GET /events?after=<laatste-event-id>&limit=100. Bewaar event-ID’s als strings. Deze cursor is een gebeurtenis-ID, niet de numerieke lijstoffset van /projects. Ga verder tot nextCursor null is.


# API-referentie & downloads

Alle routegroepen, methoden, scopes, grenzen en een downloadbare OpenAPI 3.1-specificatie voor MANE API v1.


## Basis en authenticatie

Gebruik het basisadres uit Instellingen → API & webhooks. Alle v1-routes gebruiken Authorization: Bearer <msk_-servicesleutel>. Zet geheimen in een credential store, niet in een openbare website. De API heeft geen algemene browser-CORS-configuratie of cookie-login voor externe toepassingen.

Downloads: /downloads/mane-api-v1.openapi.json bevat de machineleesbare referentie. /downloads/mane-api-handleiding.md bundelt deze API-artikelen in één leesbaar document. Voor je eigen veldinrichting blijft GET /schema leidend.

[OpenAPI 3.1 downloaden (JSON)](/downloads/mane-api-v1.openapi.json)

[Volledige API-handleiding downloaden (Markdown)](/downloads/mane-api-handleiding.md)


## Routegroepen

Route na /api/v1 | Methoden | Recht / bijzonderheid

--- | --- | ---

/workspace | GET | workspace:read

/schema | GET | schema:read; gepagineerde catalogus

/schema/{objectId} | GET, PATCH | schema:read/write; PATCH alleen ingerichte objecten

/objects/{objectId} | GET, POST, PATCH | schema:read/write; POST maakt een nieuw eigen object

/objects/{objectId}/records[/{id}] | GET, POST, PATCH, DELETE | records:read/write of objects.<id>:read/write

/records[/{id}] | GET, POST, PATCH, DELETE | records:read/write; bij POST type meegeven

/projects[/{id}] | GET, POST, PATCH, DELETE | projects:read/write; ook trajecten

/projects/{projectId}/tasks[/{taskId}] | GET, POST, PATCH, DELETE | tasks:read/write

/tasks | GET | tasks:read; lijst met projectId

/relations[/{linkId}] | GET, POST, DELETE | relations:read/write

/files[/{id}] | GET; POST alleen op collectie | files:read/write; detail levert bestand

/events | GET | events:read; after is laatste event-ID

/webhooks[/{id}] | GET, POST, PATCH, DELETE | webhooks:read/write; geen workspace If-Match nodig


## Overige dossierverzamelingen

De volgende collecties ondersteunen GET en POST op de verzameling, en GET, PATCH en DELETE op een record-ID. Gebruik telkens <collectie>:read of <collectie>:write. Beschermde documenten, historische verwijzingen en zakelijke validatie kunnen een wijziging blokkeren.

Collectie | Inhoud

--- | ---

products | Diensten en producten

quotes | Offertes

invoices | Facturen en betaalregistraties

orders | Inkooporders

hours | Urenregistraties

messages | Opgeslagen dossierberichten; geen Gmail-verzendactie

appointments | Planning

segments | Segmenten

stock-moves | Voorraadmutaties

recurring-costs | Terugkerende kosten

catalog-lists | Prijslijsten

team | Teamleden voor planning; geen accounttoegang beheren

availability | Beschikbaarheid

time-off | Vrije dagen

leave-requests | Verlofaanvragen

skills | MAINE-instructies; geen AI-uitvoering


## Dossiers en financiële bescherming

Stuur één dossier per schrijfverzoek. De JSON-limiet is 1 MB. Er is geen bulk- of batchendpoint, PUT of geforceerd opslaan. Gebruik de normale dossieropbouw en controleer referenties op bestaande projecten, relaties en producten.

Een vastgelegde offerte of uitgegeven factuur blijft beschermd. Maak een nieuwe versie of passende correctie via de documentroute in MANE. Een API-verzoek naar invoices is geen banktransactie. Het opslaan van een message verstuurt geen mail. Accountuitnodigingen en gebruikersrechten horen bij Team & rollen, niet bij de team-planningscollectie.


## Bestanden uploaden en gebruiken

POST /files gebruikt JSON met name, mime en contentBase64. Het gedecodeerde bestand is maximaal 15 MB. De upload-JSON heeft een grens van 22 MB. Gebruik bijvoorbeeld PDF voor een factuur; het toegestane bestandstype en de bestandsgrootte worden door de opslagroute gecontroleerd.

De API accepteert via de bestaande bestandscontrole PDF, PNG, JPEG, WebP, tekst, DOCX, XLSX, DWG en DXF. GET /files geeft metadata; GET /files/{id} levert de bestandsinhoud en vraagt een Bearer-token. Een ontvangen relatieve bestands-URL is dus geen openbare downloadlink.

Een gelijke inhoud met dezelfde naam en MIME kan reused:true geven. Het uploaden koppelt het bestand nog niet aan een dossier. Gebruik daarna de passende bijlagenstructuur van het dossier en de normale revisiecontrole. Bestanden via DELETE verwijderen is niet beschikbaar.

```json

{
  "name":"voorbeeld.txt",
  "mime":"text/plain",
  "contentBase64":"Vm9vcmJlZWxk"
}

```


## Webhookbeheer via de API

POST /webhooks gebruikt name, url, events en eventueel enabled. Het antwoord toont signingSecret één keer. GET geeft configuratie en bezorgtellingen terug, zonder het geheim. PATCH accepteert enabled of retryFailed:true. DELETE trekt de webhook in.

Voorbeeld van aanmaken: {"name":"n8n taken","url":"https://jouw-ontvanger.example/webhook","events":["tasks.created"],"enabled":false}. Gebruik een werkelijk publiek HTTPS-adres; het voorbeeldadres is geen geteste bestemming.


## Versie en compatibiliteit

De route is versie v1, de documentatie hoort bij de BETA-uitwerking van 19 oktober 2026. De objectinrichting kan per werkruimte verschillen. Neem daarom een schemacontrole en foutpad op in je koppeling.

De OpenAPI-download beschrijft routes en de gemeenschappelijke structuur. De download is geen SDK en bevat geen geheimen of jouw bedrijfsgegevens. Specifieke eigen velden ontdek je alleen binnen jouw MANE via de veldcatalogus.


## Pakketten en AI-credits

De dossier-API en webhooks horen bij ieder MANE-pakket, inclusief Basic ZZP. Gewone API-verzoeken gebruiken geen MAINE-credits en starten geen AI-generatie. MAINE in je werkruimte is beschikbaar tijdens de proefperiode en daarna vanaf Extended. Extended bevat 1.500 maandcredits, Team en Business 3.000. De keuze voor 1.000 credits verlaagt de pakketprijs met €5 per maand. Nieuw los bijgekochte credits zijn één jaar geldig vanaf bevestigde betaling; bestaande aankopen behouden hun overeengekomen voorwaarden. Zie [prijzen](https://maneworks.com/prijzen) en [pakketten en credits](https://maneworks.com/docs/pakketten-en-pilot).

## Klantbetalingen met je eigen Mollie

Koppel je eigen test- of live-betaalprofiel via Facturen → Mollie koppelen & uitleg. Maak een betaallink bij een definitieve verkoopfactuur en deel die zelf met je klant. Met Betaling controleren haalt MANE de status bij Mollie op en verwerkt een passende bevestigde live betaling één keer. Er is nog geen automatische Mollie-webhookverwerking voor klantfacturen. Deze route staat los van de service keys en algemene MANE API-webhooks. Zie https://maneworks.com/docs/mollie-klantbetalingen.
