Why We Open Sourced Our Mock API SDK: Zero Lock-In, Maximum Freedom

Today, we're announcing that Symulate SDK is fully open source under the MIT License. You can use it completely free with your own OpenAI API key, or even use it with zero API keys at all in Faker mode.

This isn't just about being "nice" to developers. This is a fundamental shift in how mock API tooling should work.

The Problem with Traditional Mock API Tools

Most mock API platforms follow the same playbook:

Lock you in - Your code becomes tightly coupled to their SDK
Charge monthly fees - Even for development and testing
Limit features - Free tiers are deliberately crippled
Close the source - You can't audit, modify, or truly own your tools

We asked ourselves: What if we did the opposite?

Three Usage Modes: Pick Your Level of Freedom

Instead of forcing developers into a single business model, we built three distinct modes:

🎯 Mode 1: Faker Mode (100% Free, Forever)

No API key needed. Period.

import { configureSymulate } from '@symulate/sdk';

configureSymulate({
  generateMode: 'faker', // That's it!
});

Perfect for:

CI/CD pipelines (deterministic, reproducible data)
Unit and integration tests
Quick prototyping without any setup
Learning and experimenting
Developers who value simplicity

Cost: $0 Limitations: None. You get the full SDK.

🚀 Mode 2: BYOK - Bring Your Own Key

Use your own OpenAI API key for AI-realistic data.

configureSymulate({
  openaiApiKey: process.env.OPENAI_API_KEY,
  generateMode: 'ai',
  // Persistence auto-defaults to "local"
});

Perfect for:

Individual developers who want AI-quality data
Startups optimizing for costs
Personal and learning projects
Developers who value data ownership
Anyone who hates vendor lock-in

Cost: ~$0.001 per generation (OpenAI API costs) Real-world: ~$0.05/month for active development

💼 Mode 3: Symulate Platform

Full-featured SaaS with cloud hosting, team collaboration, and branch isolation.

configureSymulate({
  symulateApiKey: process.env.SYMULATE_API_KEY,
  projectId: process.env.SYMULATE_PROJECT_ID,
  // Cloud persistence automatic
});

Perfect for:

Agencies managing multiple client demos
Teams needing shared data
Production use cases
Organizations wanting support

Cost: Starting at $49/month

Why Open Source? The Real Reasons

1. Trust Through Transparency

When you're building your application on top of a tool, you need to trust it. With closed-source SDKs, you're trusting blindly:

What data is being sent where?
Are there hidden rate limits?
Will it break in production?
What happens if the company shuts down?

Open source eliminates all these questions. You can read the code, audit it, modify it, and know exactly what it does.

2. No Hostage Situations

We've all been there: a tool you built your app on gets acquired, raises prices 10x, or shuts down. Your options are limited:

Pay the ransom
Refactor everything
Pray for the best

With Symulate SDK being open source:

The code can never be taken away
You can fork it if needed
You can even self-host everything
Your investment is protected

3. Community > Company

The best tools are built by communities, not companies. Open source means:

Developers can contribute features they need
Bug fixes come faster
Innovation happens organically
The tool evolves with real developer needs

4. Honesty About Business Model

We believe in transparent business models:

What's Free:

The entire SDK (MIT License)
All core functionality
Faker mode forever
BYOK with your own API keys
Local persistence

What You Pay For:

Cloud hosting convenience
Team collaboration features
Branch isolation (multi-tenant data)
Priority support

This is clear, honest, and fair. You're not a "free user" being pushed to upgrade. You're a developer who can choose the level of service you need.

How BYOK Actually Works

Let's demystify how the "Bring Your Own Key" model works:

The Architecture

┌─────────────────────────────────────────────────┐
│           Your Application                      │
│                                                 │
│  ┌──────────────────────────────────────────┐  │
│  │         Symulate SDK (Open Source)       │  │
│  │  ┌────────────┐      ┌────────────────┐ │  │
│  │  │   Schema   │      │  Collections   │ │  │
│  │  │  Builder   │─────▶│   (CRUD API)   │ │  │
│  │  └────────────┘      └────────────────┘ │  │
│  │                             │            │  │
│  │                             ▼            │  │
│  │                   ┌──────────────────┐  │  │
│  │                   │  Local Storage   │  │  │
│  │                   │  (Your Machine)  │  │  │
│  │                   └──────────────────┘  │  │
│  └──────────────────────────────────────────┘  │
│                      │                          │
│                      ▼                          │
│              ┌────────────────┐                 │
│              │  Your OpenAI   │                 │
│              │   API Key      │                 │
│              └────────────────┘                 │
│                      │                          │
└──────────────────────│──────────────────────────┘
                       ▼
              ┌────────────────┐
              │  OpenAI API    │
              │  (gpt-4o-mini) │
              └────────────────┘

Key Points:

Your data never touches our servers
Your API key is yours (we never see it)
Local persistence means offline capability
You control everything

Smart Defaults

When you use BYOK, the SDK automatically:

Defaults persistence to "local" (not "cloud")
Uses filesystem in Node.js, localStorage in browsers
Warns you if you accidentally try to use cloud features
Optimizes for offline-first development

