# ec2instances.info: The Open EC2 and RDS Instance Comparison Tool by Vantage

> EC2Instances.info was built out of frustration with Amazon's own comparison pages. Now hosted by Vantage and developed by community contributors, the site pulls live pricing and instance data from AWS, Azure, and GCP APIs via a Go-based scraper, and exposes it through a Next.js front end.

**vantage-sh/ec2instances.info** — Amazon EC2 instance comparison site

- Repository: https://github.com/vantage-sh/ec2instances.info
- Website: https://instances.vantage.sh
- Stars: 5,766 · Forks: 623
- Language: TypeScript
- License: MIT
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/vantage-sh-ec2instances-info

## What ec2instances.info Is and Where It Came From

Garret Heaton created EC2Instances.info because comparing EC2 instance metrics and pricing on Amazon's own site was tedious. The project is now hosted by Vantage and developed by the community. Vantage employees are the primary maintainers and handle hosting; the contributor base extends to anyone who opens a pull request or raises an issue.

The tool lives at instances.vantage.sh. The original domain ec2instances.info is referenced in the project history, but the site is served from the Vantage-hosted address. The description says Amazon EC2 instance comparison, but the scraper covers more than EC2: it also fetches RDS and ElastiCache data from AWS, and it pulls instance data from Azure and GCP as well. The front end is a Next.js application, and the data fetching layer is written in Go.

The Slack community at vantage.sh/slack has a dedicated channel named #instances-vantage.sh for users and contributors who want to discuss the site. The README also mentions a GitHub issue tracker for feature requests and bug reports. The last push to the repository was on 2026-09-21.

This is a tool for engineers making purchasing decisions, not for operators who need real-time pricing alerts. It gives a cross-region, cross-instance-family view that the AWS console does not present without manual navigation.

## Scraper Architecture: How the Go Fetcher Pulls Cloud API Data

The scraper directory contains Go code that queries three cloud providers: AWS, Azure, and GCP. For AWS, it calls ec2:DescribeInstanceTypes, ec2:DescribeSpotPriceHistory, ec2:DescribeInstanceTypeOfferings, elasticache:DescribeEngineDefaultParameters, rds:DescribeDBEngineVersions, and rds:DescribeOrderableDBInstanceOptions. These calls require an IAM user with the appropriate permissions attached.

EC2 instance launch dates are enriched during each scrape from the public instancetyp.es timeline at instancetyp.es/timeline.json. The `date_introduced` field in the output comes from this external source, so its accuracy depends on that timeline being current.

For Azure, the scraper requires AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, and AZURE_SUBSCRIPTION_ID. For GCP, it needs GCP_PROJECT_ID, GCP_CLIENT_EMAIL, and GCP_PRIVATE_KEY. The .env file for storing these credentials is gitignored, so credentials are never committed to the repository. Once credentials are in place, the fetch step runs via:

```bash
./fetch_data.sh
```

This only needs to run when the scraper changes in a way that alters the data, or when new API data is available for testing. For typical front-end development, pulling a pre-built artifact from the staging server is the faster path.

The Makefile exposes a fetch-data target that wraps the shell script, and the full pipeline target (all) calls fetch-data as its first step. The scraper output feeds into the Next.js build, which generates a static www directory ready to deploy.

## Setting Up a Local Development Environment

Docker is required for a full build. For front-end development, nvm is recommended, though any Node version at or above the one specified in next/.nvmrc works.

The first step is installing root-level dependencies, which provides Prettier:

```bash
npm ci
```

From here, either scrape the data locally by following the credential setup in the README, or pull the latest pre-built data from the staging server:

```bash
curl -L https://instances.vantagestaging.sh/www_pre_build.tar.gz | tar -xzf -
```

To start the development server, move into the next directory and run:

```bash
nvm use
npm ci
npm run init
npm run dev
```

The npm run init step is only needed on the first run. After that, npm run dev starts the Next.js development server at the default port. Before opening a pull request, the README recommends running:

```bash
npm run check-types
```

This catches TypeScript errors before CI does. The formatting check runs separately:

```bash
make format
```

This runs both gofmt on the scraper and Prettier on the rest of the repository. Both checks run in CI before the build, so catching them locally shortens the feedback loop. Pull requests should target the develop branch, which corresponds to the staging environment. Merges to main deploy to production.

## AWS IAM Permissions the Scraper Requires

