Build and Test Your Integration Before Going Live

You've decided to automate your document collection. Maybe you're connecting Claude Desktop to draft and send requests on your behalf. Maybe you're building a Zapier workflow that fires when a new deal closes in your CRM. Maybe you're writing a custom integration with the REST API.

Whatever the case, you face the same problem: every test hits live data. One wrong API call sends a real email to a real client. A misconfigured webhook floods your automation with production events. And all of it counts against your plan limits.

So you test carefully, nervously, one call at a time. Or worse — you don't test at all, and hope it works when you flip the switch.

Today we're shipping sandbox mode so you never have to do that again.

One Account, Two Worlds

If you've used Stripe, the model is familiar. Every Intake account now has two modes: live and test. You get separate API keys for each, and they access completely isolated data.

• Test keys start with dk_test_ — emails are captured (never sent), data is isolated from production, and nothing counts against your plan limits
• Live keys start with dk_live_ — emails deliver to real recipients, full production data, normal plan limits apply

Same endpoints. Same MCP tools. Same webhooks. The key prefix determines which world you're operating in. Create a test key in Settings → API Keys, and you're ready to go.

See Every Email Before It Sends

When your test workflow triggers an email — a document request, a reminder, a completion notification — it gets captured in the Sandbox Inbox instead of being delivered.

The inbox shows you the exact HTML email your client would receive. You can preview portal links, verify the copy, check that the right documents were requested. Filter by type to focus on what matters: requests, reminders, completions.

You're not guessing what the client experience looks like. You're seeing it. Every request email, every reminder, every completion notice — rendered exactly as it would appear in their inbox. When you're done testing, clear everything with one click.

Your Automations Get Real Payloads

Webhooks fire normally in sandbox mode. Your Zapier zaps, Make scenarios, n8n workflows, and custom webhook handlers all receive real event payloads with real data structures. The only difference is a mode field in the payload:

{
  "event": "request.completed",
  "mode": "test",
  "data": {
    "request_id": "req_t4k9m2...",
    "client": {
      "name": "Test Client",
      "email": "test@example.com"
    },
    "items_received": 3,
    "completed_at": "2026-03-24T14:30:00Z"
  }
}

This means you can build and debug your entire automation pipeline — conditional logic, data mapping, error handling — without worrying about downstream side effects. Your automation can check the mode field to branch behavior during the transition period.

Connect Any MCP Client in Test Mode

Claude Desktop, ChatGPT, and other MCP-compatible clients connect to Intake's MCP server using an API key. When you use a test key, the server tells the client it's in sandbox mode right in the handshake:

{
  "serverInfo": {
    "name": "intake",
    "version": "1.0.0",
    "mode": "test"
  }
}

Every tool call your AI assistant makes — creating clients, sending requests, checking uploads — operates against sandbox data. You can have a full conversation with Claude where it manages an entire document collection workflow, and nothing touches production.

Building a more permanent integration with OAuth? You can register OAuth clients in test mode too — just pass "mode": "test" during client registration to get sandbox-scoped credentials.

Go Live by Changing One String

Once you've verified everything works — emails look right, webhooks trigger your automations correctly, your MCP client manages requests properly — going live is a single change:

# Before — sandbox
INTAKE_API_KEY="dk_test_a8f29c..."

# After — production
INTAKE_API_KEY="dk_live_7b3e1d..."

No endpoint changes. No code changes. No reconfiguration. Your integration is production-ready because it was always running against the real API — just with isolated data.

End-to-End in Seven Steps

Here's a complete walkthrough to get a sandbox workflow running. The whole thing takes about five minutes.

1. Create a test API key. Go to Settings → API Keys and generate a new key. Select "Test" mode. Copy the dk_test_... key.
2. Connect your MCP client. In Claude Desktop, ChatGPT, or your preferred client, add Intake as an MCP server using your test key. The server URL and config are in the MCP docs.
3. Create a test client. Ask your AI assistant to create a client, or call the API directly. Use a test email like test@example.com. The client is created with sandbox isolation automatically.
4. Send a document request. Create and send a request to your test client. Ask for whatever documents your real workflow needs. The request goes through the full pipeline.
5. Check the Sandbox Inbox. Open Sandbox Inbox in your dashboard. You'll see the request email captured with the full HTML render. Verify the content, check the portal link, make sure everything looks right.
6. Verify your webhooks. Check your automation tool for the incoming webhook events. Confirm your workflow triggers correctly and processes the payload as expected.
7. Swap to your live key. Replace dk_test_... with dk_live_... in your configuration. You're live. Everything works exactly the same, now with real data and real emails.

What's Sandboxed (and What's Not)

A few details worth knowing as you build:

• Emails are captured, never sent. You see the exact HTML in your Sandbox Inbox.
• Webhooks still deliver to your endpoints — that's the point. Payloads include "mode": "test" so you can filter.
• Plan limits don't apply to sandbox data. Create as many test clients, requests, and deals as you need.
• Templates (form, PDF, and deal templates) are shared across both modes — you're testing with your real templates.
• File uploads work normally. You need real files to test the full flow.
• Sandbox emails auto-delete after 30 days, or you can clear them manually anytime.

Build with Confidence

We built sandbox mode because the gap between "I want to automate this" and "I trust this automation enough to run it live" shouldn't be filled with anxiety. Whether you're a developer writing a direct API integration, a team wiring up Zapier workflows, or someone connecting Claude Desktop to manage document collection through conversation — you should be able to build the whole thing, verify it works, and flip it live without breaking a sweat.

Create your account and generate a test key to get started. If you're already an Intake user, head to Settings → API Keys — sandbox mode is live now.