Integrate Console

Connect everything.
Sync anything.

A marketplace of native integrations you connect in one click, an OAuth connections control plane that never lets a token die, every payment processor with inline checkout, and a visual webhook designer that routes any event anywhere. Plus a public API and a partner program to put your own app on the shelf. The whole integration layer, built in, not bolted on.

★ ★ ★ ★ ★ Teams who replaced 5+ point tools and an iPaaS bill with one connected platform
#
integrations
5 members · 4 online
Reply…
Integration sync · 4 on
EM E. Mor
DV D. Vex
AK A. Kerr
webhook-designer · shared
Marketplace · Integrate

Every tool you run, one click from connected.

Payments, accounting, email, comms, social, and AI providers all live in one marketplace inside Ligna. Browse by category, connect with managed OAuth, and start using the integration the second the handshake completes. No glue code, no middleman, no third-party automation tax · the connectors are native to the platform.

Categories 24+ integrations
Payments5 Accounting1 Email7 Comms3 Social4 AI4
6 categories Search the shelf

Find the integration by category, not by guesswork.

The marketplace groups every connector the way your team thinks · Payments, Accounting, Email, Comms, Social, and AI providers. Filter chips narrow the grid instantly, and a search box matches on provider name. Every tile shows live connection status so you always know what is wired up and what is waiting.

  • 6 categories spanning 24+ named providers
  • Live status on every tile: Connected, Available, or Action needed
  • Search by provider name, filter by category chip
  • One shelf for the whole account, scoped per workspace
S
Connect Stripe
Managed OAuth · no keys to copy
Secure
initiate · redirect to provider callback · token exchanged for you verify · test ping in progress
Managed OAuth Verified on connect

Click connect. We handle the handshake.

For OAuth providers, Ligna runs the whole flow · /api/connect/{provider}/initiate bounces the user to the provider, the callback exchanges the code for tokens, and a verify ping confirms the connection is live before you ever see it. No client secrets pasted into forms, no copy-paste of long-lived keys. Key-based providers get a guided form with the same verify step.

  • Universal contract: initiate, callback, verify on every connector
  • Tokens stored securely on our side, refreshed automatically
  • Verify ping confirms health before the connection goes live
  • Reconnect in one click when a provider revokes access
Stripe connection Collect billing profile
Twilio connection Comms console SMS
Claude connection AI agent runtime
First-party Wired into consoles

Connectors that feed the rest of Ligna.

These are not webhooks pointed at a third-party automation service. A connected provider feeds the actual consoles · a Stripe connection becomes a billing profile in Collect, a Twilio connection powers SMS in Comms, an AI model connection drives the AI agent runtime. The same connect framework is the plumbing across every provider family.

  • Each billing profile picks its own connection
  • Social, email, comms, and AI all draw from the same connection store
  • Connection errors surface in a raw debug log for fast diagnosis
  • Multiple connections per provider for multi-brand accounts
P
Submit your app
Partner program review
In review
client_idapp_7f4a•••• client_secret•••••••• ModePlatform
Partner program Ship to the shelf

Build an app, list it in the marketplace.

Register your own OAuth app, submit your app's credentials (client ID and secret), and put it through app review to appear on the shelf. Switch it to Platform mode and your registered app powers connect flows for every child account underneath you · a white-label catalog your customers see as part of your brand, not ours.

  • Submit your app's credentials through guided app review
  • Define provider modes in your manifest, not hard-coded
  • Platform mode drives child-account onboarding
  • Your app, your brand, on the marketplace shelf
One shelf, every tool

Payments, email, comms, social, and AI providers all live in a single marketplace.

One-click connect

Managed OAuth runs the handshake so you never paste a client secret into a form.

Native connectors

Connections feed the real consoles, not a third-party automation middleman.

Verified on connect

A test ping confirms health before any connection is marked live.

Browse by category

Filter chips and search narrow 24+ providers down in a second.

List your own app

Build a partner app and ship it to the marketplace shelf with app review.

App library

Search the shelf, connect in seconds.

A searchable library of 24+ named integrations. Filter by category, scan connection status at a glance, and connect the ones your stack needs. Every tile is a real provider you can wire up today from the Integrations console.

app.ligna.io/integrate/marketplace 24+ integrations
Search 24+ integrations…
All Payments Email Comms Social AI Accounting
S Stripe Connected
P PayPal Connected
S Square Available
A Authorize.Net Action needed
Q QuickBooks Connected
S SendGrid Connected
M Mailgun Available
M Mailjet Available
S SparkPost Available
G Gmail Connected
O Outlook Connected
S SMTP Available
T Twilio Connected
P Plivo Available
Z Zoom Available
F Facebook Connected
I Instagram Available
L LinkedIn Action needed
X X Available
C ChatGPT Connected
C Claude Connected
G Gemini Available
G Grok Available
B Black Forest Labs Available
Search & filter

Type a provider name or tap a category chip to narrow the grid instantly.

Status at a glance

Connected, Available, or Action needed shows on every tile, color-coded.

24+ providers

The full shelf in one responsive grid, scoped to your account.

Category chips

Payments, Email, Comms, Social, AI, and Accounting in one tap.

Action surfaced

Reconnect prompts appear the moment a provider needs attention.

Connect from the tile

Start the connect flow without leaving the marketplace grid.

Connect flow

Pick an app, authorize, done.

Every connector follows one contract · initiate, callback, verify. Choose managed OAuth or an API key, authorize once, and the connection lands healthy. The same flow works whether you are wiring Stripe, Twilio, or an AI provider.

Step 1 Pick an app
S
Stripe
Payments
Selected from the marketplace
Step 2 Choose connect mode OAuth managed API key
Step 3 Authorize
initiate callback verify
No secret typed by hand
Step 4 Connected Healthy Verify ping passed · token stored Ready in Collect & consoles
Pick from the shelf

Start a connection straight from any marketplace tile in one tap.

OAuth or API key

Managed OAuth where it exists, a guided key form where it does not.

One contract

initiate, callback, verify on every provider, so the flow never surprises you.

Verified before live

A test ping confirms health, so a connection is never half-wired.

Secrets stay hidden

Tokens are stored securely on our side, never shown back to the user.

One-click reconnect

When a provider revokes access, restore the connection without losing config.

Categories

Six shelves, every workflow covered.

From taking payments to sending email to driving AI agents, the marketplace organizes 24+ providers into the categories your stack actually maps to. Tap a shelf to see the providers, connect the ones you need.

Payments 5
Stripe PayPal Square Authorize.Net QuickBooks
Accounting 1
QuickBooks Ledger sync Invoices
Email + Comms 10
SendGrid Mailgun Gmail Twilio Zoom
Social 4
Facebook Instagram LinkedIn X
AI providers 4
ChatGPT Claude Gemini Grok
Ads / CRM 3
Facebook LinkedIn X
Six clear shelves

Providers grouped the way your stack maps, not by alphabet soup.

5 payment rails

Stripe, PayPal, Square, Authorize.Net, and QuickBooks under one shelf.

Email + comms

SendGrid, Mailgun, Gmail, Twilio, Zoom, and more in one place.

Social ready

Facebook, Instagram, LinkedIn, and X for posting and ads.

Four AI providers

ChatGPT, Claude, Gemini, and Grok power the agent runtime.

Ads & CRM reach

The same social connections drive ad and CRM workflows.

Partner apps

Build an app, power your whole tenant base.

Register your own OAuth app, put it through review, and embed a white-label connect portal your customers use. Switch it to Platform mode and your registered app drives connect flows for every child account beneath you.