To run the scraper against AWS, an IAM user needs a specific permission set. The README provides the JSON policy directly:

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:DescribeInstanceTypes",
                "ec2:DescribeSpotPriceHistory",
                "ec2:DescribeInstanceTypeOfferings",
                "elasticache:DescribeEngineDefaultParameters",
                "rds:DescribeDBEngineVersions",
                "rds:DescribeOrderableDBInstanceOptions"
            ],
            "Resource": "*"
        }
    ]
}
```

The six actions cover on-demand EC2 instance types, spot pricing history, instance availability by region, ElastiCache engine parameters, RDS engine versions, and RDS instance options. The Resource is set to wildcard because these read-only describe calls operate on all resources within the account's regions.

AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are stored in a .env file at the repository root. That file is gitignored, so it never appears in commits. If a team member needs to onboard, they create the .env file locally from credentials generated in the AWS console. The README does not document rotating these credentials or using temporary credentials via assumed roles; the key/secret pattern is the documented path.

## Full Release Build: make all and Its Environment Variables

Development builds and full production builds are different operations. The README notes explicitly that make all is not needed for most development work and that on some setups it can interfere with file permissions in the next directory. The full release build is intended for production and staging deploys.

Running make all with the required environment variables in place triggers a pipeline that takes around 30 minutes to finish. The steps are: fetch-data (scraper run), compress-www (creates a tar archive of the output), generate-images (Docker-based OG image generation), next (Docker-based Next.js build), and write-updated-at (writes a timestamp file).

Beyond the API credentials, several environment variables affect the output. NEXT_PUBLIC_URL sets the public base URL. DENY_ROBOTS_TXT=1 prevents the build from generating a robots.txt that allows crawlers, which is relevant for staging environments. NEXT_PUBLIC_REMOVE_ADVERTS=1 strips the advertisement code from the output. OPENGRAPH_URL must point to a 1911x1156 JPEG background image for OG image generation; the default background used by Vantage is not MIT-licensed, so any non-Vantage production deployment must supply this variable.

The output is a www directory. The deploy directory in the repository contains the Cloudflare Worker and R2 push logic that Vantage uses to serve the site. Teams deploying to a different infrastructure need to adapt the routing rules the README documents for web server configuration.

## What the Site Cannot Show and Where It Falls Short

The site's data reflects the state at the last scraper run, not current pricing. Spot prices in particular can change frequently, and the stored spot history is from the last time ec2:DescribeSpotPriceHistory was called. There is no real-time feed.

Instance launch date enrichment depends on the instancetyp.es timeline. If that external source is out of date or unavailable during a scrape, the date_introduced field will not be populated for newly released instance types. The README acknowledges this dependency but does not document a fallback.

The comparison covers instance types that the scraper API calls return. AWS, Azure, and GCP all have edge cases: preview instance types, region-specific availability, and capacity reservation constraints that describe calls may not fully surface. A developer relying on this data for capacity planning should verify availability through the provider's own console or API before committing to a specific instance type.

The OG image license situation is a real constraint for self-hosters. Forgetting OPENGRAPH_URL in a production deploy does not cause a build failure; it silently uses the Vantage-owned background image, which is not permitted for third-party deployments. There is no warning in the build output.

## Repository Structure: deployment/, imagegen/, and the Makefile Targets

The top-level directories each serve a distinct purpose. The scraper/ directory holds the Go code that queries cloud APIs. The next/ directory holds the Next.js front-end application. The imagegen/ directory contains the Dockerfile and code for generating OG images via a Docker build. The deployment/ directory holds the Cloudflare Worker (deployment/index.ts) and the wrangler.jsonc configuration used to push the built output to R2 and configure the worker routing.

The Makefile defines the pipeline stages as individual targets: fetch-data, generate-images, compress-www, next, write-updated-at, gofmt, prettier, format, and all. The format target combines gofmt and prettier, making it the single command for pre-PR formatting. The all target runs the full production pipeline in dependency order.

The package.json at the root is minimal: it exists only to manage Prettier as a dev dependency at version 3.5.3. The actual Next.js dependencies live in next/package.json, which the Docker build handles. This separation means the root npm ci step only takes a moment, while the full Next.js install is deferred to the Docker environment during the production build.

## Conclusion

Engineers who regularly need to compare EC2, RDS, or ElastiCache instance pricing without digging through the AWS console will find instances.vantage.sh a practical tool for that. Running a self-hosted copy requires Docker, credentials for AWS, Azure, and GCP, and about 30 minutes for make all to finish. For production use, OPENGRAPH_URL is a required variable because the default OG image background is not MIT-licensed, and the deploy directory contains the Cloudflare Worker logic the Vantage-hosted version uses, which may not map cleanly to other hosting environments.

## FAQ

### Can ec2instances.info be self-hosted without connecting to Vantage?

Yes. The repository is MIT-licensed and the build pipeline uses your own AWS, Azure, and GCP credentials. The Vantage-specific parts are the hosted OG image background (which you must replace with OPENGRAPH_URL) and the Cloudflare Worker deploy logic in the deployment directory. The site itself runs on any web server that follows the routing rules in the README.

### Does the site include Azure and GCP instance types, or only EC2?

The scraper fetches data from all three providers. AWS, Azure, and GCP credentials are each documented in the README with their required environment variables. The front end at instances.vantage.sh surfaces this multi-cloud data, though the project originated as an EC2 comparison tool.

### How current is the pricing data on ec2instances.info?

The data reflects the most recent scraper run. There is no real-time feed. Spot price history comes from ec2:DescribeSpotPriceHistory at the time the scraper last executed. For decisions where current pricing matters, verifying against the AWS console or API is advisable.

## Sources

- [Issues](https://github.com/vantage-sh/ec2instances.info/issues)
- [License: MIT](https://github.com/vantage-sh/ec2instances.info/blob/main/LICENSE)
- [Project website](https://instances.vantage.sh)
- [README](https://github.com/vantage-sh/ec2instances.info/blob/main/README.md)
- [vantage-sh/ec2instances.info on GitHub](https://github.com/vantage-sh/ec2instances.info)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/vantage-sh-ec2instances-info