Skip to content
Fixedmark

Platforms · 11 min read

Updated

Cloud IP Ranges Are Not an Allowlist

Allowlisting a cloud's published IP ranges lets in every customer of that cloud, not only you. On 10 November 2026, AWS's `ip-ranges.json` held 10,745 IPv4 prefixes covering about 102 million addresses, and anyone with an account can rent one of them. A real allowlist names a few addresses that only you control, such as Elastic IPs on a NAT gateway or a dedicated static IP pair.

On this page

What the cloud range files contain

Every large cloud publishes the address blocks it owns. The files are public, machine-readable, and updated on a schedule. They exist so that you can recognise traffic from the provider and write egress rules toward its services. They were never meant to tell you which customer sent a packet.

  • AWS publishes ip-ranges.json. Each prefix has a region and a service such as EC2, S3, or CLOUDFRONT. The syntax reference says AMAZON returns all ranges, so every other subset is also in it. AWS also states that it does not publish ranges for all services.
  • GitHub publishes its ranges through the meta API at https://api.github.com/meta. The actions key holds the addresses that GitHub-hosted runners use. Other keys, such as hooks, api, git, and pages, cover other GitHub services.
  • Google publishes two files. Per the App Engine docs, cloud.json lists the external ranges available for customers' Google Cloud resources, and goog.json lists every Google-owned range.
  • Azure publishes service tags, named groups of prefixes such as AzureCloud or Storage.WestUS, as weekly JSON downloads and through an API.

Note the Google wording. The cloud.json ranges are available for customers' resources. They are where customer workloads live, and you are one customer among many.

How big the lists are

Numbers make the problem concrete. We downloaded each file on 10 November 2026 and collapsed overlapping prefixes before counting IPv4 addresses. Your numbers will differ by the time you read this, because the files change every week.

Published cloud ranges on 10 November 2026
ListEntriesIPv4 addresses covered
AWS ip-ranges.json, every service10,745 IPv4 prefixes (plus 7,073 IPv6)About 102 million
AWS EC2 service only1,906 prefixesAbout 80 million
AWS EC2 in ap-south-1 (Mumbai)56 prefixesAbout 2.2 million
GitHub meta actions8,350 entries (5,622 IPv4, 2,728 IPv6)About 28.6 million
Google cloud.json1,058 IPv4 prefixes (plus 95 IPv6)About 19.4 million
Google cloud.json, asia-south1 (Mumbai)34 prefixesAbout 383,000

The AWS file alone covers roughly 2.4 percent of the entire IPv4 address space. Even the narrowest slice in the table, one Google region, is hundreds of thousands of addresses. An allowlist entry for a single server is one address, written as a /32.

Count them yourself

These commands read the live files. The script uses only the Python standard library and also reports which AWS ranges contain a given IP, which is handy when a firewall rule mentions an address you do not recognise.

# AWS: IPv4 prefixes, then EC2 prefixes in Mumbai
curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq '.prefixes | length'
curl -s https://ip-ranges.amazonaws.com/ip-ranges.json \
  | jq '[.prefixes[] | select(.service=="EC2" and .region=="ap-south-1")] | length'

# GitHub Actions runner ranges (IPv4 and IPv6)
curl -s https://api.github.com/meta | jq '.actions | length'

# Google Cloud customer ranges, IPv4 only
curl -s https://www.gstatic.com/ipranges/cloud.json \
  | jq '[.prefixes[] | select(.ipv4Prefix)] | length'

Who else sends traffic from those ranges

An IP allowlist answers one question. Did this connection come from a source I trust? A cloud range answers a different one. Did this connection come from somewhere on this provider's network? Those questions only match when you are the provider's only customer.

Think about what it takes to get an address inside each list. For the AWS EC2 ranges in Mumbai, an attacker signs up for an AWS account, launches a small instance in ap-south-1, and is inside your allowlist. For GitHub's actions ranges, they push a workflow to a repository they own and the job runs on a GitHub-hosted runner. For cloud.json, they deploy a Cloud Run service. None of these steps targets you, and none needs your help.

The providers say this plainly. GitHub's hosted runner reference states, "we do not recommend that you use these as allowlists for your internal resources", and suggests larger runners with a static IP range or self-hosted runners instead. Its page on GitHub's IP addresses adds that hosted runners use dynamically assigned addresses from shared infrastructure. Microsoft's service tag overview says, "In most scenarios, we don't recommend allowing traffic from all Azure IPs since IPs used by other Azure customers are included as part of the service tag."

So a range allowlist does not stop an attacker. It changes the cost of reaching your service from zero to the price of a cloud account. For a database, an SSH port, or an admin API, that is close to no protection at all. Whatever sits behind the firewall (a password, a token, an unpatched service) is now the only real control, and you have told yourself there is a second one.