app.ligna.io/integrate/partner Platform mode
Submit your app In review
client_idapp_7f4a•••• client_secret•••••••• ModesOAuth, Platform App review confirms scopes and redirect URIs before listing.
Embedded connect portal White-label
Your customers see your brand, not ours.
S Stripe T Twilio S SendGrid C ChatGPT
Your registered app powers every child-account onboarding.
Ship to the shelf

Submit your app's credentials, pass review, and list your app.

Embedded portal

A white-label connect catalog your own customers use as part of your brand.

Platform mode

Platform mode drives connect flows for every child account beneath you.

Reviewed app

App review verifies scopes and redirect URIs before anything goes live.

Manifest modes

Declare provider modes in your manifest, not in hard-coded branches.

Onboard at scale

One registered OAuth app onboards your entire tenant base in one click.

Connections · Integrate

Connections that never quietly die.

We own the OAuth dance, store credentials AES-256 encrypted, and refresh tokens hourly before they expire. Connect many accounts to one app, cascade access down to sub-accounts on your terms, and watch a single control plane keep every link verified. The connection is the spine · every processor, webhook, and sync hangs off it.

app.ligna.io / integrate / connections Integrate · Live
S Connected
Stripe · Acme Live OAuth · refreshed 41m ago
Cascade: Brand verified 2m ago
P Connected
PayPal · Acme OAuth · refreshed 18m ago
Cascade: Inherit verified 6m ago
T Token expiring
Twilio · Outbound SMS API key · rotates in 2d
Cascade: Per-account verified 22m ago
F Connected
Facebook · Pages OAuth · refreshed 9m ago
Cascade: Brand verified 9m ago
Q Error
QuickBooks · Finance OAuth · reconnect required
Cascade: Off scope revoked
G Connected
SendGrid · Transactional API key · verified hourly
Cascade: Inherit verified 1m ago
1 – 6 of 11 connections
1 / 2
S
Stripe · Acme Live Mode: Live · Provider: Stripe
Authorized
1Redirect to provider consent screen
2Exchange code for access + refresh token
3AES-256 encrypt, store on the connection
Live · AES-256 sealed
Managed dance AES-256 sealed

We own the auth dance. You click once.

Managed OAuth means you never see a consent URL, a code exchange, or a refresh-token rotation. You click Connect, approve on the provider, and land back with a sealed connection. Credentials get AES-256 encrypted the moment they arrive, so a database dump is worthless without the key.

  • Full OAuth handshake handled server-side, no code to write
  • Access and refresh tokens AES-256 encrypted at rest
  • Least-privilege scopes requested per provider
  • One friendly error if consent is declined, never a stack trace
S Stripe 3 connections · one app
live Acme Live Provider: Stripe
sandbox Acme Sandbox Environment differs
live Nordic Merchant second account
Separated by account, app, and environment
Many accounts One provider

Run live and sandbox. Run two merchants. One app.

The same provider can hold as many connections as you need. Each connection is identified by account, app, and environment, so a live Stripe, a sandbox Stripe, and a second merchant account live side by side without colliding. Every billing profile picks the connection it bills through.

  • Unlimited connections per provider, no upgrade tier
  • live and sandbox on the same shelf
  • Each subscription or webhook pins its own connection
  • Disconnect one without touching the others
Token refresh cron Hourly
02:14 until expiry
access_token rotated refreshed at 14:00 · next sweep 15:00

We refresh tokens before they expire, so you never reconnect. The cron sweeps every connection hourly and rotates anything nearing its window.

Refreshed hourly Never expires

Tokens that refresh themselves. Hourly.

An OAuth token left alone dies, and a dead token silently breaks a sync at 2am. A token refresh cron sweeps every connection on the hour and rotates anything approaching its expiry window. You set the connection once and it stays alive for years without a single reconnect prompt.

  • Hourly cron rotates refresh tokens before they expire
  • Rotation logged per connection for the audit trail
  • Connections nearing expiry flagged in the list before they break
  • A failed refresh raises one alert, not a flood of broken syncs
Cascade Mode
InheritSub-accounts use this connection BrandShared as the parent brand Per-accountEach child connects its own OffParent only, never shared
Currently set to Inherit · 4 sub-accounts covered
Cascade access Per-account scoped

Decide exactly which sub-accounts get the connection.

Cascade Mode controls how a connection flows down your account tree. Inherit hands it to every sub-account, Brand shares it under the parent brand, Per-account makes each child connect its own, and Off keeps it locked to the parent. One setting, total control over reach.

  • Four modes: Inherit, Brand, Per-account, Off
  • Change the mode and the tree re-resolves instantly
  • Per-account keeps a child's credentials fully isolated
  • Off means a connection never leaves the parent workspace
Managed OAuth

We run the full handshake server-side, so you click Connect and the link is live.

Many accounts, one app

Live, sandbox, and a second merchant all coexist under the same provider.

Tokens never die

An hourly cron rotates refresh tokens before they expire, so syncs never break at 2am.

Cascade on your terms

Inherit, brand, per-account, or off · you choose how far each connection reaches.

AES-256 at rest

Every credential is sealed with AES-256, so a database dump reveals nothing.

Health you can see

One control plane keeps every link verified and flags trouble before it bites.

Connection manager

Run one connection, or a hundred accounts.

Verify every link in one sweep, reconnect a stale provider, disconnect a sandbox, and watch health across the whole shelf. The same browser-chrome list view powers every console list in Ligna · your team learns it once.

S
Stripe · Acme Live Stripe · Acme Live · live
Payments Connected 2m agoverified
P
PayPal · Acme PayPal · Acme · live
Payments Connected 6m agoverified
T
Twilio · Outbound SMS Twilio · Outbound SMS · live
Messaging Token expiring 22m agorotates 2d
F
Facebook · Pages Facebook · Pages · live
Social Connected 9m agoverified
Q
QuickBooks · Finance QuickBooks · Finance · live Reconnect
Accounting Error —scope revoked
G
SendGrid · Transactional SendGrid · Transactional · live
Email Connected 1m agoverified
2 selected
Bulk verify

Ping every provider in one sweep and surface auth errors instantly.

One-click reconnect

Re-run the managed OAuth dance on a stale link, no copy-paste keys.

Health at a glance

Connected, token expiring, error, off · the whole shelf in one view.

Clean disconnect

Trash one connection without touching the others on the provider.

Search the shelf

Filter by provider, category, or cascade mode across a hundred accounts at once.

Learn it once

The same browser-chrome list powers every console list in Ligna.

Managed OAuth

Set it once. It stays alive for years.

The hard part of any integration is not the first connect, it's the silent token death three weeks later. We run the OAuth dance, encrypt the result, and refresh it hourly. One provider can hold a live account, a sandbox, and a second merchant · each its own row, each refreshed on its own clock.

app.ligna.io / integrate / connections / stripe Managed OAuth
S
Stripe · Acme Live Mode: Live · Scope: charges, customers
Connected
access_token
sk_live_••••••••••••••••••••
52:18 until expiry
Auto-refresh armed Next hourly sweep rotates it well before zero
Token refresh cron · hourly

We refresh tokens before they expire, you never reconnect. Every connection is swept on the hour and any token nearing its window is rotated and re-sealed.

Stripe · 3 connections, one app
live Stripe Live refreshed 12m ago
sandbox Stripe Sandbox refreshed 12m ago
live Nordic Merchant refreshed 12m ago
One click to connect

