How we make this list: we compare pricing pages, product documentation and public user reviews. Ratings come from G2, Capterra or Trustpilot, with the date we checked them.
Key takeaways
- LocalStack changed in 2026: it now requires an account and auth token, and its license moved from Apache to BSL, which pushed many teams to look for replacements.
- Moto is the safe choice for Python unit tests, while Floci is the drop-in Docker replacement that keeps the same port and endpoint.
- MiniStack adds real databases and containers for integration tests, while MinIO, ElasticMQ, and DynamoDB Local cover single services deeply.
- You probably need two tools, not one: Moto for unit tests plus a Docker emulator for integration tests, since they solve different layers.
Quick comparison
| Tool | Best for | Starting price | Free plan |
|---|
 Moto | Python unit tests | Free, open source | Yes |
 Floci | Drop-in LocalStack replacement | Free, open source | Yes |
 MiniStack | Integration tests with real infra | Free, open source | Yes |
 MinIO | S3-compatible object storage | Free, open source | Yes |
 Testcontainers | Test lifecycle management | Free, open source | Yes |
 AWS SAM CLI | Lambda local testing | Free, open source | Yes |
 ElasticMQ | SQS simulation | Free, open source | Yes |
 DynamoDB Local | DynamoDB local development | Free | Yes |
Is your product missing or out of date?
We review this list regularly. Vendors can request a listing, send updated pricing or ask about featured placement.
The best localstack alternatives
Starting priceFree, open source
Free planYes
Moto is an open-source Python library that mocks AWS services at the Python level, and it is the safest replacement for LocalStack in unit tests. Migration from LocalStack is often a five-minute fixture change: wrap boto3 clients in a mock_aws context instead of pointing at a localhost endpoint, and test functions stay the same. Moto also runs in server mode via Docker for team environments.
Moto is less realistic than a running service, since it mocks SDK calls rather than running real infrastructure, and service coverage trails LocalStack full catalog. It is also weaker for infrastructure-as-code tests. Moto fits Python-heavy teams testing Lambda, DynamoDB, and S3 interactions in unit tests, without Docker overhead.
What we like- Lightweight
- No Docker needed
- Pytest and unittest integration
- Server mode available
Watch out for- Less realistic than a running service
- Limited service coverage
- Not ideal for IaC tests
Starting priceFree, open source
Free planYes
Floci is the free, open-source LocalStack alternative built as a drop-in replacement. Migration means swapping the Docker image from localstack/localstack to hectorvent/floci, keeping port 4566, endpoint URLs, AWS SDK config, and existing test code unchanged, with no auth token required. A built-in web UI lets teams inspect buckets, DynamoDB tables, and Lambda configs, and even invoke functions from the browser.
Floci image is dramatically lighter than LocalStack, near 90 megabytes versus about 1 gigabyte, with idle RAM near 13 megabytes versus about 500 megabytes in 2026 comparisons. The project is newer with a smaller catalog and community, so edge services may lag. Floci fits teams that want the LocalStack container workflow without the account requirement.
What we like- Same port and endpoint as LocalStack
- No auth token
- Tiny image
- Built-in web UI
Watch out for- Newer project
- Smaller service catalog
- Community is smaller
Starting priceFree, open source
Free planYes
MiniStack is the integration-test emulator that runs real infrastructure locally, with real Postgres and MySQL through Docker containers, real Redis, and real Docker execution for ECS, plus 60-plus AWS services free under an MIT license. That real-infra approach beats mocks when SQL migrations must actually run, connection pooling must actually work, and Redis TTLs must actually expire.
Many services remain in-memory, including SQS, SNS, DynamoDB, and IAM, and the project is newer than LocalStack or Moto. Image size near 150 megabytes and idle RAM near 30 megabytes keep it light for a real-infra tool. MiniStack fits integration tests where real database and container behavior matters more than pure emulation speed.
What we like- Real Postgres, MySQL, and Redis
- Real Docker containers
- 60-plus services
- MIT license
Watch out for- Newer project
- Heavier than Floci
- In-memory for many services
#4MinIO
Best for: S3-compatible object storage4.3/5 on
G2 (17 reviews, checked Oct 2026)
Visit min.io
Starting priceFree, open source
Free planYes
MinIO is an open-source, S3-compatible object storage server for cloud-native architectures, and it excels at replicating S3 behavior accurately. It supports multipart uploads, versioning, and bucket policies, runs fast, and integrates with Kubernetes. Teams that need strong S3-only emulation without full AWS simulation get the most accurate S3 behavior here.
MinIO covers S3 only, so Lambda, DynamoDB, and other services need separate tooling. MinIO fits teams with S3-heavy workloads that want accurate storage emulation, and that pair it with Moto or Floci for other services.
What we like- Exceptional S3 API compatibility
- Fast
- Multipart uploads, versioning, and bucket policies
Watch out for- S3 only
- No Lambda or DynamoDB
- Needs separate tooling for multi-service tests
Starting priceFree, open source
Free planYes
Testcontainers is not an emulator but the lifecycle tool that manages emulator containers inside test suites. It starts, stops, and cleans up containers for each test run, and it ships modules for emulators including Floci, so the whole emulator lifecycle runs inside the test suite instead of as a manually managed container. Language support covers Java, Python, Go, Node, and more.
Testcontainers needs Docker and adds startup time per test run, so teams should reuse containers across tests where possible. Testcontainers fits teams that want reproducible integration tests without manual Docker Compose management, and it pairs with Floci, MiniStack, or MinIO rather than replacing them.
What we like- Manages container lifecycle inside tests
- Language support is broad
- Works with any emulator
Watch out for- Not an emulator itself
- Needs Docker
- Test startup time adds up
Starting priceFree, open source
Free planYes
AWS SAM CLI is the official AWS tool for building and testing serverless applications locally. It invokes Lambda functions locally, emulates API Gateway, and supports step functions local testing, with deployment to AWS through the same templates. Teams already on SAM templates get the most value, since local and deployed definitions match.
SAM CLI covers Lambda and API workflows, not broad service emulation, so S3, DynamoDB, and SQS still need Moto, MinIO, or an emulator. It fits serverless teams that want official AWS local tooling for Lambda, and that pair it with Moto for other services.
What we like- Official AWS tooling
- Local Lambda invoke
- API Gateway emulation
Watch out for- Lambda and API focused
- No broad service emulation
- AWS-centric workflow
Starting priceFree, open source
Free planYes
ElasticMQ simulates Amazon SQS locally, with FIFO queues, dead-letter queues, and visibility timeout support. It runs lightweight in Docker and suits teams that need SQS behavior without a full emulator. Message-driven architectures can test producers and consumers against ElasticMQ while other services run elsewhere.
ElasticMQ covers SQS only, so it pairs with MinIO, Moto, or Floci for a full stack. Edge cases around visibility timeouts and redrive policies may differ from real SQS, so final verification should still run against real AWS. ElasticMQ fits teams with SQS-heavy workloads that want a focused, lightweight queue simulator.
What we like- SQS-focused
- FIFO and dead-letter support
- Lightweight
- Easy Docker run
Watch out for- SQS only
- No other AWS services
- Visibility timeout edge cases vary
Starting priceFree
Free planYes
DynamoDB Local is the official AWS tool for local DynamoDB development, distributed as a Java archive with Docker images available. It runs the real DynamoDB engine behavior locally, supporting tables, global and local secondary indexes, and streams, which makes it more accurate than a mock for DynamoDB-specific testing. Teams can develop and test DynamoDB code without cloud costs or network calls.
DynamoDB Local covers DynamoDB only and needs a Java runtime, and some limits and throughput behavior differ from cloud DynamoDB. It fits teams with DynamoDB-heavy workloads that want official local behavior, paired with other tools for S3, SQS, and Lambda.
What we like- Official AWS tool
- Real DynamoDB engine behavior
- Streams and indexes supported
Watch out for- DynamoDB only
- Needs Java runtime
- Some limits differ from cloud DynamoDB
How we chose
We compared these tools on service coverage, realism, migration effort from LocalStack, license, account requirements, and resource use. Guides from September and October 2026 shaped the shortlist, and we flagged every case where website fields point to project hosts rather than dedicated homepages, since several of these projects live on GitHub. We favored tools with no account requirement, since vendor-gated test execution was the core LocalStack complaint.
We also separated test layers. Unit tests need Moto speed, integration tests need Floci or MiniStack realism, and single-service depth needs MinIO, ElasticMQ, or DynamoDB Local. The right stack usually combines two tools, not one, and we ranked accordingly.
Pin versions and avoid vendor-gated test execution
Pin emulator Docker images to fixed versions rather than latest, so a vendor change cannot break CI overnight. Prefer tools that run locally without a network call to a vendor service, since test tooling is time-sensitive: CI failure blocks deploys, and you cannot negotiate from that position. Moto, Floci, and MiniStack all run without accounts.
Match the tool to the test layer
Use Moto for unit tests where speed matters, Floci or MiniStack for integration tests where a running service matters, and single-service tools where one service dominates. Mixing layers wastes effort: running a full emulator for a unit test slows CI, while mocking for an integration test hides real behavior. Map each test suite to one layer before choosing.
Verify against real AWS before release
Local emulation never matches cloud behavior perfectly, especially around IAM, limits, and service quirks. Run a final test pass against real AWS in a staging account before release, even when local tests pass. That pass catches the edge cases that emulators miss, and it costs far less than a production incident. Confirm the choice with a trial migration first.
Frequently asked questions
Why are teams leaving LocalStack in 2026?
LocalStack now requires an account and auth token, and its license moved from Apache to BSL, following the pattern of Docker Desktop, Terraform, and Elasticsearch before it. The tool remains useful, but vendor-gated test execution and license change pushed many teams to Moto, Floci, and MiniStack, which run without accounts.
What is the easiest LocalStack replacement?
Floci is easiest for Docker users, since it keeps the same port, endpoint, and SDK config with only an image swap and no auth token. Moto is easiest for Python unit tests, since it needs only a fixture change. Pick Floci for integration tests and Moto for unit tests.
Can I use Moto and Floci together?
Yes, and most teams should. Moto covers fast Python unit tests without Docker, while Floci covers integration tests with a running service. They solve different layers of the same problem, so combining them is normal, not redundant.
Is MiniStack better than Floci?
MiniStack is better for integration tests that need real databases and containers, while Floci is lighter and faster for quick emulation and CI. MiniStack runs real Postgres, MySQL, and Redis, while Floci emulates services in memory. Pick MiniStack for real-infra confidence and Floci for CI speed.
Do these tools support Terraform and CDK?
Moto is weaker for infrastructure-as-code tests, while Floci and MiniStack support Terraform, CDK, and Pulumi workflows through their endpoints. LocalStack remains relevant for advanced CDK bootstrap testing if you keep a Hobby token, but Floci and MiniStack cover most IaC cases without an account.
Sources we checked (8)
- https://github.com
- https://min.io
- https://testcontainers.com
- https://aws.amazon.com
- https://dev.to/peytongreen_dev/localstack-is-gone-floci-vs-moto-vs-testcontainers-which-one-replaces-it-c7c
- https://dev.to/peytongreen_dev/localstack-now-requires-an-account-heres-how-to-test-aws-in-python-without-one-in-2026-2153
- https://copyprogramming.com/howto/localstack-with-terraform-and-docker-for-running-aws-locally
- http://dev.to/shaam_ai/floci-the-free-open-source-localstack-alternative-that-runs-aws-on-your-laptop-2026-2dp8
Is your product missing or out of date?
We review this list regularly. Vendors can request a listing, send updated pricing or ask about featured placement.
Shihab Mia · Founder, Rankite
Shihab has 5+ years in B2B and SaaS SEO. He writes Rankite's software buying guides from pricing pages, documentation and public user reviews. More about Shihab.