Getting Started with 8kit: Add Enterprise Reliability to n8n in 5 Minutes

This is the quickstart guide. In 5 minutes, you'll have 8kit installed, connected, and running in your first n8n workflow. No prior setup required.

What You'll Need

• An n8n instance (self-hosted or n8n Cloud), version 1.0 or later
• Docker (for running the 8kit server) or an 8kit Cloud account
• 5 minutes

Step 1: Start the 8kit Server (2 minutes)

Option A: Docker (self-hosted)

docker run -d \
--name 8kit \
-p 3000:3000 \
-v 8kit-data:/data \
8kit/8kit:latest

That's it. The 8kit server is running at http://localhost:3000.

Open http://localhost:3000 in your browser to see the dashboard. It's empty for now, we'll fix that shortly.

Option B: 8kit Cloud

Sign up at 8kit.io and get your server URL and API key. Skip the Docker step.

Option C: Docker Compose (with n8n)

If you're also self-hosting n8n, add 8kit to your docker-compose.yml:

services:
n8n:
image: n8nio/n8n
ports:
- "5678:5678"
environment:
- N8N_COMMUNITY_PACKAGES_ALLOW=n8n-nodes-8kit
volumes:
- n8n-data:/home/node/.n8n

8kit:
image: 8kit/8kit:latest
ports:
- "3000:3000"
volumes:
- 8kit-data:/data

volumes:
n8n-data:
8kit-data:

n8n connects to 8kit at http://8kit:3000 (Docker internal networking).

Step 2: Install the 8kit Node in n8n (1 minute)

Via the n8n UI (recommended)

• Go to Settings → Community Nodes
• Click Install a community node
• Enter: n8n-nodes-8kit
• Click Install

Via npm (self-hosted)

cd ~/.n8n
npm install n8n-nodes-8kit
# Restart n8n

For n8n Cloud

Community nodes are supported on n8n Cloud. Install from the UI as described above.

After installation, you'll see four new nodes in your node palette:

• 8kit Uniqs, Deduplication
• 8kit Lookup, Cross-system ID mapping
• 8kit Exclusivity, Distributed locking
• 8kit Temporal, Timestamp tracking

Step 3: Add the 8kit Credential (30 seconds)

• In n8n, go to Credentials → Add Credential
• Search for 8kit
• Enter your server URL:
• Self-hosted: http://localhost:3000 (or http://8kit:3000 if using Docker Compose)
• 8kit Cloud: Your cloud server URL
• Enter your API key (if using 8kit Cloud or if you've set one on your self-hosted server)
• Click Save

Step 4: Build Your First Bulletproof Workflow (2 minutes)

Let's add deduplication to a webhook workflow. This is the most common starting point, it prevents duplicate processing when webhooks fire multiple times.

Create the workflow

• Add a Webhook node, your workflow trigger
• Add an 8kit Uniqs node after the webhook:
• Credential: Select your 8kit credential
• Operation: Check
• Namespace: my-first-dedup (name it whatever you want)
• Key: {{ $json.id }} (the unique identifier from your webhook payload)
• Add an IF node after Uniqs:
• Condition: {{ $json.isNew }} equals true
• True branch: Your processing logic (the work your workflow does)
• False branch: A No Operation node (skip, this item was already processed)
• Add another 8kit Uniqs node at the end of the True branch:
• Operation: Mark
• Namespace: my-first-dedup (same namespace)
• Key: {{ $json.id }} (same key)

The complete flow

Webhook
→ 8kit Uniqs (Check): Is this new?
→ IF isNew = true:
→ [Your processing logic]
→ 8kit Uniqs (Mark): Record as processed
→ IF isNew = false:
→ No Op (skip duplicate)

Test it

• Activate the workflow
• Send a request to the webhook URL
• Send the same request again
• Check the executions, the first one processes, the second one skips

Open the 8kit dashboard at http://localhost:3000, you'll see your my-first-dedup namespace with one entry.

What's Next?

Now that 8kit is running, here's what to explore:

Add locking to prevent race conditions

Add 8kit Exclusivity nodes around any operation where concurrent executions could conflict:

Webhook
→ 8kit Uniqs (Check)
→ 8kit Exclusivity (Acquire): Lock "resource:{{ $json.id }}"
→ [Your processing logic]
→ 8kit Exclusivity (Release): Unlock "resource:{{ $json.id }}"
→ 8kit Uniqs (Mark)

Add cross-system ID mapping

When syncing between two systems, use 8kit Lookup to store and retrieve ID mappings:

→ 8kit Lookup (Get): Namespace "shopify-hubspot", Key {{ $json.shopifyId }}
→ IF mapping exists: Update HubSpot using mapped ID
→ IF no mapping: Create in HubSpot, then 8kit Lookup (Set) to store the mapping

Add incremental sync

For scheduled workflows, use 8kit Temporal to track when you last synced:

Schedule Trigger
→ 8kit Temporal (Get): "my-sync-timestamp"
→ Fetch records updated since timestamp
→ [Process records]
→ 8kit Temporal (Set): "my-sync-timestamp" to now

Explore the dashboard

The 8kit dashboard at your server URL shows:

• Uniqs: All namespaces and their entry counts. See how many duplicates you're catching.
• Lookups: Browse your ID mapping namespaces. Inspect individual mappings.
• Exclusivity: View active locks. Identify stuck locks (if any).
• Temporal: Check all your sync timestamps. Spot processing lag.

Common Questions

How much overhead does 8kit add?

Each 8kit node makes one HTTP request to your server. Typical latency: 1-5ms for local/Docker, 10-50ms for cloud. Negligible compared to external API calls in your workflow.

Can I use 8kit with existing workflows?

Yes. Add 8kit nodes alongside your existing logic. No refactoring needed.

What happens if the 8kit server is down?

8kit nodes fail with an error, which triggers n8n's error handling. Your data is safe, nothing processes without the reliability check. When the server comes back, state is fully preserved.

Is my data safe?

8kit stores metadata only: IDs, timestamps, lock states, and mapping keys/values. Your actual business data (order details, customer records, etc.) stays in your source and target systems. For self-hosted deployments, everything runs on your infrastructure.

Can I run 8kit in production?

Absolutely. The Docker image is production-ready. For high-availability, run behind a reverse proxy. The data is stored in SQLite by default (persisted in the Docker volume), suitable for most workloads.

---

You just made your first n8n workflow bulletproof. From here, apply the same patterns to your production workflows, one at a time, starting with the ones where reliability matters most.

8kit provides four enterprise automation patterns for n8n: deduplication, cross-system mapping, distributed locking, and change tracking. Learn more at 8kit.io