Skip to main content
株式会社オブライト
株式会社オブライト

What Is AWS Emulator? AWS's Official Local Emulator of the AWS APIs

Rust, Free, No AWS Account (vs LocalStack, fakecloud, MiniStack, Moto)

Published 2026/11/1611 min read

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

FeatureDetails
Local AWS APIsOne 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 AWSCreating a DynamoDB table with a name under 3 characters is rejected with the same ValidationException as AWS (official example)
Explicit gapsUnimplemented operations return HTTP 501 with error code NotImplemented, so tests fail immediately
Server modeNative on Linux (RPM/deb); in a Docker container on macOS and Windows
Embedded modeRuns inside a Rust test process; each test gets its own state, so tests can run in parallel
Skill for AI agentsThe aws-emulator skill installs, starts and connects the emulator and checks whether your project works on it
Published fidelity scoresPer-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'.

ServicePassing / totalPass rate
Amazon S32,061 / 2,845~72%
Amazon DynamoDB1,542 / 2,142~72%
Amazon SQS1,190 / 1,536~77%
Amazon SNS557 / 641~87%
AWS Lambda1,912 / 3,021~63%
AWS IAM830 / 1,238~67%
AWS STS163 / 261~62%
AWS KMS423 / 510~83%
AWS Secrets Manager345 / 444~78%
Amazon CloudWatch Logs857 / 1,235~69%
Amazon API Gateway (REST)898 / 1,219~74%
AWS Step Functions772 / 987~78%
Amazon EC21,246 / 2,499~50%
AWS CloudFormation973 / 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

MethodDetails
PriceNo additional service fee; you pay only for AWS resources you deploy on AWS
LicenseCC0-1.0 (vendor/ is Apache License 2.0)
LinuxRPM/deb packages (x86_64, aarch64); installs the aws-emulator command in /usr/bin/
macOS / WindowsNo 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 agentaws agent-toolkit add-skill --skill-name aws-emulator (AWS CLI 2.35.0 or later)
Build from sourceLinux 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-emulator

Quick 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

ItemAWS EmulatorLocalStackfakecloudMiniStackMoto
PublisherAWS (official)LocalStackfaiscadevministackorggetmoto
LicenseCC0-1.0Old OSS repo is Apache-2.0 (archived March 23, 2026)AGPL-3.0MITApache-2.0
ImplementationRustNot confirmed on the official pageSingle binaryPythonPython
CoverageServices with an AWS API model (no count stated officially)Not confirmed on the official page105 services60+Not confirmed on the official page
Default port9297 (HTTPS)456645664566 (change with GATEWAY_PORT)5000 (server mode)
Account / registrationNot neededReported to require registration for the free tier (InfoQ)Not neededNot neededNot needed
AuthenticationSigV4 required by default (keys regenerated each start)Not confirmed on the official pageNo tokenAny non-numeric key worksNot confirmed on the official page
How to runRPM/deb, Docker, Rust embeddedDockerSingle binarypip, Dockerpip, Docker, decorator (mocking)
Published fidelityPer-service scores with each releaseNot confirmed on the official pageNot confirmed on the official pageNot confirmed on the official pageNot 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.

Feel free to contact us

Contact Us