What Is AWS Emulator? AWS's Official Local Emulator of the AWS APIs
Rust, Free, No AWS Account (vs LocalStack, fakecloud, MiniStack, Moto)
AWS Emulator is a local emulator of the AWS APIs published by AWS itself. Written in Rust, with no extra fee and no AWS account needed, it runs on your laptop or in CI. This guide covers installation, per-service fidelity scores, and how it differs from LocalStack, fakecloud, MiniStack and Moto. Updated Nov 2026.
AWS Emulator is a local emulator of the AWS APIs, published by AWS itself. You run it on your own machine, a dev server or in CI, point the AWS CLI or an SDK at it, and test your AWS-dependent code with no AWS account and no extra fee. It has no GUI and is positioned as a tool for building and testing, not for production or security testing.
AWS announced it on the AWS News Blog on November 11, 2026 (by Daniel Abib, a senior specialist solutions architect at AWS; updated November 12). As of November 16, 2026 the GitHub repository (aws/aws-emulator) has about 8,400 stars, is licensed CC0-1.0 (only the vendor/ directory is Apache License 2.0) and is written in Rust. It was posted to Hacker News on November 11 and collected 991 points.
Why it is getting attention now
The main reason is that AWS itself shipped it. Local AWS testing used to be left to third parties such as LocalStack; now the vendor offers a free tool for the same job. According to the official documentation, AI agents keep the emulator in step with AWS changes, and releases land many times a day (the GitHub releases page lists v1.0.351 through v1.0.385 on November 14, 2026 alone).
LocalStack's change of course is part of the background. InfoQ reported on February 15, 2026 that LocalStack would merge Community and Pro into one image that requires registration, with paid plans starting at $39 per license per month; its GitHub repository was archived (read-only) on March 23, 2026. fakecloud and MiniStack are among the projects filling that gap, and now AWS has joined them.
What it can do
| Feature | Details |
|---|---|
| Local AWS APIs | One HTTPS endpoint (default https://127.0.0.1:9297) that serves the APIs of services that have a published AWS API model |
| Same errors as AWS | Creating a DynamoDB table with a name under 3 characters is rejected with the same ValidationException as AWS (official example) |
| Explicit gaps | Unimplemented operations return HTTP 501 with error code NotImplemented, so tests fail immediately |
| Server mode | Native on Linux (RPM/deb); in a Docker container on macOS and Windows |
| Embedded mode | Runs inside a Rust test process; each test gets its own state, so tests can run in parallel |
| Skill for AI agents | The aws-emulator skill installs, starts and connects the emulator and checks whether your project works on it |
| Published fidelity scores | Per-service pass counts are published with each release; the tests live in the aws-emulator-evaluation-suite repository |
The supported services and their fidelity can be read from scores.json.gz, attached to each release (v1.0.385, dated November 14, 2026, commit 813af48). I tallied that file: 28,505 of 43,548 test units pass (about 65%), spanning roughly 350 service identifiers. The table below shows the major services. A test that touches several services is counted under each of them, so the counting differs slightly from the official per-service 'k of n'.
| Service | Passing / total | Pass rate |
|---|---|---|
| Amazon S3 | 2,061 / 2,845 | ~72% |
| Amazon DynamoDB | 1,542 / 2,142 | ~72% |
| Amazon SQS | 1,190 / 1,536 | ~77% |
| Amazon SNS | 557 / 641 | ~87% |
| AWS Lambda | 1,912 / 3,021 | ~63% |
| AWS IAM | 830 / 1,238 | ~67% |
| AWS STS | 163 / 261 | ~62% |
| AWS KMS | 423 / 510 | ~83% |
| AWS Secrets Manager | 345 / 444 | ~78% |
| Amazon CloudWatch Logs | 857 / 1,235 | ~69% |
| Amazon API Gateway (REST) | 898 / 1,219 | ~74% |
| AWS Step Functions | 772 / 987 | ~78% |
| Amazon EC2 | 1,246 / 2,499 | ~50% |
| AWS CloudFormation | 973 / 4,282 | ~23% |
According to the docs, the emulator matches AWS most closely on control-plane APIs (create, describe, update, delete, list), while data-plane fidelity and support for IaC tools such as CloudFormation, Terraform and the CDK vary by service; the low CloudFormation rate above fits that. Scores are snapshots whose denominators change as tests are added, and they are only comparable between runs of the same test-suite version.
Installation and pricing
| Method | Details |
|---|---|
| Price | No additional service fee; you pay only for AWS resources you deploy on AWS |
| License | CC0-1.0 (vendor/ is Apache License 2.0) |
| Linux | RPM/deb packages (x86_64, aarch64); installs the aws-emulator command in /usr/bin/ |
| macOS / Windows | No prebuilt image is published; build one yourself from the official Dockerfile |
| Embedded (Rust) | Add the aws-emulator-embedded crate to [dev-dependencies] as a Git dependency, pinned to a release commit via rev |
| AI agent | aws agent-toolkit add-skill --skill-name aws-emulator (AWS CLI 2.35.0 or later) |
| Build from source | Linux x86_64/aarch64; needs 100 GB or more free disk for target/ and a long build |
# Debian-family (amd64), as in the official steps
curl -fsSLo aws-emulator.deb https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb
aws-emulator -v
# Start (default: HTTPS on 127.0.0.1:9297)
aws-emulatorQuick start
- Start the emulator (aws-emulator on Linux; on macOS/Windows, run the Docker image you built with -p 127.0.0.1:9297:9297). Each start generates a new access key and a self-signed certificate, written to ~/.aws/emulator/9297/
- In another shell, set the environment variables: AWS_ENDPOINT_URL for the endpoint, AWS_CA_BUNDLE for the certificate, AWS_SHARED_CREDENTIALS_FILE for credentials
- unset any variable that could carry real AWS credentials (AWS_ACCESS_KEY_ID and so on); otherwise the SDK signs with them and the emulator rejects the request
- Run aws sts get-caller-identity to confirm where you are connected; on the emulator Account is 000000000000
- Run your SDK or CLI as usual; your code needs no endpoint or credentials
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE
aws s3api create-bucket --bucket amzn-s3-demo-bucket
aws sts get-caller-identity# Embedding in Rust tests (Cargo.toml)
[dev-dependencies]
aws-emulator-embedded = { git = "https://github.com/aws/aws-emulator", rev = "<commit>" }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
// In the test: hand the emulator's HTTP client and credentials to the SDK config
let emulator = AwsEmulatorEmbedded::new(EmbeddedOptions::default());
let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
.http_client(emulator.http_client())
.region(aws_config::Region::new("us-east-1"))
.credentials_provider(emulator.aws_credentials_provider())
.load()
.await;How it differs from existing tools
| Item | AWS Emulator | LocalStack | fakecloud | MiniStack | Moto |
|---|---|---|---|---|---|
| Publisher | AWS (official) | LocalStack | faiscadev | ministackorg | getmoto |
| License | CC0-1.0 | Old OSS repo is Apache-2.0 (archived March 23, 2026) | AGPL-3.0 | MIT | Apache-2.0 |
| Implementation | Rust | Not confirmed on the official page | Single binary | Python | Python |
| Coverage | Services with an AWS API model (no count stated officially) | Not confirmed on the official page | 105 services | 60+ | Not confirmed on the official page |
| Default port | 9297 (HTTPS) | 4566 | 4566 | 4566 (change with GATEWAY_PORT) | 5000 (server mode) |
| Account / registration | Not needed | Reported to require registration for the free tier (InfoQ) | Not needed | Not needed | Not needed |
| Authentication | SigV4 required by default (keys regenerated each start) | Not confirmed on the official page | No token | Any non-numeric key works | Not confirmed on the official page |
| How to run | RPM/deb, Docker, Rust embedded | Docker | Single binary | pip, Docker | pip, Docker, decorator (mocking) |
| Published fidelity | Per-service scores with each release | Not confirmed on the official page | Not confirmed on the official page | Not confirmed on the official page | Not confirmed on the official page |
As a rule of thumb: pick AWS Emulator when you want behavior close to AWS, matching error messages, or in-process use from Rust tests. If you already have test setups built around port 4566 and LocalStack-style configuration, fakecloud or MiniStack, which also use port 4566, are lighter swaps. If you only need Python unit tests, Moto's decorator is the quickest. Note that AWS Emulator uses self-signed HTTPS with keys that change on every start, so HTTP-based setups need rewriting.
Caveats and who it suits
- Not for production or security testing: it does not evaluate IAM policies or resource policies (bucket policies, KMS key policies) the way AWS does, so a request AWS denies can succeed
- One Region, one account: resources are not separated by Region or account (the account ID is 000000000000); to test several Regions, run one emulator per port
- In-memory only: everything is lost when it stops. Long-running use and load testing are untested, and it uses about 160 MiB when idle
- Fidelity varies by service: as the table shows, pass rates range from about 23% to about 87%. Check the scores for the services you use, and the known gaps under issues/, first
- Certificate setup: Node.js needs NODE_EXTRA_CA_CERTS, Java a PKCS12 trust store, Rust and .NET SSL_CERT_FILE, and so on. For S3, use 127.0.0.1, not localhost
- S3 Control does not reach it: the SDK puts the account ID in the host name, so S3 Control requests cannot reach the emulator (per the docs)
- Run only code you trust: when it runs code such as Lambda functions, that code is not isolated from your machine and can read and write your files with your permissions
- Telemetry is on by default: it sends anonymous usage and error data; per the docs it never includes request contents or credentials, and you can turn it off with --telemetry off or EMULATOR_TELEMETRY=off
- No pull requests: bugs go to GitHub Issues; security issues go to HackerOne or aws-security@amazon.com
- Who it suits: teams that want to run AWS-dependent code in CI without an account, people writing tests in Rust, and anyone letting an AI coding agent try AWS-targeted apps locally
FAQ
Is AWS Emulator free? Do I need an AWS account?
Per the official docs there is no additional service fee and no AWS account is required. You pay only for AWS resources you deploy on AWS. The license is CC0-1.0 (the vendor directory is Apache License 2.0).
Can I use it as a drop-in replacement for LocalStack?
Not necessarily. AWS Emulator listens on HTTPS port 9297 by default and generates new keys and a self-signed certificate on each start, so you need to set environment variables and trust the certificate. Test setups that assume port 4566 will not work unchanged. Coverage and scores also differ by service, so try it with the services you actually use.
Can I use S3, DynamoDB, SQS and Lambda?
Scores are published for all of them. In my tally of the v1.0.385 scores.json.gz, about 72% of S3 tests, 72% of DynamoDB, 77% of SQS, 87% of SNS and 63% of Lambda tests pass. Unimplemented operations fail explicitly with HTTP 501 (NotImplemented).
Does it run on Windows and macOS?
Yes, but through Docker rather than natively. AWS does not publish a prebuilt image; you build one from the Dockerfile in the official docs. The docs advise publishing the port to the local machine only, for example with -p 127.0.0.1:9297:9297.
Can I use it from languages other than Rust?
In server mode, yes: the AWS CLI and SDKs such as Python, JavaScript, Go, Java and .NET can be pointed at the endpoint with environment variables. Embedded mode, which runs the emulator inside your test process, is for tests that use the AWS SDK for Rust.
How do I use it with an AI coding agent?
With AWS CLI 2.35.0 or later, run aws agent-toolkit add-skill --skill-name aws-emulator. This installs the aws-emulator skill, which lets an agent install, start and connect the emulator and check whether your project works on it.
Summary
AWS Emulator is a free local emulator of the AWS APIs from AWS itself, letting you run AWS-dependent tests in CI and on laptops without an account. Its strength is that fidelity scores are published per service and per release, so you can check with numbers how far the services you use will work. On the other hand it cannot verify IAM or other policies, and scores differ widely between services.
A realistic approach is to check the scores for the services your project uses before adopting it, and to always verify on real AWS before production. For background on AWS setup and cost, see the AWS guide for small businesses and the AWS cost optimization article. Support for building and migrating on AWS is also available through Cloud Infrastructure.
References (primary sources)
- https://github.com/aws/aws-emulator
- https://github.com/aws/aws-emulator/releases
- https://aws.amazon.com/blogs/aws/test-your-applications-against-aws-locally-with-aws-emulator/
- https://docs.aws.amazon.com/emulator/latest/userguide/what-is-service.html
- https://docs.aws.amazon.com/emulator/latest/userguide/fidelity.html
- https://docs.aws.amazon.com/emulator/latest/userguide/point-sdk-to-emulator.html
- https://docs.aws.amazon.com/emulator/latest/userguide/security.html
- https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-linux.html
- https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-docker.html
- https://docs.aws.amazon.com/emulator/latest/userguide/getting-started-embedded.html
- https://github.com/ministackorg/ministack
- https://docs.getmoto.org/en/latest/docs/server_mode.html
- https://github.com/localstack/localstack
- https://www.infoq.com/news/2026/02/localstack-aws-community
株式会社オブライト
Oflight Inc. is a Tokyo-based IT company providing software development, digital signage, web development, network systems, and IoT/AR/VR technology services.
Related free tools (no sign-up, instant results)
Feel free to contact us
Contact Us