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
regionand aservicesuch asEC2,S3, orCLOUDFRONT. The syntax reference saysAMAZONreturns 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. Theactionskey holds the addresses that GitHub-hosted runners use. Other keys, such ashooks,api,git, andpages, cover other GitHub services. - Google publishes two files. Per the App Engine docs,
cloud.jsonlists the external ranges available for customers' Google Cloud resources, andgoog.jsonlists every Google-owned range. - Azure publishes service tags, named groups of prefixes such as
AzureCloudorStorage.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.
| List | Entries | IPv4 addresses covered |
|---|---|---|
AWS ip-ranges.json, every service | 10,745 IPv4 prefixes (plus 7,073 IPv6) | About 102 million |
AWS EC2 service only | 1,906 prefixes | About 80 million |
AWS EC2 in ap-south-1 (Mumbai) | 56 prefixes | About 2.2 million |
GitHub meta actions | 8,350 entries (5,622 IPv4, 2,728 IPv6) | About 28.6 million |
Google cloud.json | 1,058 IPv4 prefixes (plus 95 IPv6) | About 19.4 million |
Google cloud.json, asia-south1 (Mumbai) | 34 prefixes | About 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'import ipaddress
import json
import sys
import urllib.request
def load(url):
with urllib.request.urlopen(url, timeout=30) as resp:
return json.load(resp)
def ipv4_size(cidrs):
nets = ipaddress.collapse_addresses(
ipaddress.ip_network(c) for c in cidrs if ":" not in c
)
return sum(n.num_addresses for n in nets)
aws = load("https://ip-ranges.amazonaws.com/ip-ranges.json")
gh = load("https://api.github.com/meta")
gcp = load("https://www.gstatic.com/ipranges/cloud.json")
lists = {
"AWS, every service": [p["ip_prefix"] for p in aws["prefixes"]],
"AWS EC2 in ap-south-1": [
p["ip_prefix"]
for p in aws["prefixes"]
if p["service"] == "EC2" and p["region"] == "ap-south-1"
],
"GitHub Actions": gh["actions"],
"Google Cloud": [p["ipv4Prefix"] for p in gcp["prefixes"] if "ipv4Prefix" in p],
}
for name, cidrs in lists.items():
print(f"{name}: {len(cidrs):,} entries, {ipv4_size(cidrs):,} IPv4 addresses")
# Optional: python3 cloud_ranges.py 203.0.113.10 shows which AWS ranges hold an IP.
if len(sys.argv) > 1:
ip = ipaddress.ip_address(sys.argv[1])
for p in aws["prefixes"]:
if ip in ipaddress.ip_network(p["ip_prefix"]):
print(f"{ip} is in {p['ip_prefix']} ({p['service']}, {p['region']})")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.
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.
| Range | Who sends from it | Fit as a source allowlist |
|---|---|---|
| GitHub webhook delivery addresses | GitHub's webhook delivery service | Reasonable as a filter, together with webhook signatures |
| Payment provider webhook IPs | The provider's own delivery service | Reasonable as a filter, together with signatures |
AWS EC2, Google cloud.json, Azure AzureCloud | Every customer's instances, functions, and containers | No |
GitHub actions | Every workflow on GitHub-hosted runners | No, per GitHub's own docs |
| CDN edge ranges (Cloudflare, CloudFront) | Every customer's CDN configuration | Only 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
actionslist 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 topicAmazonIpSpaceChanged, 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.
- 1Find 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.
- 2Give 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.
- 3Add 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.
- 4Watch, 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.
# Prints the IP your proxied traffic leaves from
curl --proxy "$FIXEDMARK_PROXY_URL" https://fixedmark.com/api/ipRun 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.
- AWS: AWS IP address ranges
- AWS: Syntax for AWS IP address range JSON
- AWS: AWS IP address ranges notifications
- AWS: AWS-managed prefix lists
- AWS: Restrict access to Application Load Balancers (CloudFront)
- GitHub Docs: REST API endpoints for meta data
- GitHub Docs: GitHub-hosted runners reference
- GitHub Docs: About GitHub's IP addresses
- GitHub Docs: Best practices for using webhooks
- Google Cloud: Outbound IP addresses for App Engine services
- Microsoft Learn: Azure service tags overview
- MongoDB: Atlas IP access list
- Certitude: Using Cloudflare to bypass Cloudflare