Approve on the provider and land back with a sealed, working connection.

Hourly refresh

The cron rotates every token before its window closes, so nothing silently dies.

Live + sandbox + more

One provider holds a live account, a sandbox, and a second merchant at once.

Sealed at rest

AES-256 encryption seals each token the moment it arrives.

One alert, not a flood

A failed refresh raises a single notice instead of a wall of broken syncs.

Years of uptime

Set the connection once and the refresh loop keeps it healthy indefinitely.

Cascade access

One connection, exactly the reach you want.

A connection on the parent account can flow all the way down your tree, share under the parent brand, leave each child to connect its own, or stay locked to the parent. Pick the Cascade Mode and the preview shows precisely which sub-accounts inherit the link.

Cascade Mode
Stripe · Acme Live · how do sub-accounts get this connection?
Who gets it under Inherit 4 of 4 covered
A Acme Outreach parent · owns link
N Nordic Region Inherited
W West Team Inherited
R Retail Brand Inherited
S SaaS Portfolio Inherited
Switch to Per-account and every check flips to "connects its own"; switch to Off and the tree empties.
Inherit covers all

One parent connection serves every sub-account with nothing to re-set up.

Brand the share

Push the link down while keeping the parent brand identity in front of customers.

Per-account isolation

Each child connects its own account, so credentials never cross workspaces.

Off keeps it private

Lock a sensitive connection to the parent so it never reaches a sub-account.

Preview before you commit

See exactly which accounts gain access the moment you change the mode.

Re-resolves instantly

Change Cascade Mode and the whole tree recomputes access with no redeploy.

Secrets vault

Credentials sealed, scoped, and out of sight.

Every API key, secret, OAuth token, and webhook signing secret lives encrypted at rest, masked in the UI, and rotatable in one click. Each connection requests least-privilege OAuth scopes · only the access it actually needs, nothing more.

Stripe · Acme Live AES-256 encrypted at rest
API key sk_live_••••••••••••••4f8a
Client secret ••••••••••••••••••••
OAuth token rt_•••••••••••••••• · auto-refreshed
Webhook secret whsec_••••••••••••••••
OAuth scopes · least privilege Only the access this connection needs, nothing more.
read_write:charges read_write:customers read:subscriptions read:balance · not requested write:payouts · not requested
Per-connection permissions

Each connection carries its own scope set and its own access boundary. Revoke a scope, rotate a secret, or disconnect entirely without touching any other link on the provider.

Masked by default

Secrets show dotted in the UI · reveal is a deliberate click, not the resting state.

AES-256 at rest

AES-256 seals every credential so a database dump leaks nothing usable.

One-click rotate

Rotate any key, secret, or token the instant a credential is exposed.

Least-privilege scopes

Each connection requests only the OAuth access it needs and nothing it does not.

Per-connection boundary

Every link has its own scope set, so revoking one never weakens another.

Signing secrets vaulted

Webhook secrets sit in the same encrypted store, masked and rotatable like the rest.

Payments · Integrate

Five processors, one checkout to wire.

Stripe, PayPal, Square, Authorize.Net, and QuickBooks each connect natively · OAuth or API key, inline card fields with no redirect, native or platform-managed subscriptions, and money that flows straight back into one ledger. Every billing profile picks its own connection, so one tenant can run many processors at once.

Connected processors · one unified ledger
Stripe PayPal Sq Square A Authorize.Net Q QuickBooks
StripeOAuth Connect or restricted key
Connected
PayPalClient ID + secret
Connected
Sq
SquareOAuth merchant authorize
Connected
A
Authorize.NetAPI login ID + transaction key
Connected
Q
QuickBooksOAuth + realm ID
Connected
OAuth or key One test ping

Five acquirers, one auth flow.

Stripe, Square, and QuickBooks connect over OAuth · PayPal and Authorize.Net take API credentials. Either way the connection lands in the same place, gets a one-click test ping, and becomes selectable by any billing profile. Run one processor or all five side by side.

  • OAuth: Stripe Connect, Square merchant authorize, QuickBooks realm
  • API key: PayPal client ID + secret, Authorize.Net login + transaction key
  • Multi-connection · each profile picks its own
  • Live health checks with a one-click test ping per connection
Pay $149.00 PCI scope zero
Stripe Payment Element Square Web Payments SDK PayPal ACDC fields Authorize.Net Accept.js QuickBooks tokenize
Inline SDKs No redirect

Card fields in your page, no redirect.

The card form renders right in your checkout, tokenized client-side by each processor's own inline SDK. The raw PAN never touches your server · you receive only an opaque token. Stripe Payment Element, Square Web Payments SDK, PayPal ACDC card fields, Authorize.Net Accept.js, and QuickBooks server-side tokenize all funnel into one normalized charge.

  • Stripe Payment Element · PaymentIntent confirmed inline
  • Square Web Payments SDK + PayPal ACDC card fields
  • Authorize.Net Accept.js returns opaque data, never the PAN
  • PCI scope stays at zero · you store a token, not a card
Subscription engine per processor
Stripe Native schedule
PayPal · Billing v1 Native schedule
Sq Square Native schedule
A Authorize.Net · ARB Native ARB
Q QuickBooks Platform-managed
Native schedules We run the cron

The processor's schedule, or ours.

Where the acquirer holds a real subscription object, we drive it natively · Stripe subscriptions, PayPal Billing v1 plans, Square subscriptions, and Authorize.Net ARB. Where it does not, we own the schedule ourselves: QuickBooks renewals run on our platform-managed cron, charging the Payments API on cycle. Same console, same lifecycle events, either way.

  • Native: Stripe subs, PayPal Billing v1, Square subs, Auth.Net ARB
  • Platform-managed: QuickBooks renewals on our renewal cron
  • Uniform pause / resume / cancel across every processor
  • One subscription state model regardless of who holds the timer
Money flowing in · last sync 2m ago
Invoice INV-2048 Stripe $149.00
Payout PO-7714 PayPal $3,204.18
Refund RF-0091 Square −$49.00
Reconciled 412 / 412 matched
Auto-sync Reconciled

Invoices, payouts, reconciliation.

Every captured charge, refund, payout, and dispute flows back into one ledger, signed and deduped by webhook so a double-fire never double-counts. QuickBooks invoices sync both ways. The reconciliation view matches payouts to the invoices that funded them, so month-end close is one report instead of five.

  • Webhook-signed events, idempotent on event ID
  • Payouts matched to the invoices that fund them
  • QuickBooks two-way invoice sync
  • One ledger across all five acquirers
Native, not bolted on

Each processor has a first-class connector · no middleman vault, no extra fees.

Inline checkout

Card fields render in your page, tokenized by the processor's own SDK.

PCI scope zero

You hold an opaque token, never a card number, on every processor.

Subscriptions either way

Native where the acquirer holds the schedule, platform-managed where it does not.

Many connections

Each billing profile binds its own connection.

One reconciled ledger

Five acquirers settle into a single ledger, so close is one report.

Connect

Connect once, charge anywhere.

Each processor connects through its own canonical handshake · OAuth where the acquirer offers it, API credentials where it does not. Health-check every connection with a test ping, then let any billing profile select it. One tenant, many live connections.

