APIs, integrations and MCP servers — built for your business
We connect your systems, customer channels and AI tools, and keep those connections running.
Prefer WhatsApp?Message us(opens in a new tab)
- Built in Netanya, Israel
- Keys and secrets stay on the server
- AI access is read-only by default
Three ways we connect your systems
Most projects need one or two of them. We choose by the job, not by habit.
An API for your system, webhooks between systems
When other software needs to read or write your data, we build a clear, documented REST API. When something happens in one system, a webhook tells the others, and they react without anyone copying data by hand.
- Documented endpoints (OpenAPI), versioned so changes don’t break existing clients
- API keys, input validation and rate limits
- Incoming and outgoing webhooks with signature checks
- Connections to third-party APIs: payments, calendars, CRM, messaging
Good for
a mobile app, a partner portal, or two systems that have to stay in sync
POST /v1/bookingsAuthorization: Bearer ••••••••Idempotency-Key: 5f2c-9e1aContent-Type: application/json { "customer": "Dana Levi", "phone": "+972 50 000 0000", "service": "consultation", "start": "2026-10-01T10:00"}{ "id": "bk_123", "status": "confirmed", "calendar_event": "evt_8d2", "whatsapp": "queued"}Workflows that start on their own
A payment clears, a form arrives, a booking changes, and a chain of steps runs by itself. We build these workflows in n8n when that’s enough and in code when it isn’t, with retries and an alert to a person when a step fails.
- Triggered by webhooks, schedules, forms or email
- Receipts, WhatsApp templates, calendar events and CRM updates
- Each event is handled once, even if it arrives twice
- A log of every run, and an alert when one fails
Good for
repetitive work between WhatsApp, your CRM, email and accounting
on("payment.succeeded", async (evt) => { verifySignature(evt) if (await alreadyDone(evt.id)) return const receipt = await issueReceipt(evt) await whatsapp.template("receipt", { to: evt.customer.phone, link: receipt.url, }) await calendar.addEvent(evt.booking)})- payment.succeeded10:42:07Webhook received, signature checked
- issueReceipt10:42:07Receipt issued
- whatsapp.template10:42:08WhatsApp template sent
- calendar.addEvent10:42:11Calendar didn’t answer: retried, event created
- payment.succeeded10:42:19Same event again: already processed, skipped
Let AI assistants work with your systems
An MCP server turns your system into a small set of tools that Claude, ChatGPT and other AI assistants can use, such as “find free slots” or “look up an order”. It’s read-only by default, with sign-in, limits and a log of every call.
- Tools shaped around the questions your team really asks
- OAuth sign-in: the assistant sees only what the user may see
- Changes happen only after the user confirms
- Tested in the AI apps your team actually uses
Good for
teams that already ask AI assistants for help and paste data into the chat
server.registerTool("find_free_slots", { description: "Free calendar slots", inputSchema: { date: z.string(), minutes: z.number() }, annotations: { readOnlyHint: true },}, async ({ date, minutes }) => { const slots = await free(date, minutes) return { content: [text(slots)] }})Which slots are free tomorrow for a one-hour meeting?
Add AI to the software you already use
No new system for your team to learn. We add AI features inside your CRM, back office or website, and a person approves anything that goes out to a customer.
- Summaries and suggested replies inside your CRM or inbox
- Answers from your own documents, with the source shown
- Agents that prepare the work, people who approve the result
Systems we can connect
A starting list, not a limit. Every system here has a public API; what fits your project depends on your plans, your accounts and what should happen automatically.
Public API — we can connect
If it has an API, we can usually connect it; if not, we’ll tell you.
Ask about your systemMessaging
- WhatsApp Business API
- Telegram
Payments & invoices
- PayPlus
- Stripe
- Invoicing APIs
Calendars
- Google Calendar
- Outlook
CRM
- HubSpot
- monday.com
- Salesforce
- Custom CRM
AI models
- Claude
- ChatGPT / OpenAI
- Gemini
Data
- Google Sheets
- Firebase
- PostgreSQL
Automation
- n8n
- Make
- Zapier
Four typical integrations
Patterns you can start from. Each one links to a page with the details.
Recipe 01
Paid booking, receipt on WhatsApp
A customer books and pays online. The system issues the receipt, adds the booking to your calendar and sends the details as an approved WhatsApp template.
Recipe 02
A new lead that arrives already researched
A lead from your website is checked against public sources, lands in your CRM with a short summary and gets a follow-up sequence your team switches on. Only for people who opted in.
Recipe 03
Ask your own data from Claude
Your team asks Claude or ChatGPT “which orders are late this week?” and gets the answer from your own system, through a read-only MCP server that logs every call.
Recipe 04
Website chat straight into your CRM
The chat on your website answers from content you’ve approved, collects the visitor’s details and creates a lead in your CRM with the conversation attached.
How an integration project runs
Four stages. Each one ends with something you can see and check.
Map
We list your systems, what data should move between them and what triggers it, and read each provider’s API docs, limits and terms.
You getAn integration map and a written estimateBuild
We build against sandbox and test accounts first, and test the awkward cases: duplicates, timeouts, missing fields, Hebrew text.
You getA working connection on test dataSecure
Keys go into a secret store, webhooks are verified, permissions are cut to what the job needs, and AI actions that write data get an approval step.
You getA security checklist we review with youRun
We go live, watch the logs, retry what fails and alert a person when something needs attention.
You getMonitoring, alerts and a short runbook
Security built into every connection
Integrations move money, customer data and messages, so we treat them as production code from day one.
These are engineering practices we follow. They are not a compliance badge or an external audit.
Secrets stay on the server
API keys and tokens live in a secret manager on the server side, never in the browser, the mobile app or the code repository.
Webhook signatures checked
Every incoming webhook is verified, so a forged “payment succeeded” call is rejected instead of issuing a receipt.
Idempotency and retries
An event that arrives twice is processed once. Failed calls are retried with growing pauses before a person is alerted.
Least-privilege access
Each connection gets only the permissions its job needs, and read-only access wherever writing isn’t required.
Logs without secrets
We log what happened, not the card number or the token. Sensitive fields are masked before anything is written to a log.
Audit trail and human approval
When AI can change data, a person approves the action, and every call is recorded: who asked, what ran and when.
Questions about integrations
What is MCP?
MCP (Model Context Protocol) is an open standard that lets AI assistants such as Claude and ChatGPT use tools and data from other systems. An MCP server describes a few actions, like “find free slots” or “look up an order”, in words a model understands. We build them read-only by default, with sign-in, limits and a log of every call.
Can you connect a system that has no API?
Often, yes. Many systems without a public API can still export files, send email notifications, fire webhooks through a plugin or give access to their database, and we can build on those. Automating the screen itself is a last resort: it breaks when the interface changes and may go against the vendor’s terms. If there’s no reliable way, we’ll say so at the start.
Who owns the code and the keys?
We recommend opening accounts with services like WhatsApp, payment providers and AI models in your business’s name. That way the API keys are yours, and we work with access you can revoke at any time. Ownership of the code we write is agreed in writing before the project starts.
Do you maintain integrations after launch?
Yes, if you’d like us to. External APIs change, tokens expire and providers retire old versions, so integrations need looking after. We can watch for failures, handle alerts and update the connection when a provider changes something. What’s included in support is agreed in writing.
Can you work with our own developer?
Yes. We can build alongside your in-house or freelance developer, review their code, take the part they don’t have time for, or hand over documented code, tests and a short runbook so your team can carry on. We agree at the start who owns which part.
Tell us which two systems should talk to each other
Send us their names, or links to their API docs, and what should happen between them. We’ll reply with how we’d connect them and what to check first.
List your systems — we’ll draw the integration map.
Prefer to talk? Call050-854-2579