AWS cross-AZ data transfer cost: find the services that pay twice

You pay for cross-AZ data transfer twice: the sender is billed for outbound bytes and the receiver for inbound bytes, both under the DataTransfer-Regional-Bytes usage type in your Cost and Usage Report. This charge applies to traffic between private IPs in different Availability Zones within the same AWS region.

Why is my cross-AZ data transfer bill so high?

You’re billed for every gigabyte that crosses an AZ boundary, even if it’s within your VPC. Common sources include EKS pods calling a database or cache in another zone, Kafka consumers reading from a broker in a different AZ, and Network Load Balancers with cross-zone load balancing enabled. Traffic within a single AZ is free. Some paths are exempt: ALB-to-target traffic, RDS Multi-AZ replication, and gateway VPC endpoints for S3 and DynamoDB do not incur this charge.

How do I find cross-AZ traffic in Cost Explorer?

Open Billing and Cost Management > Cost Explorer. Filter Usage type to DataTransfer-Regional-Bytes for your region (e.g., USE1-DataTransfer-Regional-Bytes). Set granularity to Monthly and group by Linked Account, then switch to Usage Type. Most of this cost appears under EC2-Other, making it easy to overlook.

Export your Cost and Usage Report to Athena and run this query to find the top paying resources last month:

SELECT
  line_item_resource_id,
  SUM(line_item_usage_amount)   AS gb,
  SUM(line_item_unblended_cost) AS cost
FROM cur
WHERE line_item_usage_type LIKE '%DataTransfer-Regional-Bytes'
  AND line_item_usage_start_date >= TIMESTAMP '2026-10-01'
  AND line_item_usage_start_date <  TIMESTAMP '2026-11-01'
GROUP BY 1
ORDER BY cost DESC
LIMIT 20;

The resource ID tells you who paid, but not who they talked to. To find the full path, enable VPC Flow Logs with the az-id, pkt-srcaddr, and pkt-dstaddr fields. Send logs to S3 in Parquet format for direct Athena querying.

Create the flow log with this command:

aws ec2 create-flow-logs \
  --resource-type VPC --resource-ids vpc-0123456789abcdef0 \
  --traffic-type ALL \
  --log-destination-type s3 \
  --log-destination arn:aws:s3:::my-flow-logs-bucket/ \
  --log-format '${version} ${account-id} ${interface-id} ${az-id} ${pkt-srcaddr} ${pkt-dstaddr} ${srcport} ${dstport} ${protocol} ${bytes} ${packets} ${start} ${end} ${flow-direction} ${action}' \
  --destination-options FileFormat=parquet,HiveCompatiblePartitions=true,PerHourPartition=true

Export your subnets’ CIDRs and AZ IDs:

aws ec2 describe-subnets \
  --query 'Subnets[].[CidrBlock,AvailabilityZoneId]' \
  --output text | tr '\t' ',' > subnet_az.csv

Upload subnet_az.csv to S3 and create a table in Athena. Then run this query to find top cross-AZ flows:

SELECT
  f.az_id       AS source_az,
  d.az_id       AS destination_az,
  f.pkt_srcaddr AS source_ip,
  f.pkt_dstaddr AS destination_ip,
  ROUND(SUM(f.bytes) / 1e9, 1) AS gb
FROM vpc_flow_logs f
JOIN subnet_az d
  ON contains(d.cidr, CAST(f.pkt_dstaddr AS IPADDRESS))
WHERE f.year = '2026' AND f.month = '11'
  AND f.flow_direction = 'egress'
  AND f.action = 'ACCEPT'
  AND f.az_id <> d.az_id
GROUP BY 1, 2, 3, 4
ORDER BY gb DESC
LIMIT 20;

Map IPs to owners with aws ec2 describe-network-interfaces or kubectl get pods -A -o wide.

Check your own bill in 2 minutes: https://revelations.consulting/checker?utm_source=blog&utm_medium=organic&utm_content=blog-aws-cross-az-data-transfer-cost

How do I cut cross-AZ costs without breaking anything?

Start with Kubernetes Services of type ClusterIP. On Kubernetes 1.27 and later, set the service.kubernetes.io/topology-mode: Auto annotation on the Service. kube-proxy then prefers endpoints in the caller's Availability Zone. Clusters on 1.23-1.26 ignore this annotation and read the older topology-aware-hints annotation (value auto) instead.

apiVersion: v1
kind: Service
metadata:
  name: my-service
  annotations:
    service.kubernetes.io/topology-mode: Auto
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP

With the annotation in place, the EndpointSlice controller sets hints.forZones on each endpoint in the Service's EndpointSlices. kube-proxy on a node in a given zone routes only to endpoints whose hints.forZones includes that zone. Check the hints and the Service's events:

kubectl get endpointslices -n my-namespace -l kubernetes.io/service-name=my-service \
  -o jsonpath='{range .items[*].endpoints[*]}{.addresses[0]}{"\t"}{.zone}{"\t"}{.hints.forZones[*].name}{"\n"}{end}'
kubectl get events -n my-namespace --field-selector involvedObject.kind=Service,involvedObject.name=my-service

If the third column shows zone names, the hints are active. If the column is empty, topology-aware routing is off for that Service and traffic goes cluster-wide. The Auto heuristic drops hints when a zone has no endpoints, when a node lacks the topology.kubernetes.io/zone label, when there are too few endpoints for the number of zones, or when a zone's share of endpoints is out of proportion to its share of allocatable CPU. Each time hints are removed, the controller records a TopologyAwareHintsDisabled event on the Service, so check events after every rollout and scaling change.