app.ligna.io / integrate / payments / connections Integrate · Live
Stripe OAuth Connect
Healthy
One-time Subscriptions Refunds Disputes
PayPal API key
Healthy
One-time Subscriptions Refunds Disputes
Sq
Square OAuth
Healthy
One-time Subscriptions Refunds Card-on-file
A
Authorize.Net API key
Healthy
One-time ARB subscriptions Refunds CIM vault
Q
QuickBooks OAuth
Healthy
One-time Managed renewals Refunds Invoice sync
Add a connection Run a second Stripe or PayPal per brand or region.
OAuth where it counts

Stripe, Square, and QuickBooks connect with a click · no key-pasting.

Keys when needed

PayPal and Authorize.Net take credentials, encrypted at rest.

Test before live

A one-click ping verifies each connection and surfaces auth errors instantly.

Many connections

Run a second Stripe or PayPal per brand · each profile binds its own.

Continuous health

Connection status is monitored, so a dead token surfaces before a charge fails.

Capability at a glance

Every card shows what it supports · one-time, subscriptions, refunds, vault.

Inline checkout

Card fields in your page, scope at zero.

Every processor mounts its own inline SDK so the card form renders right in your checkout · no hosted redirect, no pop-up. The PAN is tokenized client-side and never touches your server. Vault the result for one-click repeat charges.

Acme Pro · Annual$149.00 / year
PCI scope zero
Save this card on file · vault for repeat charges
Inline tech, per processor
StripePayment Element · PaymentIntent confirmed inline
Sq
SquareWeb Payments SDK · tokenize then charge
PayPalACDC card fields · Orders v2 capture
A
Authorize.NetAccept.js · returns opaque data, never the PAN
Q
QuickBooksServer-side tokenize · Payments API v4
Card-on-file vaults the token · Stripe customers, Square card-on-file, Authorize.Net CIM, PayPal vault · so renewals and one-click repeats never re-prompt the buyer.
No redirect

The card form renders in your checkout · the buyer never leaves your page.

PCI scope zero

The PAN is tokenized client-side · your server only ever sees a token.

Payment Element

Stripe confirms the PaymentIntent inline with native 3DS where required.

Accept.js + ACDC

Authorize.Net opaque data and PayPal ACDC card fields, both inline.

Card on file

Vault the token in CIM, Square, or Stripe for one-click repeat charges.

Your styling

The inline fields inherit your checkout's look, not a generic hosted page.

Subscriptions & sync

Native where it can, managed where it must.

Where the acquirer holds a real subscription object we drive it natively · where it does not, we own the renewal cron. Pick the mode per processor, route each profile to its own connection, and watch invoices, payouts, and refunds flow back into one reconciled ledger.

Subscription mode
Native · the processor holds the schedule
Stripe subscriptions PayPal Billing v1 Square subscriptions Authorize.Net ARB
Platform-managed · we run the renewal cron
QuickBooks renewals Authorize.Net fallback
Our cron charges the Payments API on cycle, retries on dunning rules, emits the same lifecycle events.
Multi-connection routing · each billing profile picks its own connection, so a US profile can run Stripe while an EU profile runs PayPal, both live at once.
Sync preview last sync 2m ago
Invoice INV-2049 in QuickBooks $420.00
Invoice INV-2048 in Stripe $149.00
Payout PO-7714 in PayPal $3,204.18
Refund RF-0091 in Square −$49.00
Reconciliation 412 / 412 matched
Native schedules

Stripe, PayPal Billing v1, Square, and Auth.Net ARB run their own renewals.

Managed renewals

QuickBooks runs on our cron · we own the schedule and the retries.

Per-profile routing

Each profile binds its own connection · many at once.

Invoice sync

QuickBooks invoices sync both ways · the ledger and your books agree.

Payouts in

Settlement payouts pull in automatically so you see cash, not just charges.

Signed events

Webhook signature verification keeps every synced event trustworthy.

Reconcile

Payouts matched to invoices, automatically.

Five acquirers settle into one ledger, then the reconciliation engine matches every payout to the invoices that funded it. Matched rows clear green, the rare unmatched row flags amber for a human to resolve. Month-end close is one report, not five.

app.ligna.io / integrate / payments / reconcile June 2026 · close
Collected$284.6K +9% MoM
Payouts$271.2K18 settlements
Refunds$4.1K31 issued
Unreconciled$6122 rows to resolve
PayoutMatched invoicesAmountStatus
PO-7710 INV-2041 · INV-2042 · INV-2044 $5,902.00 Matched
PO-7714 INV-2046 · INV-2048 $3,204.18 Matched
Sq PO-7718 INV-2050 · INV-2051 $1,488.00 Matched
A PO-7721 No invoice match · $612 short $2,140.00 Unmatched
Q PO-7724 INV-2053 · INV-2055 · INV-2056 $4,260.00 Matched
Auto-matched

Payouts clear against the invoices that funded them, no spreadsheet surgery.

Exceptions flagged

The rare unmatched payout flags amber with the shortfall, ready to resolve.

One ledger

Five acquirers settle into a single ledger, so close is one report not five.

Cash, not promises

Payouts reconcile to settled cash, so the number on the books is real.

Close-ready export

Export the matched ledger by processor and period for your accountant.

Refunds netted

Refunds net against payouts so the reconciled total ties out to the cent.

Integration recipes

Start from a recipe that is already wired up.

90+ ready-to-run integration recipes, one for every "when this happens in that app, do this in another." Each lands with the trigger, the connections, the field mapping, and the webhook already in place. Pick one, connect your apps, and it is live. AI Assist can reshape any recipe to your exact flow in one prompt.

  • Every recipe is fully editable. AI Assist reshapes the trigger, mapping, and routes to your flow in one prompt.
  • Connections + mapping pre-wired. It lands ready to run, you just authorize the apps it uses.
  • Save your own as a recipe. Turn your best integration into a reusable blueprint your whole team installs from.
Search integration recipes… All Popular Recent 90+
Payments · Paid to CRM
CRM · New lead to Slack
Accounting · Invoice sync
Email · Form to autoresponder
Webhooks · Event to workflow
Payments · Paid to onboarding
CRM · Two-way sync
Comms · Failed pay to SMS
Social · Lead ad to CRM
Support · Email to ticket
AI · Enrich on signup
Accounting · Payout to dashboard
Webhooks · Integrate

Any event in, any action out.

A visual webhook designer that receives an inbound payload, runs it through filters and a router, and fans it out to a workflow or back out to any URL. Every endpoint is signed with HMAC, every delivery is deduped and retried, and nothing is ever silently lost. The whole event layer is built in · no middleware, no glue code.

app.ligna.io / integrate / webhooks Integrate · Live
Inbound · receive
payment.succeededPOST /wh/in/wh_9f3a
form.submittedTypeform · signed
Filter · route · transform
Outbound · emit
Open onboardingWorkflow · Automate
POST to SlackOutbound · HMAC signed
Payment router5 nodes · 2 branches
Trigger · Payment received
Filter · Amount > $500
Router · Plan tier?
Visual graph Auto-wired

A graph, not a config file.

The same Cadence-Designer canvas that powers Automate drives webhooks too. Drag a trigger in, drop a filter, fork a router, and wire the branches to a workflow or an outbound POST. Connectors draw themselves as you go, and the whole graph is saved with the endpoint so it is versioned and auditable.

  • Grouped palette: triggers, logic, routes, outbound
  • Ports auto-connect · true/false branches on every router
  • Inline inspector configures the selected node
  • Graph saved with the endpoint, versioned and auditable
Inbound · kind = inbound
POST /wh/in/wh_9f3a2c8e
Outbound · kind = outbound
POST https://hooks.acme.com/ligna
Receive Emit

One endpoint type. Both directions.

