Integrations

Connections — any service with an HTTP API

Your CRM, your warehouse, your booking system, an internal endpoint — anything that speaks HTTP. A connection is one saved address plus one key, and a sentence you write about what it is for. Your agents read that sentence, and from then on they can call the service on your behalf. There is no fixed list of supported vendors, and nothing to wait for us to build.

SetupProject → Integrations → Connect → 'Any HTTP API (bring your own)'. Fill in the base URL (every call stays under it — HTTPS only), pick how it authenticates (bearer token, custom header, query parameter, username and password, or none), paste the key, and write a sentence about what the service is for. Set a test path — a cheap read like 'me' or 'ping' — and press Test before saving, so you find out the key is wrong now rather than at three in the morning. Your key is encrypted and never leaves the server: agents get the name of it, never the value.

Workflow action: call_integration

Connections that need a sign-in (OAuth)

Services that only issue tokens which expire — Google Workspace, Slack, HubSpot — need OAuth rather than a pasted key. Coagentic does not carry an OAuth app for anybody’s service: you register one on your own account, and we keep the tokens fresh. When the access token runs out, the platform swaps it for a new one at the moment of use, on both the agent path and the workflow path.

SetupRegister an app with the service and set its redirect URI to <API_URL>/integrations/oauth/callback — ONE URL for every connection you make, because the specific one travels in the state parameter. Then: Project → Integrations → Any HTTP API, pick 'OAuth — sign in to the service', paste the client ID and secret, the authorize and token URLs, and the scopes you want. Save, then press Connect on the card. Note that a token endpoint on localhost or a private address is refused — the same SSRF guard that protects every other outbound call — so a local mock will not work; test against the real service.

S3-compatible storage (AWS signature)

Object storage signs each request rather than carrying a pasted key, so it needs its own auth kind. One algorithm opens all of them: Cloudflare R2, Backblaze B2, MinIO, Wasabi, DigitalOcean Spaces and AWS itself.

SetupProject → Integrations → Any HTTP API, pick 'AWS signature'. Base URL is your account’s S3 endpoint with the bucket on the end, e.g. https://<account>.r2.cloudflarestorage.com/<bucket>/. Paste the access key ID and secret, set the region ('auto' for R2) and leave the service as 's3'. Paths are then relative to the bucket, so 'reports/july.csv' is the object.

Saved calls on a connection

A connection says where to send a request and how to sign it. A saved call says what to actually ask for — worked out once, then repeatable. Your agents write these down as they go, so the second time is not a guess; you can add or remove them by hand on the connection's card.

SetupProject → Integrations → the connection's card → Saved calls → Add one. Give it a short key (create_order), a label, a method and a path relative to the base URL. Use {{placeholders}} for the parts that change — they are filled from whatever is passed at run time, whether that is an agent or a workflow step.

A saved call becomes its own agent tool

Once a call is written down, your agents stop assembling it. Each saved call turns into a tool of its own — named after the connection and the call, taking only the values in its {{placeholders}}. Asking an agent to place an order stops being "work out the URL, the method and the body shape" and becomes "fill in the shop, the SKU and the email", which is the difference between a call that usually works and one that always does.

SetupNothing to set up. Save a call and it is there the next time an agent works on that project. The agent's own kill switch still applies (turn off agent access on the card and the tools disappear with it), and an agent restricted to certain connections only gets tools for those. The generic call is still available for anything not written down yet.

Polar.sh (Platform Payments — recommended)

One-click card payments with 0% Coagentic commission. Polar is the merchant of record — they handle global VAT/sales tax, payouts, chargebacks. Supports 175+ seller countries including Türkiye. See the dedicated guide at /docs/payments for end-to-end setup, agent product tools, and the cart pattern.

SetupProject → Integrations → Platform Payments panel → Enable payments → OAuth with Polar → done. No API keys to copy, no webhook URLs to wire. Open Polar dashboard from the panel to add your bank account and complete KYC before your first payout.

Polar.sh (BYOK — advanced)

Bring-your-own-key alternative if you already have a Polar account you want to use directly without OAuth. Same Polar API behind the scenes; less hand-holding.

SetupPolar dashboard → Settings → Developers → Organization access tokens → create. Coagentic Project → Integrations → Polar.sh → paste. Sandbox tokens start with polar_oat_ and accept the test card 4242 4242 4242 4242.

Resend

Modern transactional email. Most projects connect this for order confirmations, welcome emails, drip sequences. Also the backend behind the Platform Email feature — every project sends from its own <project-subdomain>@coagentic.site automatically, upgradeable to a dedicated subdomain (see /docs/email).

SetupResend dashboard → API keys → create with full-access scope. Project → Integrations → Resend → paste. Verify your sending domain (one DNS TXT record), then set a Default From on a domain you verified — sends now require an explicit From (no automatic fallback, which would be rejected by your Resend account).

Workflow action: send_email

Twilio (SMS)

Phone-number-based messaging. Order updates, delivery alerts, two-factor codes for your end customers.

SetupTwilio Console → Account SID + Auth Token + a verified Twilio phone number. Project → Integrations → Twilio → paste all three.

Workflow action: send_sms

Twilio (WhatsApp)

WhatsApp Business messaging on top of the same Twilio integration. For testing, use Twilio's Sandbox sender (recipients opt-in by texting the join code). For production, register a WhatsApp Business sender via Meta and add it as the integration's whatsapp_from value.

SetupSame Twilio integration used for SMS. Add a `whatsapp_from` value in the integration config (Sandbox: `+1 415 523 8886`; production: your registered WABA sender). The send_whatsapp action prefixes both From and To with `whatsapp:` automatically.

Workflow action: send_whatsapp

Twilio (Phone OTP)

One-tap phone verification for your forms — a visitor enters their number, gets a code, and types it back. Sent through Twilio Verify on your own Twilio account (the platform funds no SMS).

SetupCreate a Verify Service in the Twilio Console (Verify → Services) and paste its SID into the `verify_service_sid` field of your Twilio integration. Your site then calls POST /verify/<projectId>/send and /check; the send_verification_code / check_verification_code workflow actions use it too.

Workflow action: send_verification_code

Google Analytics

GA4 client-side measurement. Paste your measurement ID, we inject the tracker on every project page automatically.

SetupGA4 property → Web data stream → Measurement ID (looks like `G-XXXXXXXXXX`). Project → Integrations → Google Analytics → paste.

Cloudflare R2

S3-compatible object storage, zero egress fees — for tenants who want their own bucket instead of the platform-managed media tier.

SetupCloudflare dashboard → R2 → API Tokens → Create R2 Token → copy access key + secret. Project → Integrations → Cloudflare R2 → paste keys + bucket name + S3 endpoint (`https://<account>.r2.cloudflarestorage.com`).

Workflow action: upload_to_storage

Raw HTTP request (no saved connection)

A one-off call to a URL, straight from a workflow step, with no saved credentials behind it. Useful for a public endpoint or a webhook you are poking at once. For anything with a key, save a connection instead — the key is encrypted there, and your agents can use it.

SetupNo setup screen — used directly in workflows. The step takes a method, URL, headers and a JSON body. Anything outside 2xx fails the step; list the codes you mean to accept in allow_status.

Workflow action: http_request