API-Dokumentation
Erstellen Sie Whitepage-Websites, verfolgen Sie deren Fortschritt und laden Sie die Dateien aus Ihrem eigenen Code, mit einem No-Code-Tool oder einfach durch Fragen an einen KI-Assistenten herunter. Jede Anfrage ist JSON über HTTPS.
So funktioniert es
Drei Schritte, egal wie Sie sich verbinden:
- Erstellen Sie einen API-Schlüssel Melden Sie sich an, öffnen Sie API-Schlüssel im Dashboard und erstellen Sie einen Schlüssel. Er funktioniert wie ein Passwort für Ihr Konto, also halten Sie ihn privat.
- Fragen Sie eine Website an Senden Sie einen Titel und eine Sprache und falls gewünscht das Thema, die Zielgruppe und Schlüsselwörter. Der Preis für die Generierung wird von Ihrem Guthaben abgezogen und die Website beginnt mit dem Aufbau.
- Sammeln Sie Ihre Website ein Sie ist normalerweise innerhalb von Minuten fertig. Überprüfen Sie den Status oder lassen Sie uns Ihre URL anrufen, wenn sie fertig ist, dann können Sie die Dateien ansehen, bearbeiten und herunterladen.
Wählen Sie, wie Sie sich verbinden
- Ich verwende einen KI-Assistenten Claude, ChatGPT, Cursor und andere können Websites für Sie erstellen und verfolgen.
- Ich schreibe Code Drei REST-Aufrufe, mit Beispielen in curl, PHP, Node.js und Python.
- Ich benutze ein No-Code-Tool Alles, was eine HTTP-Anfrage senden kann, wie Zapier, Make oder n8n, kann dieselben drei Aufrufe ausführen.
No-Code-Tools: Alles, was eine HTTP-Anfrage senden kann (Zapier, Make, n8n, ein Tabellenkalkulationsskript) kann dieselben Aufrufe ausführen. POST /sites startet eine Website; GET /sites/{uuid} in einem Timer oder eine callback_url teilt Ihnen mit, wann sie fertig ist. Legen Sie den API-Schlüssel in den Authorization-Header.
Schlüsselbegriffe
- Website
- Eine erzeugte Website mit allen ihren Seiten. Sie wird durch eine UUID identifiziert.
- Status
- steht aus, während sie gebaut wird; fertig, wenn sie bereit ist; Fehler, falls sie fehlgeschlagen ist. Eine fehlgeschlagene Website wird automatisch erstattet.
- API-Schlüssel
- Ein geheimer String, der beweist, dass eine Anfrage von Ihrem Konto stammt. Erstellen und widerrufen Sie Schlüssel im Dashboard.
- Kontostand
- Vorausbezahltes Guthaben auf Ihrem Konto. Das Erstellen einer Website reserviert den Erzeugungspreis davon.
- Callback
- Eine URL von Ihnen, die wir einmal aufrufen, wenn eine Website fertiggestellt ist, sodass Sie nicht ständig den Status überprüfen müssen.
- Idempotency-Schlüssel
- Ein Label, das Sie einer Anfrage anhängen, damit das zweimalige Senden niemals zwei Websites erzeugt oder in Rechnung stellt.
Verwenden Sie es mit KI-Assistenten
Verbinden Sie einen KI-Assistenten und fragen Sie einfach: „Erstelle eine Website für meine Zahnarztpraxis, auf Türkisch.“ Der Assistent ruft dieselbe API unter Ihrem Konto auf. Sie behalten die Kontrolle: Das Erstellen einer Website kostet Guthaben, und gute Assistenten fragen Sie, bevor sie es tun.
Dinge, die Sie sagen können
- Wie viel Guthaben habe ich und was kostet eine einzelne Website?
- Welche Design-Kits eignen sich für eine Bäckerei?
- Erstellen Sie eine Ein-Seiten-Website für das Alder House, ein ruhiges Gästehaus am Hafen, auf Englisch.
- Ist meine Website bereit? Senden Sie mir den Vorschau-Link.
Über MCP verbinden (Claude, Cursor und mehr)
MCP ist der offene Standard, den Assistenten nutzen, um externe Werkzeuge aufzurufen. Richten Sie Ihren Assistenten auf die MCP-URL und geben Sie Ihren API-Schlüssel als Bearer-Token ein.
Claude Code
bash
claude mcp add --transport http whitepagekit https://whitepagekit.com/api/v1/mcp \
--header "Authorization: Bearer YOUR_API_KEY"Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"whitepagekit": {
"url": "https://whitepagekit.com/api/v1/mcp",
"headers": {
"Authorization": "Bearer ${env:WPK_API_KEY}"
}
}
}
}Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"whitepagekit": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://whitepagekit.com/api/v1/mcp",
"--header", "Authorization:${WPK_AUTH}"],
"env": { "WPK_AUTH": "Bearer YOUR_API_KEY" }
}
}
}Rohes JSON-RPC
curl
curl -X POST https://whitepagekit.com/api/v1/mcp \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_account","arguments":{}}}'Claude Desktop erreicht entfernte Server über die mcp-remote Brücke, die Node.js benötigt.
ChatGPT (kundenspezifisches GPT)
- Erstellen Sie in ChatGPT ein GPT, öffnen Sie Konfigurieren und wählen Sie Neue Aktion erstellen.
- Wählen Sie Importieren von URL und fügen Sie https://whitepagekit.com/api/v1/openapi.json?profile=assistant ein. Dieses abgespeckte Schema enthält nur die sechs Assistenten-Tools.
- Wählen Sie unter Authentifizierung API-Schlüssel, stellen Sie den Authentifizierungstyp auf Bearer und fügen Sie Ihren API-Schlüssel ein.
- ChatGPT bittet Sie, Anfragen zu bestätigen, die etwas ändern, damit Sie die Kontrolle über alles behalten, was Guthaben kostet.
Schema URL
https://whitepagekit.com/api/v1/openapi.json?profile=assistantOpenAI API (MCP-Tool)
Die Responses API kann die MCP-URL als Remote-Tool verwenden. require_approval hält einen Menschen im Entscheidungsprozess.
Python
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="YOUR_MODEL",
tools=[{
"type": "mcp",
"server_label": "whitepagekit",
"server_url": "https://whitepagekit.com/api/v1/mcp",
"headers": {"Authorization": "Bearer YOUR_API_KEY"},
"require_approval": "always",
}],
input="What does one site cost, and which design kits suit a bakery?",
)
print(response.output_text)Ihre eigene Tool-Schleife (Funktionsaufrufe)
Wenn Sie die Modell-Schleife selbst ausführen, holen Sie vorgefertigte Tool-Schemata ab und führen jeden Tool-Aufruf gegen den passenden REST-Endpunkt aus. Formate: openai (Responses API), openai-chat, anthropic und mcp.
curl
curl "https://whitepagekit.com/api/v1/ai-tools?format=openai" # or openai-chat, anthropic, mcpDie sechs Tools
| Werkzeug | Was es macht | REST-Aufruf | Kosten |
|---|---|---|---|
get_account |
Zeigt Ihr Guthaben und was eine Seite kostet. | GET /me |
Kostenlos |
list_languages |
Listet die Sprachen auf, in denen eine Seite geschrieben werden kann. | GET /languages |
Kostenlos |
list_themes |
Durchsucht die Design-Kits nach Thema oder Stil. | GET /themes |
Kostenlos |
create_site |
Beginnt mit der Generierung einer Seite und zieht den Generierungspreis von Ihrem Guthaben ab. | POST /sites |
Verwendet Guthaben |
get_site |
Zeigt eine Seite: Fortschritt, Vorschau-Link und Download-Link. | GET /sites/{uuid} |
Kostenlos |
list_sites |
Listet Ihre Seiten auf, die neuesten zuerst. | GET /sites |
Kostenlos |
Geben Sie diesen Dokumenten eine beliebige KI
Diese Seite ist auch als reines Markdown verfügbar, ideal zum Einfügen in einen Chat oder zur Weitergabe an einen Coding-Assistenten:
Markdown
https://whitepagekit.com/api/v1/docs.mdEin Prompt, den Sie einfügen können
Prompt
You can build websites with the White Page Kit API. Read https://whitepagekit.com/api/v1/docs.md first.
My API key is in the environment variable WPK_API_KEY.
Check my balance and the price, then create a site for my dental clinic in Izmir, in Turkish,
wait until it is ready and send me the preview link.Sicherheit und Kosten
- Nur create_site verbraucht Guthaben. Die anderen fünf Werkzeuge lesen nur.
- Verwenden Sie einen separaten Schlüssel für Assistenten. Geben Sie ihm im Dashboard ein Ablaufdatum und eine Leistungsbegrenzung und widerrufen Sie ihn jederzeit.
- Assistenten können keine Seiten löschen, Einstellungen ändern oder Zahlungen bearbeiten: Diese Routen sind nicht als Werkzeuge verfügbar.
- Setzen Sie idempotency_key bei create_site, damit ein Wiederholungsversuch nie doppelt berechnet wird. Fehlgeschlagene Generierungen werden erstattet.
- Bearbeitungsseiten, Referenzbilder und ZIP-Downloads bleiben in der REST-API und im Dashboard.
Schnellstart
Drei Aufrufe führen Sie von einem Briefing zu einer herunterladbaren Website. Ersetzen Sie YOUR_API_KEY durch einen Schlüssel aus dem Dashboard.
1. Eine Generierung starten
POST /sites validiert Ihr Briefing, reserviert den Generierungspreis von Ihrem Guthaben und gibt sofort eine Antwort zurück.
curl
curl -X POST https://whitepagekit.com/api/v1/sites \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: order-1042-attempt-1" \
-d '{"title":"Alder House","lang":"en","sector":"guesthouse","keywords":"quiet stay, harbour","structure":"onepage"}'Die Antwort ist 202 Accepted mit der neuen Website:
202 Accepted
{
"success": true,
"data": {
"uuid": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"title": "Alder House",
"lang": "en",
"preview_url": null,
"download_url": null
}
}2. Status abfragen
Rufen Sie etwa alle 5–20 Sekunden GET /sites/{uuid} ab, bis der Status done oder error ist, oder verwenden Sie stattdessen eine Callback-URL anstelle des Pollings.
curl
curl https://whitepagekit.com/api/v1/sites/550e8400-e29b-41d4-a716-446655440000 \
-H "X-API-Key: YOUR_API_KEY"3. Die Dateien herunterladen
Eine fertige Website wird als ZIP heruntergeladen. format ist multi oder onepage; assets sind inline oder extern.
curl
curl -o site.zip \
-H "X-API-Key: YOUR_API_KEY" \
"https://whitepagekit.com/api/v1/sites/550e8400-e29b-41d4-a716-446655440000/download?format=multi&assets=inline"Der gleiche Ablauf im Code
PHP
<?php
$ch = curl_init('https://whitepagekit.com/api/v1/sites');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POST => true,
CURLOPT_HTTPHEADER => [
'Authorization: Bearer ' . getenv('WPK_API_KEY'),
'Content-Type: application/json',
'Idempotency-Key: order-1042-attempt-1',
],
CURLOPT_POSTFIELDS => json_encode(['title' => 'Alder House', 'lang' => 'en']),
]);
$site = json_decode(curl_exec($ch), true)['data'];
do {
sleep(5);
$ch = curl_init('https://whitepagekit.com/api/v1/sites/' . $site['uuid']);
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['X-API-Key: ' . getenv('WPK_API_KEY')]]);
$site = json_decode(curl_exec($ch), true)['data'];
} while ($site['status'] === 'pending');Node.js
const headers = {
Authorization: `Bearer ${process.env.WPK_API_KEY}`,
'Content-Type': 'application/json',
'Idempotency-Key': 'order-1042-attempt-1',
};
let { data: site } = await (await fetch('https://whitepagekit.com/api/v1/sites', {
method: 'POST', headers,
body: JSON.stringify({ title: 'Alder House', lang: 'en' }),
})).json();
while (site.status === 'pending') {
await new Promise((r) => setTimeout(r, 5000));
({ data: site } = await (await fetch(`https://whitepagekit.com/api/v1/sites/${site.uuid}`, { headers })).json());
}Python
import os, time, requests
headers = {"Authorization": f"Bearer {os.environ['WPK_API_KEY']}",
"Idempotency-Key": "order-1042-attempt-1"}
site = requests.post("https://whitepagekit.com/api/v1/sites", headers=headers,
json={"title": "Alder House", "lang": "en"}).json()["data"]
while site["status"] == "pending":
time.sleep(5)
site = requests.get(f"https://whitepagekit.com/api/v1/sites/{site['uuid']}", headers=headers).json()["data"]Authentifizierung
Senden Sie bei jeder Anfrage außer dem OpenAPI-Dokument einen API-Schlüssel mit. Bewahren Sie Schlüssel auf Ihrem Server auf; setzen Sie sie niemals in Browser-Code oder URLs.
- Header: Authorization: Bearer YOUR_API_KEY, oder X-API-Key: YOUR_API_KEY.
- Erstellen, widerrufen und begrenzen Sie Schlüssel im Dashboard. Schlüssel können ein Ablaufdatum und eine IP-Whitelist haben.
- Sie sehen nur Ihre eigenen Websites. Eine Website, die einem anderen Konto gehört, gibt 404 not_found zurück.
- Fügen Sie ?lang=xx oder Accept-Language hinzu, um Fehlermeldungen zu lokalisieren.
Idempotenz
Senden Sie Idempotency-Key (8–80 Zeichen: Buchstaben, Ziffern, _ und -) bei POST /sites. Durch die Wiederholung desselben Schlüssels wird die ursprüngliche Website zurückgegeben und nie doppelt berechnet, sodass Wiederholungen nach einem Timeout sicher sind. Verwenden Sie einen neuen Schlüssel, um eine fehlgeschlagene Generierung erneut zu versuchen.
Webhooks (Rückrufe)
Übergeben Sie callback_url an POST /sites (oder richten Sie einen Account-Webhook ein) und erhalten Sie eine JSON-POST, wenn der Auftrag abgeschlossen ist (site.completed) oder fehlschlägt (site.failed).
POST callback_url
{
"event": "site.completed",
"uuid": "550e8400-e29b-41d4-a716-446655440000",
"status": "done",
"site_title": "Alder House",
"lang": "en",
"domain": null,
"created_at": "2026-01-15T09:30:00+00:00",
"preview_url": "https://whitepagekit.com/preview?uuid=550e8400-…"
}Wenn das Konto ein Webhook-Geheimnis hat, trägt jede Anfrage X-Webhook-Signature: sha256=<hex>, eine HMAC-SHA256 des Rohkörpers. Verifizieren Sie es, bevor Sie das JSON parsen, mit einem Vergleich in konstanter Zeit:
PHP
$raw = file_get_contents('php://input');
$expected = 'sha256=' . hash_hmac('sha256', $raw, $webhookSecret);
if (!hash_equals($expected, $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'] ?? '')) {
http_response_code(401);
exit;
}Node.js
import crypto from 'node:crypto';
const expected = 'sha256=' + crypto
.createHmac('sha256', webhookSecret).update(rawBody).digest('hex');
const received = req.get('x-webhook-signature') ?? '';
const ok = received.length === expected.length
&& crypto.timingSafeEqual(Buffer.from(received), Buffer.from(expected));Jeder Callback wird einmal mit einem 10-Sekunden-Timeout versucht und nicht erneut gesendet. Behandeln Sie ihn als Benachrichtigung und gleichen Sie ihn mit GET /sites/{uuid} ab. Wiederholungen idempotent nach uuid und Ereignis behandeln. Private Netzwerkziele werden abgelehnt.
Fehler
Jede Antwort verwendet einen Umschlag. Fehler tragen einen stabilen Code, eine lokalisierte Nachricht und für Validierungsfehler das fehlerhafte Feld.
JSON
{
"success": false,
"error": {
"code": "validation_error",
"message": "...",
"details": { "field": "title" }
}
}| HTTP | Fehlercodes |
|---|---|
| 400 | validation_error, invalid_json, invalid_webhook_url |
| 401 | missing_api_key |
| 402 | insufficient_balance |
| 403 | api_disabled, invalid_api_key, forbidden |
| 404 | not_found, route_not_found |
| 405 | method_not_allowed |
| 409 | site_not_ready, conflict, edits_reset_required |
| 413 | payload_too_large |
| 415 | unsupported_media_type |
| 429 | rate_limited |
| 500 | internal_error, export_failed |
| 502 | generation_failed |
Grenzen
| Limit | Wert |
|---|---|
| Anfragen pro Schlüssel | Standardmäßig 60 pro Minute (konfigurierbar pro Schlüssel, 0 = unbegrenzt). Wiederholt ungültige Schlüssel von einer IP erhalten 429 mit Retry-After. |
| Anfragetext | 2 MB; POST /sites mit Referenzbildern bis zu 162 MB; Editor speichert bis zu 4 MB. |
| Referenzbilder | Bis zu 12 PNG-, JPEG- oder WEBP-Bilder (base64 oder Daten-URL), maximal 10 MB pro Bild. |
| Inhalt der Editor-Seite | HTML bis zu 500.000 Zeichen, CSS bis zu 100.000. Skripte und Ereignis-Handler werden entfernt. |
| Seitenbilder | PNG, JPEG, WEBP oder GIF, jeweils 5 MB, bis zu 200 pro Seite. |
| Seitentitel | Seitentitel 1–200 Zeichen. |
Editor-API
Alles, was der Dashboard-Editor kann, steht für Ihre fertigen Seiten zur Verfügung: Seiteninhalt, Seiten- und Abschnittsplan, Stil, Titel/Thema/Layout/Struktur, Tracking und Bilder. Seitenbearbeitungen ersetzen die Seite; LÖSCHEN stellt die generierte Seite wieder her.
curl
# Load, change and save a page
curl -H "X-API-Key: YOUR_API_KEY" \
"https://whitepagekit.com/api/v1/sites/UUID/editor?page=index"
curl -X PATCH https://whitepagekit.com/api/v1/sites/UUID/editor \
-H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"page":"index","html":"<main>…</main>","css":""}'
# Restore the generated page
curl -X DELETE -H "X-API-Key: YOUR_API_KEY" \
"https://whitepagekit.com/api/v1/sites/UUID/editor?page=index"Die Bearbeitung benötigt eine abgeschlossene Seite (sonst 409 site_not_ready). Das Ändern von Thema, Layout oder Struktur über bearbeiteten Seiten gibt 409 edits_reset_required zurück, es sei denn reset_edits ist true. Die Bearbeitung ist kostenlos.
Endpunkt-Referenz
Generiert aus dem OpenAPI-Dokument, sodass es immer mit der Live-API übereinstimmt. Pfade sind relativ zur Basis-URL.
Konto
-
GET
/meGet the authenticated account
-
GET
/transactionsList account balance transactions
Katalog
-
GET
/languagesList enabled supported languages
-
GET
/themesList site themes
-
GET
/layoutsList enabled layouts
Seiten
-
GET
/sitesList the authenticated account's sites
-
POST
/sitesStart site generation
-
GET
/sites/{uuid}Get site status and refresh generation state
-
DELETE
/sites/{uuid}Delete a terminal site and its generated data — Pending, queued and running generation jobs cannot be deleted. Wait for done or error; active deletion returns 409 conflict without refunding or removing the job.
-
GET
/sites/{uuid}/downloadDownload a completed site archive
KI und Automatisierung
-
GET
/ai-toolsFunction-calling tool schemas — The same six tools the MCP endpoint offers, as JSON schemas for your own tool loop. format is openai (Responses API), openai-chat (Chat Completions), anthropic or mcp. Public; no response envelope.
-
GET
/docs.mdDocumentation as Markdown — The developer guide, endpoint reference and AI integration guide as one Markdown file, written for language models and quick copy-paste. Public.
-
POST
/mcpModel Context Protocol endpoint — MCP over Streamable HTTP (JSON-RPC 2.0, one JSON reply per POST). Methods: initialize, ping, tools/list, tools/call. Tools: get_account, list_languages, list_themes, create_site (paid), get_site, list_sites. Authenticate with the same API key; point an MCP client at this URL.
Editor
-
GET
/sites/{uuid}/editorLoad a page for editing — Editor access for the site owner's API key; mirrors the dashboard editor. Only completed sites (409 site_not_ready otherwise).
-
PATCH
/sites/{uuid}/editorSave a page's edited content — Replaces the page content and CSS. html must be non-empty (use DELETE to restore the generated page); scripts, event handlers and javascript: URLs are removed, HTML is limited to 500000 and CSS to 100000 characters, request body to 4 MB. Returns the saved page as GET does.
-
DELETE
/sites/{uuid}/editorRestore a page's generated content — Discards the page's saved edits. Returns the regenerated page.
-
GET
/sites/{uuid}/editor/canvasGet editing canvas data — Stylesheet, Tailwind theme, body class, direction, section blocks, icons and sample copy an external visual editor needs to render the page like the dashboard editor.
-
GET
/sites/{uuid}/pagesGet the page and section plan — Returns structure, pages with their sections and edited flag, one-page sections and the sections available to add. Same payload as the dashboard.
-
POST
/sites/{uuid}/pagesSave the page and section plan — Body: pages (list of {slug, title, nav, sections}; the first page is index) and, for onepage sites, onepage_sections. Sections of pages with saved edits are locked in the dashboard; edited pages that are removed lose their edits. At most 12 pages.
-
GET
/sites/{uuid}/styleGet style overrides — Returns stored overrides, effective colors, fonts, radius and density, and the allowed font, radius and density values.
-
POST
/sites/{uuid}/styleSave or reset style overrides — Send style ({colors, fonts: {heading, body}, radius, density}) or reset=true to return to the theme.
-
GET
/sites/{uuid}/designGet site title, theme and layout — Returns site_title, title_suggestions, theme_variant, theme_mode, layout, structure and whether the site has saved edits.
-
POST
/sites/{uuid}/designChange site title, theme, mode, layout or structure — theme_variant, theme_mode, layout and structure are required; site_title (1-200 characters), apply_blueprint and reset_edits are optional. Changing theme, layout or structure while pages have saved edits returns 409 edits_reset_required unless reset_edits is true; renaming alone keeps edits.
-
GET
/sites/{uuid}/trackingGet tracking settings
-
POST
/sites/{uuid}/trackingSave tracking settings — Body: tracking {ga4_measurement_id, google_ads_id, google_ads_conversion_label, meta_pixel_id, privacy_policy_url, terms_url}. Applied to exports; an empty object removes all tracking.
-
GET
/sites/{uuid}/mediaList uploaded site images
-
POST
/sites/{uuid}/mediaUpload or delete site images — multipart/form-data with one or more files in files[] (PNG, JPEG, WEBP or GIF, 5 MB each, at most 200 images per site), or JSON {"action": "delete", "name": <name>}. Returns the updated list for uploads. 409 conflict when the per-site image limit is reached.
Externe Zahlungen (nur Administrator-Schlüssel)
-
GET
/payment-sitesList external payment sites owned by the admin API account — Admin role required; payment.manage permission alone is insufficient. Webhook secrets are never returned.
-
POST
/payment-sitesRegister an external payment site (admin only)
-
PATCH
/payment-sites/{id}Update an owned external payment site (admin only)
-
DELETE
/payment-sites/{id}Delete an owned external payment site (admin only) — Deletion is allowed only when the site has no orders. Sites with orders must be disabled instead.
-
GET
/paymentsList external orders owned by the admin API account
-
POST
/paymentsCreate external checkout or automatic subscription (admin only) — Server-to-server only. Separate from wallet top-ups: no White Page Kit balance, bonus or referral credit. Repeated idempotency key returns the original order; a different payload or reused external order ID conflicts. Provider uncertainty never starts a second checkout automatically.
-
GET
/payments/{uuid}Read owned external payment status (admin only)
-
POST
/payments/{uuid}/cancelCancel an owned subscription or locally close a pending one-time order (admin only) — Subscriptions stop future renewals. Pending one-time cancellation is a local close, not a refund; an already-open provider checkout may still accept payment. A late authenticated real payment remains recorded and notified. No payment is marked paid by a browser return.
-
POST
/payments/{uuid}/approveApprove funds received for an owned pending or locally cancelled bank transfer (admin only) — Manual confirmation of funds received, including a transfer arriving after local cancellation; never approves a Dodo or Enigmoss order and never credits White Page Kit balance.
Beschreibungen stammen aus dem OpenAPI-Dokument und sind auf Englisch. Anfrage- und Antwortschemata sind in der Schemadatei.
Bereits fertige Integrationen
Das Integrationskit ist eine kleine PHP-Anwendung mit einem Generatorformular, Statusabfrage, Anleitung zu signierten Callbacks und einem vollwertigen visuellen Editor, der über einen serverseitigen Proxy mit dieser API kommuniziert. Erstellen Sie ein Konto, um einen Schlüssel zu bekommen, und informieren Sie sich anschließend über die Preise für jede Generierung.