An inbound endpoint hands you a signed URL that any app can POST to · the receiver verifies the signature, dedupes on event ID, and starts the graph. An outbound endpoint emits your own events (subscription.created, lead.created, payment.failed) to any URL you name. Same designer, same delivery log, one mental model.

  • Inbound: a signed `/wh/in/{token}` URL per endpoint
  • Outbound: emit platform events to any external URL
  • Inbound receiver verifies, dedupes, and dispatches
  • Every inbound key maps into a workflow variable
Signature header X-Ligna-Signature: t=1718380931, v1=5257a8•••c19f
whsec_•••••••••••••••• HMAC-SHA256
HMAC-SHA256 Timestamped

Signed, timestamped, tamper-evident.

Every payload carries an `X-Ligna-Signature` header with a timestamp and an HMAC-SHA256 signature over the raw body. Inbound, the receiver rejects anything that does not verify against the signing secret. Outbound, your stack verifies the same way. Rotate the secret with an overlap window so nothing breaks mid-flight, and a stale timestamp is refused to stop replays cold.

  • HMAC-SHA256 over the raw request body
  • `t=` timestamp blocks replayed requests
  • Per-endpoint signing secret, rotatable with overlap
  • Inbound requests that fail verification are dropped
Backoff schedule
200Attempt 1 · deliveredinstant
503Attempt 2 · retry+1m
503Attempt 3 · retry+5m
DLQDead-letter · held for replay+12h
Exponential Dead-letter

A 5xx is a pause, not a loss.

Every delivery is recorded and deduped on event ID so a double-fire never double-processes. A failed attempt retries on exponential backoff, and once the window is exhausted the event drops into a dead-letter queue where it waits for you to fix the endpoint and replay it with one click. Nothing is silently dropped · every attempt is recorded.

  • Idempotent: deduped on event ID before processing
  • Exponential backoff · 1m, 5m, 30m, up to 12h
  • Dead-letter queue after the retry window closes
  • One-click replay from the deliveries log
Visual by default

Drag, drop, and wire the event flow on the same canvas Automate uses.

In and out

One endpoint type receives inbound payloads or emits your own events.

Signed every time

HMAC-SHA256 with a timestamp so payloads can be verified and replay-proofed.

Retried, not lost

Exponential backoff and a dead-letter queue keep every event recoverable.

Full audit log

Every delivery, attempt, and status code recorded for instant debugging.

Works with anything

Stripe, partner systems, your own backend · if it can POST, it connects.

The designer

Wire an event to an action, on a canvas.

A grouped node palette on the left, the live event graph in the middle, and a node inspector on the right. Drag a trigger in, drop a filter and a router, wire the branches, and the connectors draw themselves. AI Assist can build the whole graph from a sentence.

app.ligna.io / integrate / webhooks / payment-router / build Webhook Designer
Settings Designer Events Test Deliveries AI Build Save
Payment receivedInbound · Stripe
Amount > $500?Logic
Plan tier?Route
Open onboardingWorkflow
POST to SlackOutbound
Grouped palette

Triggers, logic, routes, and outbound nodes · searchable and one drag away.

Auto-wired connectors

Drag a port to the next; the graph snaps and the line draws itself.

Route on any field

Fork a router on plan tier, amount, or any inbound key into branches.

Fan out anywhere

Send a branch to a workflow, an automation, or an outbound HTTP POST.

Test from the canvas

Fire a sample payload and watch each node light up as it routes.

AI builds the graph

Describe the routing in a sentence and AI Assist lays out the nodes.

Event catalog

Subscribe to what you need, emit what they need.

Inbound events from your connected processors land on one side; outbound events your platform emits sit on the other. Flip a toggle to subscribe. Every delivery is signed with the same `X-Ligna-Signature` scheme, and the signing secret rotates with an overlap window so nothing breaks.

Inbound · source events kind = inbound
payment.succeeded
charge.refunded
dispute.created
form.submitted
invoice.paid
Outbound · emittable events kind = outbound
subscription.created
lead.created
payment.failed
subscription.canceled
deal.won
Every delivery carries X-Ligna-Signature: t=1718380931, v1=5257a8c1d4e9f06b3a72c9e1d8f4•••c19f
HMAC-SHA256 over the raw body · verify with the signing secret, reject a stale `t`
Signing secret
whsec_••••••••••••
Inbound catalog

Subscribe to processor events like payment.succeeded with one toggle.

Emit your own

subscription.created, lead.created, payment.failed · fired to any URL.

X-Ligna-Signature

A timestamp and an HMAC over the body on every single delivery.

Rotate the secret

Roll the signing secret with a 24h overlap so verifiers never break.

Toggle per event

Turn any event on or off without touching the rest of the graph.

Keys to variables

Inbound payload keys map straight into {{trigger.*}} for the graph.

Deliveries

Every delivery, every attempt, on one screen.

A live log of every webhook delivery, with the numbers that matter pinned above it. See what shipped in the last 24 hours, the success rate, what is mid-retry, and what failed. Replay any delivery in one click, and a dead-letter queue holds anything that exhausts the retry window until you are ready.

Delivered 24h9,412 +1,108 vs prior day
Success rate99.4% +0.2pp
Retrying23 backoff window
Failed · dead-letter6 held for replay
whd_8f3a2c
Slack notifier hooks.acme.com / ligna
payment.succeeded Outbound Delivered 1 attempt 14:02:11
whd_8f3a2b
Stripe inbound /wh/in/wh_9f3a
charge.refunded Inbound Delivered 1 attempt 13:58:40
whd_8f3a1e
CRM sync api.partner.io / events
lead.created Outbound Retrying 2 of 5 · +5m 13:51:22
whd_8f39d7
PayPal inbound /wh/in/wh_4c11
dispute.created Inbound Delivered 1 attempt 13:44:09
whd_8f398a
Billing webhook hooks.acme.com / billing
payment.failed Outbound Failed 5 of 5 · DLQ 12:31:55
whd_8f3971
Onboarding flow Automate / workflow
subscription.created Outbound Delivered 1 attempt 12:18:02
2 selected
Anything that exhausts the exponential-backoff window lands in the dead-letter queue · it is never dropped. Fix the endpoint, then replay the whole batch in one click.
KPIs pinned up top

Delivered, success rate, retrying, and failed sit above the live log.

Both directions logged

Inbound and outbound deliveries share one searchable, filterable list.

Attempt count visible

See exactly which retry a delivery is on and when the next fire lands.

One-click replay

Re-fire any delivery, or a whole selection, straight from the row.

Dead-letter queue

Exhausted deliveries are held, never dropped, until you replay them.

Inspect the payload

Open any delivery to read the exact body and signature that was sent.

API · Integrate

A platform your developers can actually build on.

REST and GraphQL over the same data your console reads. Scoped API keys, predictable rate limits, signed webhooks, first-party SDKs, a sandbox that mirrors production, and a visual field mapper for two-way sync. Everything the console does, your code can do too.

REST GraphQL
GET /v1/leads?status=open&limit=25
query Leads { leads(status: open) { email company } }
Same data model JSON over HTTPS

Two shapes, one data model.

Hit resource-style REST endpoints when you want simple CRUD, or send a GraphQL query when you want exactly the fields you need in one round trip. Both speak the same objects the console renders, so nothing drifts between what your team sees and what your code reads.

  • REST resources for leads, contacts, deals, products, payments
  • GraphQL endpoint with typed queries and a live schema explorer
  • Cursor pagination, filtering, and sparse field selection
  • Versioned base path (/v1) so upgrades never break you