On Kubernetes 1.31 and later (beta and on by default; GA in 1.33), the Service field trafficDistribution: PreferClose is a simpler alternative. kube-proxy prefers endpoints in the caller's zone and uses other zones only when the local zone has no ready endpoints. PreferClose ignores capacity: if a zone has many callers and few pods, those pods take that zone's load and can overload. Use one mechanism per Service; if both are set, the topology-mode annotation wins.

spec:
  trafficDistribution: PreferClose

Apply topology spread constraints to ensure even pod distribution across zones before enabling topology mode:

spec:
  template:
    spec:
      topologySpreadConstraints:
      - maxSkew: 1
        topologyKey: topology.kubernetes.io/zone
        whenUnsatisfiable: ScheduleAnyway
        labelSelector:
          matchLabels:
            app: my-app

Roll out one Service at a time. Monitor per-zone CPU, p99 latency, and error rates for seven days after each change. Check pod placement:

kubectl get nodes -L topology.kubernetes.io/zone
kubectl get pods -n my-namespace -l app=my-app -o wide

If one zone becomes overloaded, remove the annotation and revert to cluster-wide routing.

For RDS, Aurora, or ElastiCache, run read replicas in each AZ your app uses. Point clients in each zone to the replica in that zone using the instance endpoint or a custom Aurora endpoint. RDS Multi-AZ replication traffic is not billed as data transfer, leave it alone.

For MSK, set client.rack to the AZ ID (e.g., use1-az1) and configure replica.selector.class=org.apache.kafka.common.replica.RackAwareReplicaSelector in the broker config. For Valkey GLIDE, use the AZ-affinity read strategy.

For Network Load Balancers, check cross-zone load balancing:

aws elbv2 describe-load-balancer-attributes --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/my-nlb/abc123def4567890

Look for load_balancing.cross_zone.enabled. Turn it off only if every enabled AZ has enough healthy targets.

What it usually looks like

Three patterns account for most cross-AZ traffic. First, a database or cache in one AZ serving pods spread evenly across three AZs, every request from the other two zones crosses a boundary. Second, a Kubernetes Service with replicas in every zone, but no topology hints enabled, so kube-proxy routes randomly. Third, Kafka consumers or Redis clients reading from the first available node, with no rack or AZ affinity configured.

I cut a roughly $1M-a-year cloud bill by 26% at a former employer. The habit that carries over to cross-AZ traffic is simple: map the flows before you change any routing, so you fix the pairs that cost money and leave the rest alone.

If you’re paying for cross-AZ data transfer, start with the Athena query and pick the top two source-destination pairs. For a Kubernetes Service, spread its pods across zones with topologySpreadConstraints, add the topology-mode annotation, and confirm hints.forZones appears on its endpoints. Watch per-zone CPU, p99 latency and error rate for a week, then move to the next pair.

If you want a second pair of eyes on your query results, book a free 30-minute consult: https://revelations.consulting/?utm_source=blog&utm_medium=organic&utm_content=blog-aws-cross-az-data-transfer-cost#contact

Run your own numbers: Cross-AZ Data Transfer Cost Calculator.

Frequently asked questions

How do I see cross-AZ data transfer charges in the Cost and Usage Report?

Cross-AZ data transfer appears in the Cost and Usage Report under usage types ending in DataTransfer-Regional-Bytes with a region prefix, such as USE1-DataTransfer-Regional-Bytes. Filter line_item_usage_type on that suffix and group by line_item_resource_id to see which resources paid. The per-GB rate is listed on the Amazon EC2 On-Demand pricing page under data transfer within the same AWS Region (checked November 2026).

Can I avoid cross-AZ charges by using a single Availability Zone?

Running a workload in a single Availability Zone removes cross-AZ data transfer for that workload, but an outage in that AZ takes the whole workload down. Single-AZ is a reasonable trade for development environments, batch jobs, and workloads you can rebuild elsewhere. Keep production databases and customer-facing services in at least two AZs.

Does VPC endpoint traffic count as cross-AZ data transfer?

Gateway VPC endpoints for S3 and DynamoDB do not incur cross-AZ data transfer charges. Interface VPC endpoints (AWS PrivateLink) are billed per endpoint per AZ per hour and per GB processed, as listed on the AWS PrivateLink pricing page (checked November 2026). Create the interface endpoint in every AZ your clients run in, and use the zonal DNS name if you need to pin traffic to a zone.

Why does EKS still send traffic across AZs even with topology mode enabled?

EKS topology mode is most often off because the EndpointSlice controller removed the hints; run kubectl get events -n my-namespace --field-selector involvedObject.name=my-service and look for TopologyAwareHintsDisabled, then confirm each endpoint lists hints.forZones. Even with hints in place, topology mode only steers ClusterIP traffic that kube-proxy routes inside the cluster. Ingress controllers that send to pod IPs, AWS Load Balancer Controller targets in IP mode, clients that dial pod IPs directly, and calls to services outside the cluster such as RDS or ElastiCache all bypass kube-proxy, so topology mode does not keep that traffic in-zone.

Is cross-region data transfer billed the same as cross-AZ data transfer?

No. Cross-AZ data transfer is billed within one region under DataTransfer-Regional-Bytes. Data sent between regions is billed as inter-region transfer, with usage types like USE1-USW2-AWS-Out-Bytes, at rates listed per region pair on the Amazon EC2 On-Demand pricing page (checked November 2026).

Run the numbers on your own bill: What is traffic between your availability zones costing you?. Free, in your browser.

Want this kind of thing weekly? Get Cloud Bill Weekly. Want us to find it in your bill? We're taking three founding clients for a free Cost Assessment.