Narrowing to one region or one service helps less than it looks. The Mumbai slice of EC2 is still about 2.2 million addresses, and it is exactly the slice an attacker targeting an Indian company would rent from.

The CDN version of the same mistake

A common setup puts a CDN in front of an origin server and lets the origin accept only the CDN's addresses. The idea is that all traffic must pass through the CDN's WAF and rate limits. The CDN's edge, though, is shared by every customer of that CDN.

In September 2023, Certitude published Using Cloudflare to bypass Cloudflare. Their point was simple. An origin that only allowlists Cloudflare's IP ranges accepts connections from Cloudflare regardless of tenant. An attacker adds their own domain to their own Cloudflare account, points it at the victim's origin IP, turns off protections for that domain, and sends traffic through Cloudflare. The victim's firewall sees a Cloudflare address and lets it in. Certitude reported that Cloudflare first closed the report as informative, then raised it to high severity and said it would steer customers toward per-zone or per-hostname Authenticated Origin Pulls with custom certificates. Certitude's own advice is to treat the IP allowlist as defence in depth, not the only control.

AWS gives the same advice for CloudFront. Its guide to restricting access to Application Load Balancers leads with a secret custom header that CloudFront adds and the load balancer checks. The managed prefix list com.amazonaws.global.cloudfront.origin-facing appears as an optional extra layer. The guide also tells you to treat the header value like a password and rotate it. The pattern is the same in both cases. The IP range proves the request came through the CDN, and a secret proves it came through your distribution.

When a published range is the right tool

Published ranges are not useless. The question to ask about any range is who can make traffic originate from it. If only the provider's own code sends from those addresses, the range identifies the provider well. If any customer's code can run there, it identifies nobody.

Who can send from a published range
RangeWho sends from itFit as a source allowlist
GitHub webhook delivery addressesGitHub's webhook delivery serviceReasonable as a filter, together with webhook signatures
Payment provider webhook IPsThe provider's own delivery serviceReasonable as a filter, together with signatures
AWS EC2, Google cloud.json, Azure AzureCloudEvery customer's instances, functions, and containersNo
GitHub actionsEvery workflow on GitHub-hosted runnersNo, per GitHub's own docs
CDN edge ranges (Cloudflare, CloudFront)Every customer's CDN configurationOnly with a per-customer secret or certificate on top

GitHub's webhook best practices recommend an IP allow list of its delivery addresses and a webhook secret with high entropy. The signature is what proves the payload came from GitHub. The IP filter just keeps random scanners away from your handler. The same logic applies to Razorpay, Stripe, or Cashfree callbacks, covered in allowlisting payment webhook source IPs.

Egress filtering is the other legitimate use, and it is the one AWS describes first. You can let your own private workloads reach AWS service endpoints and nothing else by allowing outbound traffic to the AMAZON ranges. That rule decides where your traffic may go. It says nothing about who may reach you.

The upkeep a range allowlist needs

Even before security, big range lists are hard to run. They do not fit the tools that enforce them, and they change under you.

  • Rule limits. An AWS security group has a default quota of 60 rules. The CloudFront origin-facing prefix list alone has a weight of 55, which leaves room for 5 more rules. Thousands of prefixes need many groups, quota increases, or a different firewall.
  • SaaS access lists are smaller still. A MongoDB Atlas project allows up to 200 IP access list entries, and many partner portals want each address typed into a form. A list of thousands of prefixes does not go in.
  • Churn. GitHub updates the actions list once a week and asks you to keep allowlists in sync with every range in it. Azure publishes service tag files weekly and holds new addresses back for at least a week so you can catch up. AWS announces each change on the SNS topic AmazonIpSpaceChanged, per its notification docs.
  • Silent breakage. When a sync job fails, the allowlist goes stale. The next deploy or job lands on a new address and fails with a timeout that looks like a network fault, not a firewall rule.
  • Incomplete coverage. AWS notes that it does not publish ranges for every service, and it can advertise a published prefix as more specific ranges. A list you trust as complete can still miss the address your code uses today.

So a cloud-range allowlist gives you the operational cost of a large, moving list and the security of no list. That is the worst combination available.

What a fixed-IP allowlist gives you instead