sk_live_a91•••••••••••7f Live
read create update delete
Scoped tokens Rate limited

Least-privilege by default.

Every key carries an explicit scope set, so a read-only integration can never write. Keys pass in an Authorization: Bearer header, rotate with a single click, and report their last-used time. Rate limits are per-key and visible, so you size your traffic before you hit them.

  • Scopes per key: read / create / update / delete, per resource
  • Live and test keys side by side, each independently rotatable
  • Per-key rate limits with response headers and burst window
  • Last-used, created-by, and IP allowlist on every key
$ npm i @ligna/sdk
const lead = await ligna.leads.create({ email });
JavaScript PHP Python Sandbox
First-party SDKs Sandbox parity

Ship in an afternoon.

Interactive docs let you fire a real request from the page. Official SDKs for JavaScript, PHP, and Python wrap auth, retries, and pagination. A sandbox mirrors production so you build against test data with zero risk, and the CLI forwards live webhooks to localhost while you debug.

  • Try-it docs that run against your test key inline
  • SDKs for JavaScript, PHP, Python with typed responses
  • Sandbox / test mode with seeded fixtures and reset
  • CLI webhook forwarding to localhost during development
Lead.email
Contact.Email
lowercase
Two-way sync
Field mapping Conflict-aware

Two-way, conflict-aware.

Map our fields to a connected app's fields with a visual editor, add per-mapping transforms like lowercase or format, then flip on two-way sync. A conflict rule decides who wins when both sides change, so records stay consistent without you babysitting the integration.

  • Visual field mapping with drag-to-connect link lines
  • Per-mapping transforms: format, lowercase, concat, default
  • One-way or two-way sync, toggled per object
  • Conflict rule: newest-wins, source-wins, or manual review
REST + GraphQL

Pick the shape that fits the job; both read the exact objects your console renders.

Scoped keys

Least-privilege API keys with per-resource scopes and one-click rotation.

Predictable limits

Per-key rate limits surfaced in response headers, so you never get surprised.

First-party SDKs

JavaScript, PHP, and Python wrappers handle auth, retries, and pagination.

Sandbox parity

Build against a test mode that mirrors production, then promote with the same code.

Two-way sync

Map fields once and keep records consistent both ways with a conflict rule.

API keys

Keys you can trust in production.

Live and test keys, masked by default with reveal and rotate. Scopes pinned per key so a token can only do what you granted. A visible rate limit and a copy-paste Authorization: Bearer example, so a new developer is authenticated in under a minute.

app.ligna.io / integrate / api-keys Live
Production key Live
sk_live_a91•••••••••••••••7f
Last used 3m ago
Sandbox key Test
sk_test_4c0•••••••••••••••d2
Last used 1h ago
Scopes read create update delete
Rate limit 1,000 req / min burst 50
# authenticate every request
Authorization: Bearer sk_live_a91••••••7f
Live + test keys

Separate API keys for production and sandbox, each rotatable on its own.

One-click rotate

Compromised key? Rotate it and the old secret stops working instantly.

Masked by default

Secrets stay hidden until you reveal, so screen-shares never leak a key.

Visible rate limits

Per-key limits and burst windows shown up front, returned in response headers.

Granular scopes

Grant read / create / update per resource so a token does only its job.

Usage audit

Last-used, created-by, and IP allowlist on every key for clean attribution.

Docs & SDKs

Read the docs, run them right there.

Pick an endpoint on the left, see the request and a real 200 response on the right. Copy the curl, drop in an SDK for JavaScript, PHP, or Python, point at sandbox / test mode, and forward live webhooks to localhost with the CLI while you build.

developers.ligna.io / reference Test mode
Leads
GET /leads
POST /leads
GET /leads/:id
PATCH /leads/:id
Webhooks
POST /webhooks
Request
curl https://api.ligna.io/v1/leads
-H "Authorization: Bearer sk_live_a91••7f"
Response 200 OK
{
"id": "lead_8f21",
"email": "sarah@acme.com",
"company": "Acme Outreach",
"status": "open"
}
JavaScript PHP Python Sandbox / Test mode CLI webhook forwarding
Run-it docs

Fire a real request from the reference page and see the live response inline.

Three SDKs

JavaScript, PHP, and Python wrappers handle auth, retries, and pagination for you.

Sandbox + test mode

Build against seeded test data, then ship the exact same code to production.

CLI webhook forwarding

Pipe live webhook events straight to localhost so you debug without a tunnel.

Copy-paste curl

Every endpoint ships a ready curl with your test key already substituted in.

Typed responses

Predictable JSON shapes and error codes so your client handles edge cases cleanly.

Data sync

Map your fields once, sync both ways forever.

Draw a line from our field to a connected app's field, add a transform where the formats differ, then flip on two-way sync. A conflict rule decides who wins when both sides change the same record, so the two systems stay in lock-step without manual cleanup.

Ligna CRM field mapping Salesforce
Lead.email
lowercase
Contact.Email
Lead.company
Account.Name
Lead.phone
format E.164
Contact.Phone
Two-way sync
Conflict rule Newest wins
Last synced 2m ago · 0 conflicts
When both systems edit the same record, the most recently changed value is kept and the older write is logged for review.
Visual field mapping

Connect our fields to a connected app's fields by drawing a line, no code.

Per-mapping transforms

Lowercase, format, concat, or default a value as it crosses the boundary.

Two-way sync

Flip one toggle and changes flow both directions, kept in lock-step.

Conflict rules

Newest-wins, source-wins, or manual review decides who wins a clash.

Sync history

Every run logs what moved and what clashed, so reconciliation is one screen.

Safe by design

Older writes are logged, not lost, so a bad sync is always recoverable.

Governance · Integrate

Connect anything, and prove every byte of it.

Every connect, refresh, webhook, and sync writes to an immutable audit trail. Secrets sit encrypted at rest with AES-256, scoped to least-privilege OAuth grants. Tenant isolation is enforced at the connector base class, not bolted on. The compliance story your security review actually wants to read.

Audit log
connect sarah@acme.com 14:02
token.refresh system 13:48
webhook.error slack · 401 13:30
Immutable trail Who, what, when

Every connect, refresh, and webhook on the record.

The audit log captures every state change a connection makes · who connected it, who disconnected it, every token refresh, every webhook delivery, every error. Payloads are masked so the trail is safe to read. When a security review asks "who touched this connector and when," the answer is one filtered query.

  • Actor, action, outcome, and timestamp on every row
  • Connect / disconnect / refresh / webhook / sync / error actions
  • Masked payloads so secrets never land in the log
  • Filter by connector, actor, outcome, or date range
AES-256 encryption
AES-256 encrypted at rest
OAuth scopes granted
read:contacts
write:messages
admin:billing not requested
AES-256 Least privilege

Secrets encrypted. Scopes minimal.

Tokens and API keys are encrypted with AES-256 before they ever touch the database. Nothing is stored in plaintext, and decryption happens only at the moment of the outbound call. Every OAuth grant requests the narrowest scope set the integration needs, so a compromised token can never reach beyond its job.

  • AES-256 encryption at rest
  • Least-privilege OAuth scopes requested per provider
  • Tokens decrypt only at call time, never logged
  • Refresh and revoke without exposing the raw secret
Connector base class
Tenant Ascoped
Tenant Bscoped
Cross-tenant reads rejected at the base class
Base-class scope No cross-tenant leaks

Isolation enforced where it cannot be skipped.

