> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.
# Create Monitoring Event
> Send one login, gameplay, bonus, payment, dispute or security event from your backend to be stored, enriched and scored by your event rules.
Create Monitoring Event API Prompt
Copy prompt to clipboard
\
\`Send one non-monetary monitoring event (login, session, gameplay, bonus, affiliate, payment, dispute, security, responsible gambling or custom) from my backend to Didit.
Endpoint:
POST https://verification.didit.me/v3/events/
Authentication:
Use the x-api-key header with my Didit API key, from my backend only. A scoped key needs transactions: write.
Goal:
\- Record what happened on my platform so Didit's event rules can score it alongside my transactions, and read the verdict from the response.
Request body (application/json):
\{
"event_id": "login-2026-10-17-000001", // required - my id, unique per application, the idempotency key (max 128)
"event_category": "auth", // required - auth, session, gameplay, bonus, affiliate, payment, dispute, security, responsible_gambling, custom
"action_type": "login", // required - what happened inside the category (max 128)
"occurred_at": "2026-10-17T09:15:02.481Z", // required - at most 7 days in the past, 5 minutes in the future
"subject": { "vendor_data": "user-42", "entity_type": "individual" }, // required - entity_type individual (default) or company
"session": { "session_id": "web-session-abc", "sequence": 142 },
"device_context": { "fingerprint": "didit-fp-v2:a8c1", "network_context": { "ip_address": "203.0.113.42" } },
"transaction_context": { "amount": "1000.00", "currency": "EUR", "payment_reference_id": "dep_735" },
"payload": { "method": "password" }, // category fields, max 16 KB
"custom_values": { "vip_tier": "gold" } // max 100 scalar keys
}
Behavior:
\- Validated, stored, IP-enriched and evaluated by the real-time event rules before the response returns. Cross-subject and long-window rules run asynchronously within minutes (correlation_pending: true).
\- Some actions require payload keys, for example gameplay.p2p_settlement (game_id, counterparty_vendor_data, stake_amount, net_result_amount, role, and one of hand_id, round_id, match_id), payment.deposit_completed (payment_reference_id, amount, currency, payment_method, status) and dispute.chargeback_opened (payment_reference_id and one of dispute_id, chargeback_id). transaction_context keys count towards these requirements.
\- Send hashes and references, never a card number, a full withdrawal address, a password hash or an MFA secret.
\- Idempotency: the same event_id with the same event_category, action_type, occurred_at, subject.vendor_data and payload returns 200 with idempotent_replay true and the stored event's result. Different values in those fields return 409; the other fields are not compared. Retry safely on timeouts.
\- The IP address used for enrichment and rules is device_context.network_context.ip_address as you send it.
\- In a sandbox application no rules run: status is ACCEPTED and rules_evaluated_count is 0.
\- The subject resolves to the user (or company) with that vendor_data; one is created when none exists.
\- Event ingestion is opt-in: until it is switched on in Transactions > Settings > Event monitoring, this call returns 403 with code event_monitoring_disabled and stores nothing.
Example call:
curl -X POST "https://verification.didit.me/v3/events/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"event_id":"login-2026-10-17-000001","event_category":"auth","action_type":"login","occurred_at":"2026-10-17T09:15:02.481Z","subject":{"vendor_data":"user-42"},"device_context":{"network_context":{"ip_address":"203.0.113.42"}},"payload":{"method":"password"}}'
What to read from the response:
\- event_uuid - Didit id of the stored event.
\- status - ACCEPTED (stored, no rule changed it), APPROVED, IN_REVIEW or DECLINED.
\- score, rules_evaluated_count, rules_matched_count, rule_matches[] (rule_id, library_key, mode, is_async).
\- correlation_pending - when true, read GET /v3/events/{event_uuid}/ later for the final status.
\- retention_class and expires_at (null for payment and dispute events).
\- idempotent_replay - true when the event was already stored.
Failure modes:
\- 400 - validation error keyed by field (missing field, occurred_at outside the window, payload over 16 KB, nested custom_values, missing required payload keys).
\- 401 - the API key has expired.
\- 403 - missing or invalid API key, a scoped key without transactions: write, or code event_monitoring_disabled.
\- 409 - event_id reused with different content; use a new event_id.
\- 429 - more than 300 writes per minute for this API key; honor Retry-After.
Side effects: stores the event, may create the subject's user or company, and applies the actions of matched active rules (score, status, tags, notes, list entries, cases).
For the full integration shape, see /integration/integration-prompt.`
\
Paste into
> [!NOTE]
>
> Event ingestion is opt-in. Switch it on in **Transactions > Settings > Event monitoring** before you send events; until then this endpoint answers `403` with `"code": "event_monitoring_disabled"`.[Event ingestion](/transaction-monitoring/events.md) covers the envelope, the ten categories, the required payload keys and the retention classes. [Rules on events](/transaction-monitoring/event-rules.md) explains which rules run in the request and which run asynchronously. To send events from a browser or app instead of your backend, use [SDK event submission](/transaction-monitoring/sdk-event-submission.md).
## OpenAPI
````yaml POST /v3/events/
openapi: 3.0.0
info:
version: 3.0.0
title: Didit Verification API
description: Identity verification API. Authenticate with x-api-key header.
servers:
- url: https://verification.didit.me
security: []
tags: []
paths:
/v3/events/:
post:
tags:
- Monitoring Events
summary: Create monitoring event
description: >-
Send one non-monetary event (login, session, gameplay, bonus, affiliate,
payment, dispute, security, responsible gambling or custom) from your
backend. The event is validated against its category contract, stored,
IP-enriched once per unique public address, and evaluated by your
real-time event rules before the response returns; cross-subject and
long-window rules run asynchronously (`correlation_pending: true`), and
in a sandbox application no rules run. `event_id` is the idempotency
key: the same `event_id` with the same `event_category`, `action_type`,
`occurred_at`, `subject.vendor_data` and `payload` returns `200` with
`idempotent_replay: true` and the stored outcome (other envelope fields
are not compared), while different values return `409`. Event ingestion
is opt-in per application: until it is switched on this endpoint returns
`403` with `code: event_monitoring_disabled` and stores nothing. A
scoped API key needs `transactions: write`. See [Event
ingestion](https://docs.didit.me/transaction-monitoring/events) and
[Rules on
events](https://docs.didit.me/transaction-monitoring/event-rules); to
send events from a browser or app, use [SDK event
submission](https://docs.didit.me/transaction-monitoring/sdk-event-submission).
operationId: create_monitoring_event
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/MonitoringEventCreateRequest'
examples:
Login:
value:
event_id: login-2026-10-17-000001
event_category: auth
action_type: login
occurred_at: '2026-10-17T09:15:02.481Z'
time_zone: Europe/Madrid
subject:
vendor_data: user-42
entity_type: individual
session:
session_id: web-session-abc
sequence: 142
device_context:
fingerprint: fp-a8c1
network_context:
ip_address: 203.0.113.42
payload:
method: password
custom_values:
vip_tier: gold
Deposit completed:
value:
event_id: deposit-2026-10-17-000002
event_category: payment
action_type: deposit_completed
occurred_at: '2026-10-17T09:16:40Z'
subject:
vendor_data: user-42
transaction_context:
amount: '100.00'
currency: EUR
direction: inbound
payment_reference_id: dep_736
payload:
payment_method: card
status: completed
Chargeback opened:
value:
event_id: chargeback-2026-10-16-000318
event_category: dispute
action_type: chargeback_opened
occurred_at: '2026-10-16T14:02:11Z'
subject:
vendor_data: user-42
payload:
payment_reference_id: dep_735
chargeback_id: cb_5521
amount: '250.00'
currency: EUR
reason_code: fraud
responses:
'200':
description: >-
Idempotent replay: an event with this `event_id` and the same
content is already stored. Nothing was stored or evaluated again;
the body describes the stored event.
content:
application/json:
schema:
$ref: '#/components/schemas/MonitoringEventIngestResult'
examples:
Replay:
value:
event_uuid: 33333333-4444-5555-6666-777777777777
event_id: login-2026-10-17-000001
status: ACCEPTED
score: 0
rules_evaluated_count: 6
rules_matched_count: 0
correlation_pending: false
retention_class: standard
expires_at: '2026-11-16T09:15:02.481000Z'
idempotent_replay: true
rule_matches: []
'201':
description: The event was stored and evaluated.
content:
application/json:
schema:
$ref: '#/components/schemas/MonitoringEventIngestResult'
examples:
Stored, no rule matched:
value:
event_uuid: 33333333-4444-5555-6666-777777777777
event_id: login-2026-10-17-000001
status: ACCEPTED
score: 0
rules_evaluated_count: 6
rules_matched_count: 0
correlation_pending: false
retention_class: standard
expires_at: '2026-11-16T09:15:02.481000Z'
idempotent_replay: false
rule_matches: []
Rule matched, async rule pending:
value:
event_uuid: 33333333-4444-5555-6666-777777777777
event_id: login-2026-10-17-000001
status: IN_REVIEW
score: 40
rules_evaluated_count: 6
rules_matched_count: 1
correlation_pending: true
retention_class: risk_relevant
expires_at: '2027-01-15T09:15:02.481000Z'
idempotent_replay: false
rule_matches:
- rule_id: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
library_key: null
mode: ACTIVE
is_async: false
'400':
description: >-
Validation failed. The body is keyed by field; nested fields are
nested objects. Nothing is stored.
content:
application/json:
examples:
Missing fields:
value:
event_id:
- This field is required.
subject:
- This field is required.
Unknown category:
value:
event_category:
- '"login" is not a valid choice.'
occurred_at too old:
value:
occurred_at:
- >-
occurred_at is more than 7 days in the past. Use the
batch import lane for backfills.
occurred_at in the future:
value:
occurred_at:
- occurred_at is more than 5 minutes in the future.
Missing subject vendor_data:
value:
subject:
vendor_data:
- This field is required.
Missing required payload keys:
value:
payload:
- >-
payment.deposit_completed requires: payment_method,
status.
Missing one-of payload key:
value:
payload:
- >-
dispute.chargeback_opened requires one of: dispute_id,
chargeback_id.
Security change without changed_field:
value:
payload:
- security.*_changed requires 'changed_field'.
Payload too large:
value:
payload:
- >-
payload exceeds 16384 bytes. Summarise telemetry
client-side.
Too many custom_values:
value:
custom_values:
- custom_values accepts at most 100 keys.
Nested custom value:
value:
custom_values:
- >-
custom_values['limits'] must be a scalar - rule
conditions cannot address nested values.
'401':
description: >-
The scoped API key has expired. Only an expired key gets `401`; a
missing or invalid key gets `403`.
content:
application/json:
examples:
Expired key:
value:
detail: This API key has expired.
'403':
description: >-
Missing or invalid `x-api-key` (this endpoint answers `403`, never
`401`, for a missing or invalid key), a scoped key without
`transactions: write`, a key limited to some workflows or to
approved sessions (such a key never reaches transaction monitoring
data), or a request from outside the key's IP allowlist. Also
returned with `code: event_monitoring_disabled` while event
ingestion is switched off for the application; nothing is stored in
that case, and the check runs before the body is validated.
content:
application/json:
examples:
Event monitoring disabled:
value:
detail: >-
Event monitoring is not enabled for this application. Turn
on event ingestion in the transaction monitoring settings
before submitting events.
code: event_monitoring_disabled
Missing or invalid API key:
value:
detail: You do not have permission to perform this action.
Scoped key without access:
value:
detail: This API key has no write access to transactions.
Key limited to workflows or approved sessions:
value:
detail: >-
This API key only reaches sessions inside its workflow or
status limits, so it can't use this endpoint.
IP not allowed:
value:
detail: This API key can't be used from this IP address.
'409':
description: >-
`event_id` was already used for an event with different content
(category, action type, `occurred_at`, subject `vendor_data` or
payload). Send the event under a new `event_id`.
content:
application/json:
examples:
event_id reused:
value:
event_id: >-
event_id 'login-2026-10-17-000001' already exists with a
different payload.
'429':
description: >-
Rate limit exceeded: write requests (`POST`, `PATCH`, `DELETE`)
share a budget of 300 requests per minute per API key. Wait
`Retry-After` seconds, then retry.
headers:
Retry-After:
description: Seconds to wait before retrying.
schema:
type: integer
minimum: 1
example: 30
content:
application/json:
examples:
Throttled:
value:
detail: >-
Write request rate limit exceeded. You can make up to 300
requests per minute.
security:
- ApiKeyAuth: []
x-codeSamples:
- lang: curl
label: curl
source: |-
curl -X POST 'https://verification.didit.me/v3/events/' \
-H 'x-api-key: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"event_id": "login-2026-10-17-000001",
"event_category": "auth",
"action_type": "login",
"occurred_at": "2026-10-17T09:15:02.481Z",
"subject": {"vendor_data": "user-42", "entity_type": "individual"},
"session": {"session_id": "web-session-abc", "sequence": 142},
"device_context": {
"fingerprint": "fp-a8c1",
"network_context": {"ip_address": "203.0.113.42"}
},
"payload": {"method": "password"}
}'
- lang: python
label: Python
source: >-
import os
import requests
resp = requests.post(
'https://verification.didit.me/v3/events/',
headers={'x-api-key': os.environ['DIDIT_API_KEY']},
json={
'event_id': 'login-2026-10-17-000001',
'event_category': 'auth',
'action_type': 'login',
'occurred_at': '2026-10-17T09:15:02.481Z',
'subject': {'vendor_data': 'user-42', 'entity_type': 'individual'},
'session': {'session_id': 'web-session-abc', 'sequence': 142},
'device_context': {
'fingerprint': 'fp-a8c1',
'network_context': {'ip_address': '203.0.113.42'},
},
'payload': {'method': 'password'},
},
timeout=10,
)
resp.raise_for_status()
result = resp.json()
print(result['event_uuid'], result['status'],
result['idempotent_replay'])
- lang: javascript
label: JavaScript
source: >-
const resp = await fetch('https://verification.didit.me/v3/events/',
{
method: 'POST',
headers: {
'x-api-key': process.env.DIDIT_API_KEY,
'Content-Type': 'application/json',
},
body: JSON.stringify({
event_id: 'login-2026-10-17-000001',
event_category: 'auth',
action_type: 'login',
occurred_at: '2026-10-17T09:15:02.481Z',
subject: { vendor_data: 'user-42', entity_type: 'individual' },
session: { session_id: 'web-session-abc', sequence: 142 },
device_context: {
fingerprint: 'fp-a8c1',
network_context: { ip_address: '203.0.113.42' },
},
payload: { method: 'password' },
}),
});
if (!resp.ok) throw new Error(await resp.text());
const result = await resp.json();
console.log(result.event_uuid, result.status,
result.idempotent_replay);
components:
schemas:
MonitoringEventCreateRequest:
type: object
description: >-
The event envelope, the same for every category. camelCase aliases are
accepted: `eventId`, `eventCategory` (or `category`), `actionType`,
`occurredAt`, `timeZone` (or `zoneId`), `deviceContext` (or `device`),
`transactionContext`, `customValues` (or `props`); inside `subject`:
`vendorData`, `entityType`, `fullName`; inside `session`: `sessionId`,
`pageUrl`; inside `transaction_context`: `paymentReferenceId`.
required:
- event_id
- event_category
- action_type
- occurred_at
- subject
properties:
event_id:
type: string
maxLength: 128
description: >-
Your identifier for the event, unique per application. It is the
idempotency key: resending the same `event_category`, `action_type`,
`occurred_at`, `subject.vendor_data` and `payload` under it is a
replay, anything different is a conflict.
example: login-2026-10-17-000001
event_category:
type: string
enum:
- auth
- session
- gameplay
- bonus
- affiliate
- payment
- dispute
- security
- responsible_gambling
- custom
description: Event category.
example: auth
action_type:
type: string
minLength: 1
maxLength: 128
description: >-
What happened within the category. Open vocabulary; the managed
actions listed in [Event
ingestion](https://docs.didit.me/transaction-monitoring/events) (for
example `login`, `deposit_completed`, `chargeback_opened`) unlock
typed validation and managed rule fields. Leading and trailing
whitespace is trimmed.
example: login
occurred_at:
type: string
format: date-time
description: >-
When the event happened on your side, ISO 8601 (a value without an
offset is read as UTC). Must be no more than 7 days in the past and
no more than 5 minutes in the future.
example: '2026-10-17T09:15:02.481Z'
time_zone:
type: string
nullable: true
maxLength: 64
description: >-
Time zone of the occurrence on your side, for example
`Europe/Madrid`. Stored with the event; not returned by the read
endpoints.
subject:
type: object
description: >-
The user or company the event belongs to. It resolves to the user
(or company) with this `vendor_data` in your application; one is
created when none exists.
required:
- vendor_data
properties:
vendor_data:
type: string
minLength: 1
maxLength: 255
description: Your id for the subject.
example: user-42
entity_type:
type: string
maxLength: 32
default: individual
description: >-
`company` resolves the subject to a company; any other value
(default `individual`) resolves it to an individual. The same
`vendor_data` can name one of each.
example: individual
full_name:
type: string
nullable: true
maxLength: 512
description: >-
Display name, used only when this event creates the user or
company.
email:
type: string
format: email
nullable: true
description: Validated as an email address; not stored on the event.
phone:
type: string
nullable: true
maxLength: 32
description: Validated; not stored on the event.
country:
type: string
nullable: true
maxLength: 3
description: Validated; not stored on the event.
business:
type: object
description: >-
The business the event belongs to, when it differs from the subject.
Only `vendor_data` is read.
additionalProperties: true
properties:
vendor_data:
type: string
maxLength: 255
description: Your id for the business. Filterable as `business_vendor_data`.
example: merchant-7
session:
type: object
description: Your session context for the event.
properties:
session_id:
type: string
nullable: true
maxLength: 255
description: >-
Your session identifier. Filterable and returned as
`session_id`.
sequence:
type: integer
nullable: true
description: >-
Position of the event within the session. Returned as
`session_sequence`.
page_url:
type: string
nullable: true
maxLength: 2048
description: Validated; not stored on the event.
referrer:
type: string
nullable: true
maxLength: 2048
description: Validated; not stored on the event.
device_context:
type: object
additionalProperties: true
description: >-
Device and network context, stored as sent and returned by `GET
/v3/events/{event_uuid}/`. On this server lane Didit does not see
the end user's connection, so the IP enriched and used by rules is
`network_context.ip_address` as you send it.
properties:
fingerprint:
type: string
maxLength: 255
description: Device fingerprint. Filterable as `device_fingerprint`.
persistent_device_id:
type: string
maxLength: 255
description: Your persistent device identifier.
bot_score:
type: integer
description: Bot score from your own detection, as an integer.
network_context:
type: object
additionalProperties: true
properties:
ip_address:
type: string
maxLength: 64
description: >-
End user's IP address. Public addresses are enriched once
per unique address.
example: 203.0.113.42
transaction_context:
type: object
description: >-
Money context. Non-empty values here also satisfy the required
payload keys of the action.
properties:
amount:
type: string
nullable: true
description: Amount as a decimal string (a number is also accepted).
example: '1000.00'
currency:
type: string
nullable: true
maxLength: 10
description: Currency code.
direction:
type: string
nullable: true
maxLength: 16
description: >-
Direction of the money movement, for example `inbound` or
`outbound`.
payment_reference_id:
type: string
nullable: true
maxLength: 255
description: Your payment reference. Filterable as `payment_reference_id`.
payload:
type: object
additionalProperties: true
description: >-
The category's domain fields, at most 16384 bytes once JSON-encoded.
Some actions require keys (in `payload` or `transaction_context`):
`gameplay.p2p_settlement` needs `game_id`,
`counterparty_vendor_data`, `stake_amount`, `net_result_amount`,
`role` and one of `hand_id`, `round_id`, `match_id`;
`gameplay.bet_placed` and `gameplay.bet_settled` need `game_id`;
`payment.deposit_initiated`, `payment.deposit_completed`,
`payment.withdrawal_requested` and `payment.withdrawal_completed`
need `payment_reference_id`, `amount`, `currency`, `payment_method`,
`status`; `payment.withdrawal_address_changed` needs
`withdrawal_address_hash`; `dispute.chargeback_opened`,
`dispute.chargeback_won` and `dispute.chargeback_lost` need
`payment_reference_id` and one of `dispute_id`, `chargeback_id`;
`session.bot_signal_observed` needs `telemetry_schema_version` and
one of `bot_score`, `actions_per_minute`, `timing_variance_ms`,
`pointer_entropy`, `keystroke_entropy`, `reaction_time_ms_p50`;
`responsible_gambling.self_exclusion_match` needs `registry_source`,
`exclusion_status`, `identity_match_ref`. Every `security` action
ending in `_changed` needs `changed_field`, plus
`previous_reference_hash` or `new_reference_hash` when the field is
`password`, `mfa_method`, `mfa`, `email`, `phone`,
`withdrawal_address`, `payout_method` or `api_key`. Send hashes and
references, never a card number, a full withdrawal address, a
password hash or an MFA secret.
custom_values:
type: object
description: >-
Up to 100 keys of your own, addressable from rules as
`custom_values.`. Values must be scalars (string, number,
boolean or null); nested objects and arrays are rejected.
additionalProperties:
nullable: true
oneOf:
- type: string
- type: number
- type: boolean
example:
event_id: login-2026-10-17-000001
event_category: auth
action_type: login
occurred_at: '2026-10-17T09:15:02.481Z'
time_zone: Europe/Madrid
subject:
vendor_data: user-42
entity_type: individual
session:
session_id: web-session-abc
sequence: 142
device_context:
fingerprint: fp-a8c1
network_context:
ip_address: 203.0.113.42
payload:
method: password
custom_values:
vip_tier: gold
MonitoringEventIngestResult:
type: object
description: >-
Outcome of ingesting one event. The same shape is returned for a new
event and for an idempotent replay.
required:
- event_uuid
- event_id
- status
- score
- rules_evaluated_count
- rules_matched_count
- correlation_pending
- retention_class
- expires_at
- idempotent_replay
- rule_matches
properties:
event_uuid:
type: string
format: uuid
description: Didit identifier of the stored event.
event_id:
type: string
description: Your `event_id`.
status:
type: string
enum:
- ACCEPTED
- APPROVED
- IN_REVIEW
- DECLINED
description: Status after the real-time rules ran. See `MonitoringEvent.status`.
score:
type: integer
description: Score after the real-time rules ran.
rules_evaluated_count:
type: integer
minimum: 0
description: >-
Number of event rules evaluated in the request. 0 in a sandbox
application, where no rules run.
rules_matched_count:
type: integer
minimum: 0
description: Number of rules that matched, including `TEST` mode rules.
correlation_pending:
type: boolean
description: >-
`true` when an asynchronous rule still has to run. Read `GET
/v3/events/{event_uuid}/` a few minutes later for the final `status`
and `score`.
retention_class:
type: string
enum:
- low_value
- standard
- risk_relevant
- monetary_or_compliance
description: Retention class, after any promotion by a matched rule.
expires_at:
type: string
format: date-time
nullable: true
description: >-
When the event expires under its retention class and is deleted.
Null for `monetary_or_compliance` (payment and dispute) events.
idempotent_replay:
type: boolean
description: >-
`true` when an event with this `event_id` and the same content was
already stored; the values are those of the stored event and no rule
ran again.
rule_matches:
type: array
description: Rules that matched the event.
items:
type: object
required:
- rule_id
- library_key
- mode
- is_async
properties:
rule_id:
type: string
format: uuid
description: UUID of the rule.
library_key:
type: string
nullable: true
description: >-
Library key when the rule was installed from the rules
library, otherwise null.
mode:
type: string
enum:
- ACTIVE
- TEST
description: '`TEST` rules record the match but apply no actions.'
is_async:
type: boolean
description: '`true` when the match came from the asynchronous pass.'
securitySchemes:
ApiKeyAuth:
type: apiKey
in: header
name: x-api-key
description: >-
Your application's API key, from Developers -> API keys in the Business
Console. The primary key has full access. A named key can be scoped:
none, read or write per resource, limited to some workflows or to
approved sessions, to a list of IP addresses, and to an expiry date. 401
means the key is missing, wrong, revoked or expired; 403 means the key
has no access to this resource or action, or the request came from an
address outside its IP list; 404 on a session route means the session is
outside the key's workflows or statuses. A key without media access
receives image, video and PDF URLs as null, and a key without sessions
write receives session links and tokens as null. See
https://docs.didit.me/console/api-keys.
````
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.