A real allowlist entry is an address that only your traffic can leave from. On AWS that is an Elastic IP on a NAT gateway or instance in your own VPC. On Google Cloud it is a static address reserved for Cloud NAT. For CI it is a self-hosted runner or a larger runner with a static range. For serverless and PaaS apps whose platforms share egress addresses (see why serverless egress IPs change), it is usually a dedicated static IP proxy for the calls that need it.

  • Attribution. A connection from your address is from your workload. Logs on the partner side mean something.
  • A short list. Two entries fit in any security group, any database access list, and any bank onboarding form.
  • Change control. The address changes only when you change it, so the list does not need a sync job.
  • Availability without sprawl. Two addresses on separate hosts give you failover, which is why many partners ask for a primary and a secondary IP. The tradeoffs are in static IP pairs and failover.

Check that the address really is yours alone. Some static IP services put many customers on one shared pair. That is a far smaller crowd than a cloud range, but the receiving side still cannot tell those customers apart. Ask whether the address is dedicated before you hand it to a bank or a broker.

A fixed IP is still one layer. Keep the TLS, the API key or token, and the signed requests behind it. The case for combining them is in IP allowlists in a zero trust world. What the fixed IP adds is that a stolen credential is useless from anywhere else.

Moving off a cloud-range allowlist

If a firewall already holds a cloud's ranges, you can replace them without an outage. Work from evidence, not memory.

  1. 1
    Find who uses the ruleTurn on flow logs or firewall logs for the rule and record the source addresses that match over a week or two. Each address maps to a workload you can name, such as a deploy job, a Lambda function, or a partner integration.
  2. 2
    Give each caller a fixed egressMove each workload behind an address you control. That might be a NAT gateway with an Elastic IP, a self-hosted runner, or a proxy for only the calls that reach this firewall. The GitHub Actions deploys and NAT gateway alternatives posts cover the options.
  3. 3
    Add the new addresses as /32 entriesAdd each fixed address next to the old ranges. Confirm from the workload itself that it now leaves from the new address, for example by calling an IP echo endpoint through the same client.
  4. 4
    Watch, then remove the rangesKeep logging until no traffic matches the broad ranges for a full cycle of your slowest job, such as a weekly report. Then delete the range rules and keep the /32 entries.

Doing this with Fixedmark

Fixedmark gives serverless and PaaS apps a static outbound IP pair. Your app sends the calls that need a fixed address through one proxy URL, over HTTP CONNECT or SOCKS5, and the partner allowlists two /32 entries instead of a cloud's ranges. TLS passes through end to end. Fixedmark is in early access and not generally available yet.

The same rule from this post applies to us. The Starter plan ($9 a month, planned launch price) and the 7-day trial run on a shared IP pair, so other Fixedmark customers send from those addresses too. Do not register a shared pair with a bank, broker, or partner that needs an address only you use. The Pro plan ($29 a month, planned launch price) gives you a dedicated pair reserved for your account. Business and larger plans add destination allowlists, which limit each proxy credential to the hosts and ports you list. Prices and plans are on the pricing page.

Before you send the addresses to anyone, confirm the egress IP from your app's environment, as the verify egress IP guide shows.

Terminal
# Prints the IP your proxied traffic leaves from
curl --proxy "$FIXEDMARK_PROXY_URL" https://fixedmark.com/api/ip

Run the same command without --proxy and you will see your platform's own egress address. Pass it to the script above and it will often land inside one of the large cloud ranges. That is the address you were about to allowlist, along with everyone else on the same network.

Sources

Checked November 2026. Confirm current details on the vendor's site before you decide. Prices and limits change.

Blog

Frequently asked questions

Is it safe to allowlist AWS ip-ranges.json for my database?

No. The file lists the ranges every AWS customer uses, about 102 million IPv4 addresses in November 2026. Anyone can launch an instance inside them. Allowlist the specific Elastic IPs or static IPs your own workloads leave from.

Can I allowlist GitHub Actions IP ranges for deploys?

GitHub recommends against it. Its docs say not to use the `actions` ranges as allowlists for internal resources, because hosted runners share infrastructure with every other workflow. Use larger runners with a static IP range, self-hosted runners, or a fixed-IP proxy for the deploy step.

Does restricting to one region or one service fix the problem?

It shrinks the list but not the risk. AWS `EC2` in `ap-south-1` alone was about 2.2 million addresses in November 2026, and any customer can rent one of them in minutes.

Is allowlisting a vendor's webhook IPs the same mistake?

Not quite. Webhook ranges, such as the addresses GitHub publishes for webhook deliveries, are used by the vendor's own delivery service, not by customer code. They make a reasonable filter, but you should still verify the webhook signature on every request.

Is a shared static IP better than a cloud range?

It is a much smaller group, but the receiving side still cannot tell the customers on it apart. For banks, brokers, and partners that need an address only you use, ask for a dedicated IP.

Make it fixed.

Fixedmark is in early access. Join the list to get dedicated static IPs when your region opens.