Every connector inherits from one base class, and that base class scopes every query, every credential lookup, and every audit write to the calling tenant. A new integration cannot accidentally read another account's data, because the isolation lives below the integration code, not inside it. One enforcement point, audited once, trusted everywhere.

  • Tenant scope applied at the connector base class
  • New integrations inherit isolation by default
  • Cross-tenant reads rejected before the query runs
  • Audit writes carry the tenant context automatically
Connection health
Slack 99.8%
Stripe 94.1%
HubSpot 71.4%
Alert fires when a connection drops below 90%
Live health Alert on failure

You see the failure before your customer does.

Every connection reports a rolling health score from its delivery and sync success rate. Green, amber, and red tell you at a glance which providers are solid and which need attention. When a connection drops below threshold or a token stops refreshing, an alert fires · you fix it before the data stops flowing.

  • Rolling health score per provider from real traffic
  • Green / amber / red status at a glance
  • Alert on failed delivery, sync error, or stale token
  • Last-verified timestamp on every connection
Immutable audit trail

Every connect, refresh, webhook, and sync recorded with actor and outcome.

AES-256 at rest

AES-256 encrypts every secret before it touches the database.

Least-privilege scopes

Each OAuth grant requests only the access the integration actually needs.

Tenant isolation

Scoped at the connector base class, so no integration can leak across accounts.

Continuous health

Live delivery and sync scores surface a failing connection before it bites.

Alert on failure

A connection drop or stale token pages you, not your customer.

Audit & security

A trail you can hand to an auditor.

The audit feed shows who did what to every connection, with masked payloads and exact timestamps. The security panel proves the rest · AES-256 secrets, least-privilege scopes, an IP allowlist on inbound webhooks, SOC 2 and GDPR posture, and tenant isolation enforced at the base class. One screen answers the whole questionnaire.

app.ligna.io / integrate / governance / audit Integrate · Live
Audit log
connect
sarah@acme.comslack · payload {tok:••••3f8a}
ok 14:02
refresh
systemstripe · token rotated
ok 13:48
webhook
hubspotcontact.created · payload {id:••8821}
200 13:41
error
hubspot · webhook401 unauthorized · logged to error log
fail 13:30
disconnect
jon@acme.commailchimp · revoked by user
ok 12:58
Security posture
AES-256 encrypted secrets
OAuth scopes · least privilege
read:contacts
write:messages
admin:* never requested
IP allowlist 52.10.0.0/16 + 3 more
SOC 2 GDPR TLS 1.2+
Tenant isolation enforced at the connector base class · no integration can read another account.
Who did what, when

Every connect, disconnect, refresh, webhook, and error stamped with actor and time.

Masked payloads

Tokens and IDs are redacted in the trail so the log is safe to export.

Encrypted secrets

AES-256 at rest, decrypted only at the moment of the call.

IP allowlist

Inbound webhooks accepted only from the CIDR ranges you approve.

SOC 2 / GDPR posture

The compliance chips your security review needs, on one screen.

Raw error log

Every failed call captured raw for fast diagnosis without guessing.

Observability

Know a connection is failing before anyone asks.

One dashboard for the whole integration surface. Connections healthy, webhook success rate, sync errors in the last 24 hours, and average latency up top. Per-provider health with a last-verified timestamp below. A delivery and sync trend line so you spot a slow degrade, and an alert that fires the moment a connection drops.

app.ligna.io / integrate / governance / health Health
Connections healthy23 / 25 92% green
Webhook success rate99.2% +0.4pp 24h
Sync errors 24h7 −12 vs prior
Avg latency284msp95 612ms
Per-provider health
Slackverified 2m ago
99.8%
Stripeverified 5m ago
98.1%
Salesforceverified 9m ago
93.4%
HubSpotlast verified 41m ago
71.4%
Mailchimpverified 14m ago
97.6%
Delivery + sync success · last 14d
14d10d7d4d2dnow
Alert on failure · HubSpot dropped below 90% at 13:30. A notification fired and the failed delivery is queued for idempotent replay.
Health at a glance

Connections healthy, webhook success, sync errors, and latency in one row.

Per-provider scores

Green, amber, or red for every connection, with a last-verified timestamp.

Trend, not snapshot

A 14-day delivery and sync line catches a slow degrade before it tips red.

Alert on failure

A connection drop or webhook failure pages you the moment it happens.

Latency tracked

Average and p95 response time per provider, so slow is visible, not silent.

Idempotent replay

A failed delivery re-fires safely, so a recovered provider never double-processes.

AI Assist · Integrate

The integrations engineer you do not have to hire.

AI Assist for Integrate is trained on every connection, webhook, and sync in your workspace. Say "connect Stripe" or "map our leads to HubSpot" and it runs the OAuth, wires the fields, signs the webhook, and tells you exactly what it did. Then it watches every token and delivery and fixes what breaks.

Integrations Agent AI Assist Trained on every connection, webhook, and sync in your workspace. Connects, maps, and self-heals.
Marketplace Connections Payments Webhooks API Governance Sync OAuth
Activate in Conversations
Connect an app for you

"Connect our Stripe account." AI Assist runs the OAuth, verifies it, stores the token encrypted, and points your billing profile at it.

Connected + verified 6 sec
Map + sync the data

"Map our leads to HubSpot." AI Assist matches the fields, picks a key, applies transforms, and turns on two-way sync.

14 fields mapped 8 sec
Build a webhook flow

"When a payment over $500 lands, ping Slack and open onboarding." AI Assist wires the trigger, filter, and routes on the canvas.

Flow built + tested 7 sec
Heal a failing delivery

"The Slack webhook is failing." AI Assist finds the cause, adds a retry, replays the failed deliveries, and clears the alert.

18 deliveries recovered 5 sec
Keep tokens alive

"Anything about to break?" AI Assist scans every connection, refreshes expiring tokens ahead of time, and flags revoked keys.

2 refreshed, 0 downtime 4 sec
Explain the error

"Why is the QuickBooks sync erroring?" AI Assist reads the audit log and gives you the plain-language cause and the fix.

Cause + fix 5 sec
Suggest the integration

AI Assist watches how you work and recommends the apps and webhooks that would save your team the most manual steps.

3 suggested today live
Write the API call

"Show me how to create a lead via the API." AI Assist returns the request, the SDK snippet, and a sandbox example you can run.

Snippet + sandbox 4 sec
24+Integrations AI Assist can connect
5Payment processors it wires for you
100%Tokens auto-refreshed before expiry
100%Audit-trailed · every action logged
Conversations

Your team, your AI agent, every connection in one place.

DMs, channels, threads, voice, video up to 10, screen share, AI agents in the same thread · the entire communications layer built into the console so your team never has to leave Integrate to connect an app or fix a webhook.

app.ligna.io / integrate / connections Integrate · Live
3
Focus 3 Direct 2 Channels 3 Feed
Pinned1
Nexus · Integrations Agent
Stripe connected · Slack webhook healed.
2m
Channels3
#integrations
E. Mor: @Nexus connect our Stripe account…
4
#webhooks
Nexus: Slack webhook healed, 18 replayed.
21m
#connection-health
Nexus: 2 tokens refreshed ahead of expiry.
1h
Direct3
DV
D. Vex
Webhook fix worked, thanks.
8m
AK
A. Kerr
HubSpot sync looks perfect.
23m
PL
P. Lund
Reviewing the QuickBooks sync now.
1h
Nexus · Integrations Agent AI active · tools 1,000+
EM
E. Mor · 9:20a
Nexus, connect our Stripe account and point the Growth profile at it.
N
Nexus · AI · 9:21a
Stripe is connected and verified. I ran the OAuth, stored the token encrypted, set the webhook signature, and pointed the Growth billing profile at the new connection. Inline checkout is live and auto-refresh is on, so the token will never expire on you.
stripe-connection.json verified · 1 of 24 apps · 84 KB
💳 3 👍 E. Mor, A. Kerr
You · 9:23a
Perfect. Now subscribe a webhook so payment.succeeded pings the #revenue channel.
Read by Nexus, E. Mor
N
Integration sync · 3 on 2:14
DV AK PL
5 conversation types

