Getting Started

OverviewQuickstartArchitecture

API Reference

Idempotent RecordsWebhooksAuth / Keys

SDK

InstallUsage

Guides

IdempotencyWebhook GatewayWebhook ConfigurationObservability DashboardChargeback SimulationOnboarding FlowBackoffice Overview

Examples

PaymentsStripePayPal / BraintreeGeneric HMACShopifyGitHub

Syllecta Documentation

What is Syllecta?

Syllecta is a managed layer between your product and every external service that sends or receives events. Instead of writing bespoke middleware for retries, dedupe, and webhook validation, you point your traffic to Syllecta and focus on product logic. The platform consists of:

  • Syllecta endpoints – /v1/record and /v1/webhooks/:provider APIs that guarantee dedupe, retries, and normalized payloads.
  • Syllecta dashboard – manage API keys, webhook settings, and usage from one place.
  • SDKs & tooling – helper clients plus sample apps that show how to integrate quickly.

Problems We Solve

  • Duplicate writes and race conditions – automatic-scoped idempotency keys prevent double charges, errant emails, and conflicting updates.
  • Untrusted webhooks – Syllecta verifies signatures (Stripe, Shopify, GitHub, generic HMAC) and drops replays before they reach your backend.
  • Blind spots – dashboard views, event logs, and usage counters keep engineers informed without sifting through raw logs.
  • Ops toil – built-in retries, DLQ handling, and normalized payloads reduce the scripting required to keep integrations healthy.

Why Syllecta?

  • Ship faster – you implement /v1/record and /v1/webhooks/:provider once; Syllecta handles retries, caching, and dedupe forever.
  • Confidence at scale – multi-tenant isolation, callback status tracking, and audit trails help teams catch issues before customers do.
  • Observable by default – inspect redacted payloads and headers, filter recent events, and trigger manual retries when delivery fails.
  • Flexible adapters – built-ins for Stripe, PayPal/Braintree, Shopify, GitHub, and a generic HMAC option so niche vendors are covered too.

Common Use Cases

  1. Payments & billing – prevent double-charging and reconcile invoices via reliable webhooks.
  2. Marketplace workflows – coordinate seller/buyer notifications across many providers without rewriting plumbing per integration.
  3. Fintech/ledger apps – guarantee write-once semantics so downstream accounting stays consistent.
  4. Internal platforms – expose a single set of idempotent endpoints to dozens of product teams while keeping governance centralized.

Dashboard & Visual Monitoring

Syllecta ships with a Backoffice dashboard so teams can observe activity without building custom tooling. The UI includes:

  • Overview cards – client, API key, and billable-event summaries, plus health status and top active clients for admin users.
  • Webhook tables – filtered event and simulation views with status badges, payload/headers in a redacted view, and retry controls for eligible events.
  • Tenant views – plan, billing status, API keys, usage counters, and callback configuration for the selected tenant.
  • Audit logs – admin and super-admin timeline of control-plane changes such as key rotation, webhook updates, retries, and simulation lifecycle actions.

All visualizations honor tenant scoping. Admins can see every tenant, while tenant users see only their own traffic, making it safe to share access.

Working with the Dashboard

  1. Log in to the Backoffice UI using your tenant credentials.
  2. Open Dashboard to review high-level counters and current health status.
  3. Use Tenants (or your tenant home page) to review API keys, billing details, and usage counters.
  4. Drill into Webhooks → Events or Webhooks → Simulations to inspect recent deliveries and lifecycle steps.
  5. If you have admin access, use Audit Logs to review control-plane changes and retry actions.

Customers typically keep the dashboard open during rollouts because it provides immediate confirmation that Syllecta is receiving and forwarding events. You can triage provider issues from one place instead of tailing logs across multiple services.

How It Works (at a glance)

  1. Clients send writes to /v1/record with a scope + key pair.
  2. Syllecta checks the scope + key, caches the record, and returns the cached value for duplicates.
  3. Providers (Stripe, Shopify, internal services) send webhooks to /v1/webhooks/:provider or slugged URLs.
  4. Syllecta validates signatures, dedupes, and forwards normalized JSON to the callback you configure in Backoffice.
  5. Dashboards and APIs expose the status of every record/write so operators have a single pane of glass.

Use this page as the entrypoint and refer to:

Architecture Snapshot

Syllecta operates as a managed middle layer between your clients, webhook providers, and backend. A simplified view:

Client App ──> Syllecta (Idempotency API) ──> Your Backend

Webhook Provider ──> Syllecta (Verification & Forwarding) ──> Your Backend

The platform handles hashing, dedupe, retries, and delivery visibility internally.

Internal Links