// This is ALL you need
configureSymulate({
  openaiApiKey: process.env.OPENAI_API_KEY,
  generateMode: 'ai',
});

// SDK automatically sets:
// - persistence: "local"
// - caching: true
// - optimizations for BYOK

Real-World Cost Comparison

Let's talk actual numbers for a typical project:

Scenario: Building an E-Commerce Demo

Data Needed:

50 products
20 users
30 orders
100 reviews

Traditional SaaS Mock API:

Monthly cost: $19-49
Annual cost: $228-588
Features locked behind paywall
Data hosted on their servers

Symulate BYOK:

Initial generation: ~$0.05
Ongoing: FREE (data cached locally)
Annual cost: ~$1-2 (occasional regenerations)
All features included
Savings: 99%

Symulate Faker Mode:

Cost: $0
Annual cost: $0
All features included
Savings: 100%

Security and Privacy Benefits

Your Data Stays Yours

With BYOK:

Local-first: Data stored on your machine
No cloud uploads: Nothing touches external servers (except OpenAI for initial generation)
Full control: You decide where data goes
Audit trail: You can see every API call (inspect the code!)

API Key Security

Your OpenAI API key is sacred. Symulate SDK:

Never stores your key anywhere
Uses it only for direct OpenAI API calls
Doesn't log it
Doesn't transmit it to our servers

You can verify this yourself - the code is open source!

The Philosophy: Tools Should Be Free

We believe that developer tools should be free by default.

Sure, companies can charge for:

Infrastructure they manage
Support they provide
Convenience features

But the core tool itself? That should be free, open, and owned by developers.

This is why:

Git is free (GitHub charges for hosting)
VS Code is free (Microsoft charges for enterprise features)
Node.js is free (companies charge for hosting)
Symulate SDK is free (we charge for cloud platform)

Comparison with Alternatives

Let's be honest about the landscape:

Feature	Symulate BYOK	json-server	MSW	Mockoon	Postman Mock
Open Source	✅ MIT	✅ MIT	✅ MIT	✅ Apache	❌ Closed
AI Generation	✅	❌	❌	❌	❌
CRUD Collections	✅	⚠️ Limited	❌	⚠️ Limited	⚠️ Limited
Type Safety	✅	❌	✅	❌	❌
Local Persistence	✅	✅	❌	✅	❌
Flexible Schemas	✅	❌	❌	❌	❌
Free Forever	✅	✅	✅	✅	⚠️ Limited
Cost	$0-0.05/mo	$0	$0	$0	$0-50/mo

Symulate SDK combines the best of all worlds:

Open source like json-server
Type-safe like MSW
Feature-rich like paid tools
AI-powered (unique)

Getting Started with Open Source Symulate

1. Install

npm install @symulate/sdk

2. Choose Your Mode

Faker Mode (No Setup):

import { configureSymulate } from '@symulate/sdk';

configureSymulate({
  generateMode: 'faker',
});

BYOK Mode (OpenAI Key):

configureSymulate({
  openaiApiKey: process.env.OPENAI_API_KEY,
  generateMode: 'ai',
});

3. Start Building

import { defineCollection, m, type Infer } from '@symulate/sdk';

const ProductSchema = m.object({
  id: m.uuid(),
  name: m.string(),
  price: m.number(),
});

const products = defineCollection({
  name: 'products',
  schema: ProductSchema,
  seedCount: 20,
});

// Use it
const { data } = await products.list();

That's it. No accounts, no credit cards, no limitations.

Community and Contributions

As an open source project, we welcome contributions:

Ways to Contribute:

🐛 Report bugs on GitHub Issues
💡 Suggest features in Discussions
🔧 Submit pull requests
📖 Improve documentation
⭐ Star the repo (it helps!)

Community Resources:

When to Use Platform vs BYOK

We want to be clear about when each option makes sense:

Use Faker/BYOK if:

You're an individual developer
Building personal or learning projects
Want to minimize costs
Value data ownership and privacy
Prefer local-first development
Don't need team collaboration

Use Symulate Platform if:

You're an agency with multiple clients
Need isolated demos (client-specific demos)
Want team collaboration features
Prefer managed cloud hosting
Need priority support
Want to optimize developer time over cost

There's no "upsell pressure" here. Use what works for your needs.

The Future

Making Symulate SDK open source is just the beginning:

Coming Soon:

More AI providers (Anthropic Claude, local LLMs)
Plugin system for custom generators
Visual schema builder
Enhanced TypeScript codegen
Community marketplace for schemas

Always Free:

Core SDK functionality
Faker mode
BYOK support
Local persistence
All future features

Conclusion

Open sourcing Symulate SDK is our commitment to developers:

✅ Your tools should be yours ✅ Transparency over secrecy ✅ Freedom over lock-in ✅ Community over corporation ✅ Value over extraction

We're building the mock API tool we wish existed: powerful, free, and honest.

Try it today:

npm install @symulate/sdk

Read the Open Source guide or check out the BYOK tutorial.

Star us on GitHub if you believe in open source developer tools!

Happy coding! 🚀

Why We Open Sourced Our Mock API SDK: Zero Lock-In, Maximum Freedom

Why We Open Sourced Our Mock API SDK: Zero Lock-In, Maximum Freedom

Ready to try Symulate?