DMs, channels, threads, voice, video · all in-console.

Voice + video up to 10

Screen share, recording, transcripts auto-attached to threads.

AI Assist in the same thread

Connects apps, maps fields, fixes webhooks, all without leaving chat.

Connection context inline

Pull a connection, its health, and its last delivery into the thread without switching tabs.

Alerts route to channels

Failed deliveries and expiring tokens post to the channel that owns them, automatically.

Action from the message

Reconnect an app or replay a delivery right where the conversation happens.

The flagship automation

One webhook in. Every connected app reacts.

A payment lands at the processor and the whole connected stack moves · signature verified, books synced, CRM updated, onboarding opened, Slack pinged, dashboard refreshed. One inbound webhook fanning across every integration. 9 nodes, atomic, idempotent, audit-trailed.

9 nodes, every app

Accounting, CRM, onboarding, Slack, dashboard · one webhook fans across them all.

Signed + idempotent

HMAC-verified, deduped on the event ID · a double-fire never re-charges or re-syncs.

Audit on every edge

Each node writes to the integration audit log with its before and after.

Test before you ship

Fire a test event and watch every node and every connected app react safely.

Self-healing delivery

A failed outbound step retries with backoff and replays, instead of silently dropping.

No glue code

It is all native connections, not a separate iPaaS bill bolted on the side.

Compare

If you have ever paid for an integration tool on top of your software, you know why already.

Most platforms make you bolt on a unified-API vendor, an embedded-iPaaS bill, and a separate payments tool. Integrate ships the marketplace, the connections, the payments, and the webhooks natively, inside the platform your data already lives in. Hover any card to compare.

vs HubSpot The native marketplace standard Hover to compare
  • Payments built in Stripe, PayPal, Square, Auth.Net, QuickBooks
  • Webhook designer Visual inbound + outbound, not just settings
  • Multi-account per app Many connections of the same provider
  • One platform CRM, billing, sites, support in the same login
  • Flat pricing No per-connected-app marketplace tax
  • AI Assist Connects and maps for you
vs Shopify The developer-platform bar Hover to compare
  • REST + GraphQL API Keys, scopes, rate limits, sandbox
  • Signed webhooks HMAC, retries with backoff, replay
  • Event catalog Subscribe to any platform event
  • Not just commerce CRM, marketing, billing, projects too
  • CLI webhook forwarding Test on localhost before you ship
  • Partner program Put your own app on the shelf
vs Merge The unified-API vendor Hover to compare
  • No extra vendor Integrations live in the platform, not a middleman
  • Visual field mapping Two-way sync, transforms, conflict rules
  • Payments included Not just CRM/HRIS read+write
  • Webhook designer Route any event, not only sync data
  • Health observability See every connection and delivery
  • One bill No per-API-call unified-API charge
vs Paragon The embedded-iPaaS add-on Hover to compare
  • Embedded connect portal Your customers self-connect, white-labeled
  • Managed OAuth + refresh Tokens never silently die
  • Native, not bolted on One platform, not an iPaaS subscription
  • Payments + accounting Stripe to QuickBooks, in the box
  • Audit + secrets vault Encrypted, scoped, fully logged
  • AI Assist Builds the connection and the webhook
Integrate console FAQ

Everything you would ask on the demo call.

What can I connect, and how fast?
24+ integrations out of the box across payments, accounting, email, comms, social, and AI · Stripe, PayPal, Square, Authorize.Net, QuickBooks, Twilio, SendGrid, Gmail, Outlook, Zoom, Facebook, Instagram, LinkedIn, X, ChatGPT, Claude, Gemini, Grok, and more. Most connect in one click: pick the app, authorize, done. AI Assist can run the whole connect for you and point your billing profile at it.
Can I have more than one account of the same app?
Yes. Connections are multi-account by design · a Stripe Live and a Stripe Sandbox, two merchant accounts, a separate Gmail per brand. Each is its own connection with its own health, and a billing profile or a workflow picks exactly the connection it should use. We never silently fall back to a parent's credentials.
Do connections break when tokens expire?
No. A refresh job runs ahead of every OAuth token's expiry and rotates it, so connections stay live without anyone reconnecting. If an upstream key is revoked, we flag it for a one-click reconnect and tell the owner. Every token is stored AES-256 encrypted and never shown after you save it.
Which payment processors are supported, and is checkout inline?
Stripe, PayPal, Square, Authorize.Net, and QuickBooks. Checkout is inline on every one · card fields render in your page with Stripe Payment Element, Square Web Payments, PayPal card fields, and Authorize.Net Accept.js, so there is no redirect and your PCI scope stays at zero. Subscriptions run native where the processor holds the schedule, or platform-managed where we run the renewals for you.
How does the webhook designer work?
It is a visual canvas. Drop a trigger (an inbound event or a schedule), add filters, transforms, and routers, then send the result anywhere · an HTTP request, a workflow, an email, an SMS. Inbound webhooks are HMAC-verified and deduped on the event ID. Outbound deliveries are signed, retried with exponential backoff, logged, and dead-lettered after the retry window so nothing is lost silently.
Can I sync data both ways and map fields?
Yes. Drag a field from our side to the app's side and a link connects them, with a transform on the wire if you need to reshape the value. Sync runs one-way or two-way, on a schedule or in real time, with a conflict rule when both sides change. AI Assist can build the whole mapping from a sentence and re-map automatically if a field gets renamed.
Is there a public API for my developers?
Yes. A REST and GraphQL API covers the platform, with issued API keys, per-key scopes, and rate limits. There is interactive documentation, SDKs in JavaScript, PHP, and Python, a sandbox/test mode, and CLI webhook forwarding so your team can build and test on localhost before they ship.
Can I put my own app in the marketplace?
Yes. Register your OAuth app, submit it for review, and list it. You can also run an embedded connect portal · a white-label catalog your own customers use to self-connect their apps, looking native in your product. Your registered app powers the OAuth for every child account that connects through it.
How is it secured and audited?
Secrets are AES-256 encrypted at rest and never re-displayed. OAuth scopes are least-privilege per app, with an IP allowlist and SOC 2 / GDPR posture. Every connect, disconnect, refresh, webhook, and error writes to the integration audit log with the payload redacted. Tenant isolation is enforced at the connector base class, not just by a SQL filter, so one account can never read another's credentials.
What is AI Assist, exactly?
AI Assist is the Integrate-specific AI agent. It has read-and-write access to your integration workspace, trained on every connection, webhook, and sync in your tenant. Ask it to connect an app, map fields and turn on sync, build a webhook flow, fix a failing delivery, or find connections about to break, and it has the context to take the action. Every AI Assist action is audit-trailed with the prompt and the outcome.
Ready when you are

Consolidate your stack. Reclaim your week.

Free for life for one user. Bring your whole stack into one place — no credit card, no time limit.