A Spark job on 10 DPUs that runs for 30 minutes costs $2.20 on Glue 5.1 and $1.54 on Glue 6.0 in us-east-1. Create that job without setting a version and it runs on Glue 5.1.
To a data engineer or FinOps practitioner explaining a Glue line in Cost Explorer, AWS Glue pricing looks like one DPU-hour rate. The bill depends on the Glue version, worker type, execution class, schedule and a handful of defaults. You'll get the current rate card by version, the hourly cost of every worker type, three monthly bills for one job, and the Terraform settings that decide them. Prices are from AWS's US East (N. Virginia) price list, September 2026.
How AWS Glue pricing works: DPU-hours, billed per second
AWS Glue bills compute in DPU-hours, per second, with a 1-minute minimum for jobs on Glue 2.0 and later and a 10-minute minimum for crawlers. In us-east-1, a Spark job pays $0.308 per DPU-hour on Glue 6.0 and $0.44 on Glue 5.1 and earlier. The Data Catalog is free up to 1 million objects and 1 million requests a month.
A DPU (Data Processing Unit) is 4 vCPU and 16 GB of memory. Every job follows the same formula:
cost = workers × DPU per worker × hours × rate per DPU-hour
Ten G.2X workers are 20 DPUs. Billing rounds up to the nearest second. Spark jobs need at least 2 DPUs and default to 10. Spark Streaming defaults to 2.
DataBrew sessions bill in 30-minute units. Not everything on the bill is a DPU-hour, either:
AWS Glue pricing after Glue 6.0: what the 30% cut covers
Glue 6.0 became generally available on August 21, 2026, in all commercial, AWS GovCloud (US) and China regions. Its per-DPU-hour rates are 30% lower, according to the Glue 6.0 launch announcement.
Rates from the AWS Glue pricing page for us-east-1, per DPU-hour unless noted:
| Workload | Glue 5.1 and earlier | Glue 6.0+ | Minimum |
|---|---|---|---|
| Spark or Spark Streaming job | $0.44 (2.0 to 5.1) | $0.308 | 1 min (10 min on 0.9/1.0) |
| Flex (G.1X and G.2X only) | $0.29 (3.0 to 5.1) | $0.203 | 1 min |
| Memory-optimized R workers, jobs and sessions | $0.52 (4.0 to 5.1) | $0.364 | 1 min |
| Interactive session | $0.44 | $0.308 | 1 min |
| Data Quality in Glue ETL | $0.44 | $0.308 | not listed |
| Python shell | $0.44 | no 6.0 rate listed | 1 min |
| Ray (per M-DPU-hour) | $0.44 | no 6.0 rate listed | 1 min |
| Crawler | $0.44 | no 6.0 rate listed | 10 min |
| Development endpoint (legacy) | $0.44 | no 6.0 rate listed | 10 min |
| Catalog statistics, Iceberg compaction, MV refresh | $0.44 | no 6.0 rate listed | 1 min |
| Zero-ETL S3-target compute | $0.44 | no 6.0 rate listed | 1 min |
Everything with no 6.0 rate listed bills $0.44.
AWS's own worked example, a 6-DPU job running 15 minutes, comes to $0.66 at the Glue 5.1 rate. On Glue 6.0 the same job costs $0.462.
Jobs created without specifying a Glue version default to Glue 5.1, so they bill $0.44. Most regions match these rates, and a few, such as São Paulo, charge more.
Which rate your job pays
Flex (flexible execution) runs on spare capacity at a lower rate, in exchange for a possible delayed start and interruptions.
What moving to Glue 6.0 takes
There's no API change: you select --glue-version 6.0, or glue_version = "6.0" in Terraform. The migration guide lists changes to test:
- EMRFS is removed, so S3 access goes through S3A only
- The AWS SDK for Java v1 is removed
- Scala code needs a recompile from 2.12 to 2.13
- ANSI mode is on by default
- Iceberg v3 tables can't be read by Athena SQL, and upgrading a table to v3 is one-way
For a job that runs daily, I'd treat the 30% as worth a test migration.
What each Glue worker type costs per hour
A worker's hourly cost is its DPU count times the rate. Standard execution class, us-east-1:
| Worker | DPU | vCPU / memory | Glue 5.1 | Glue 6.0 | Flex eligible |
|---|---|---|---|---|---|
| G.025X (streaming only) | 0.25 | 2 / 4 GB | $0.11 | $0.077 | No |
| G.1X | 1 | 4 / 16 GB | $0.44 | $0.308 | Yes |
| G.2X | 2 | 8 / 32 GB | $0.88 | $0.616 | Yes |
| G.4X | 4 | 16 / 64 GB | $1.76 | $1.232 | No |
| G.8X | 8 | 32 / 128 GB | $3.52 | $2.464 | No |
| G.12X | 12 | 48 / 192 GB | $5.28 | $3.696 | No |
| G.16X | 16 | 64 / 256 GB | $7.04 | $4.928 | No |
| R.1X | 1 | 4 / 32 GB | $0.52 | $0.364 | No |
| R.2X | 2 | 8 / 64 GB | $1.04 | $0.728 | No |
| R.4X | 4 | 16 / 128 GB | $2.08 | $1.456 | No |
| R.8X | 8 | 32 / 256 GB | $4.16 | $2.912 | No |
| Z.2X (Ray) | 2 M-DPU | 8 / 64 GB | $0.88 | no 6.0 rate listed | No |
R-worker memory figures come from AWS's July 2025 launch blog. An M-DPU, the Ray unit, is 4 vCPU and 32 GB, and concurrent M-DPUs per account are capped by a service quota.
G.4X and G.8X need Glue 3.0 or later. G.12X, G.16X and the R types need Glue 4.0 or later and run in eight regions: N. Virginia, Oregon, Ohio, Ireland, Frankfurt, Spain, Tokyo and São Paulo. They also have higher startup latency.
I'd start on G.1X or G.2X and size up only when CloudWatch observability metrics such as glue.driver.workerUtilization show the need.
Auto Scaling and Flex bill the workers that ran
Auto Scaling works on Glue 3.0 and later with G and R workers, and the worker count you set becomes a ceiling. Turn it on with --enable-auto-scaling true.
For Flex and Auto Scaling runs, the job run's DPUSeconds field reports executor time multiplied by each worker's DPU factor. That can be less than runtime × max capacity. AWS describes Flex billing as "the sum of (Number of DPUs per worker * time each worker ran)". In one AWS migration run with Auto Scaling, a job consumed 28.79 DPU-hours against an expected 33.46.
Python shell for small scripts
Not every job needs Spark. A Python shell job runs on 0.0625 DPU (1 GB) by default, or on 1 DPU. At 0.0625 DPU that's $0.0275 an hour in us-east-1. A 20-second run bills the 1-minute minimum, about $0.00046.
AWS positions Python shell for datasets up to roughly 10 GB. By DPU count alone, the 2-DPU Spark minimum is 32 times a default Python shell job.
What a Glue job costs per month: one job, three schedules
Take one job with 10 DPUs (10 G.1X or 5 G.2X workers) in us-east-1, no Auto Scaling, and a 30-day month. The streaming row uses the 2-DPU streaming default and 730 hours.
| Schedule | DPU-hours per month | Glue 5.1 Standard | Glue 6.0 Standard | Glue 6.0 Flex |
|---|---|---|---|---|
| Daily batch, 30 min | 150 | $66.00 | $46.20 | $30.45 |
| Every 15 min, 10 min each | 4,800 | $2,112.00 | $1,478.40 | $974.40 |
| Streaming 24/7, 2 DPU | 1,460 | $642.40 | $449.68 | n/a (no Flex for streaming) |
- Schedule shape beats rate choice. The micro-batch uses 32 times the DPU-hours of the daily batch.
- Right-sizing beats both. The same micro-batch on 2 DPUs costs $295.68 a month on Glue 6.0 Standard, under a third of the Flex price at 10 DPUs.
- Flex is a risk on a 15-minute cadence. Flex jobs may not start when capacity is short, and AWS expects about 5% of them to be interrupted (5% to 10% at peak). An interrupted job fails and retries up to its max retries. Keep Flex for batch work that can slip.
- Streaming is always-on DPU-hours. A streaming job runs continuously, so even the 2-DPU default bills every hour of the month.
If a pipeline needs 15-minute freshness, I'd compare both at the worker count the job needs: at 2 DPUs, the micro-batch costs $295.68 and the stream $449.68 on Glue 6.0.
You can price the Glue 5.1 version of this job with the micro-batch already filled in. It returns the $2,112.00 row. For Glue 6.0 Standard, multiply the ETL line by 0.7.
These figures are arithmetic on AWS's us-east-1 rates. Your runtime, worker count and schedule decide the real total.
Is AWS Glue free, or is it expensive?
No, Glue isn't free. The pricing page lists no free DPU-hours for jobs, crawlers or interactive sessions. The free parts are metadata and tooling: 1 million Data Catalog objects and 1 million requests a month, and 40 DataBrew sessions for first-time users.
What costs nothing in AWS Glue
- The first 1 million Data Catalog objects stored and first 1 million requests each month
- The first 40 DataBrew interactive sessions, for first-time DataBrew users
- The Schema Registry, at no additional charge
- Anomaly detection inside Glue ETL, free since August 5, 2026
- Lake Formation permissions on Catalog tables, with no separate charge
When Glue gets expensive
Glue is cheap for short, bursty batch work: the daily 30-minute job above costs $46.20 a month on Glue 6.0. It gets expensive when DPUs run for hours nobody planned. At Glue 6.0 rates:
- A 10-minute job every 15 minutes: $1,478.40 a month
- Always-on streaming at 2 DPUs: $449.68 a month
- A notebook session left open at its defaults: up to $73.92
- A hung 10-DPU job at the default timeout: $24.64 per run
- A 3-minute crawl every hour: $105.60 a month, because each run bills 10 minutes
Some of the cost never appears under Glue. Temporary files, Data Quality results and shuffle files bill at S3 request and storage rates, and Glue may create a temporary bucket per region. Continuous logging, job metrics and observability metrics show up as CloudWatch Logs charges, and Spark UI logs land in S3. Source databases such as RDS and Redshift charge their standard request and transfer rates.
Glue crawler and Data Catalog pricing
Crawlers bill a minimum per run, and the Data Catalog bills by object and request count.
Crawlers bill at least 10 minutes a run
A crawler costs $0.44 per DPU-hour in us-east-1, billed per second with a 10-minute minimum per run. A 2-DPU crawl that finishes in 3 minutes bills 10, about $0.147.
Run that crawl hourly for 30 days and 720 runs cost $105.60, against $31.68 if they billed actual duration. The minimum more than triples the bill. The same crawl once a day costs $4.40 a month.
Crawlers are optional: you can add tables and partitions to the Catalog through the API instead. When you run your own crawler and Catalog numbers in the AWS Glue calculator, enter at least 10 minutes per crawl, because it prices the minutes you enter.
What counts as a Data Catalog object
The first 1 million objects stored each month are free, then $1.00 per 100,000. The first 1 million requests a month are free, then $1 per million. An object is a table, table version, partition, partition index, statistic, database or catalog.
Your S3 files aren't on that list. Table data bills at S3 or Redshift rates, with no extra Catalog storage charge.
A month with 3 million objects and 5 million requests costs $24. Partition granularity is what moves the object count:
- 1,000 tables with daily partitions for three years: at least 1.096 million objects, about $0.96 a month
- The same tables with hourly partitions for one year: at least 8.76 million objects, about $77.61 a month
Table versions, partition indexes and statistics push both counts higher. The same tables usually serve Athena queries that read the Catalog, which bill on Athena's own line.
Statistics, compaction and view refresh
Column statistics, Iceberg compaction and materialized-view refresh each cost $0.44 per DPU-hour, per second, with a 1-minute minimum. Statistics on 1 DPU for 10 minutes cost about $0.07. A 2-DPU compaction running 30 minutes costs $0.44.
Interactive sessions: the 48-hour idle timeout
An interactive session bills active session time × DPUs, per second, with a 1-minute minimum. It defaults to 5 DPUs, with a minimum of 2.
In us-east-1 a session costs $0.44 per DPU-hour on Glue 5.1 and earlier, or $0.308 on Glue 6.0. The idle timeout is how long a session can sit unused before Glue stops it, and its default is 2,880 minutes: 48 hours.
A 5-DPU session left open on Friday evening can bill up to $105.60 on Glue 5.1, or $73.92 on Glue 6.0, if it stays active until the timeout stops it. A 30-minute idle timeout caps the same idle session at $0.77 on Glue 6.0. Two session magics set the idle timeout and shrink the worker count:
%idle_timeout 30
%number_of_workers 2
Stop or delete sessions you aren't using. When you don't need a cluster at all, develop locally against the Glue Docker image.
Development endpoints never time out
Development endpoints, the legacy route, support Glue 0.9 and 1.0 only. Their console was removed on March 31, 2023, but the API and CLI remain.
They bill provisioned time × DPUs at $0.44, with a 10-minute minimum and a 5-DPU default, and they don't time out. Attached notebooks bill separately. AWS recommends moving to interactive sessions, and I'd delete any endpoint that's still running.
DataBrew, Data Quality and zero-ETL pricing
Three more Glue products bill on their own units. In us-east-1:
| Product | Unit | Rate | Minimum or free allowance |
|---|---|---|---|
| DataBrew interactive session | per 30-minute session | $1.00 | First 40 free for first-time users |
| DataBrew job | per node-hour (4 vCPU, 16 GB) | $0.48 | 1 min; default 5 nodes |
| Data Quality, Data Catalog tasks | per DPU-hour | $0.308 | 2 DPU, 1 min |
| Data Quality rules in Glue ETL | the job's own rate | $0.44 (5.1 and earlier) / $0.308 (6.0+) | adds job runtime |
| Anomaly detection in Glue ETL | none | no additional charge | since August 5, 2026 |
| Zero-ETL application ingestion | per GB, billed per MB | $1.50 | 1 MB per request |
| Zero-ETL S3-target compute | per DPU-hour | $0.44 | 1 min |
A 5-node DataBrew job running 10 minutes costs $0.40. Any interaction keeps a DataBrew session active.
Anomaly detection in the Data Catalog is billed: 1 DPU per statistic for the detection time, typically 10 to 20 seconds, with a 1-second minimum.
Zero-ETL has no integration fee. Ingesting 10 GB from an application costs $15 before target compute, and Redshift targets bill at Redshift Serverless compute rates.
Set the settings that drive your Glue bill in Terraform
Most of the dollars above trace back to five job properties: Glue version, worker type, worker count, execution class and timeout. Here they are on a nightly, delay-tolerant batch job:
resource "aws_glue_job" "nightly_orders" {
name = "nightly-orders"
role_arn = aws_iam_role.glue.arn
glue_version = "6.0" # unset defaults to 5.1 at $0.44/DPU-hour
worker_type = "G.1X" # Flex needs G.1X or G.2X
number_of_workers = 10
execution_class = "FLEX" # $0.203 vs $0.308 on 6.0 in us-east-1
timeout = 120 # minutes; default is 480 on Glue 5.0+
max_retries = 1
command {
script_location = "s3://example-bucket/scripts/nightly_orders.py"
}
}
For an SLA-bound job, drop execution_class so it runs Standard, and add "--enable-auto-scaling" = "true" to its default_arguments so number_of_workers becomes a ceiling. The 120-minute timeout follows AWS's console advice to give Flex jobs a shorter timeout.
"To avoid unexpected charges, configure timeout values appropriate for the expected execution time," AWS advises in its Glue job properties reference. A 10-DPU job that hangs until the default 480-minute timeout costs $24.64 on Glue 6.0. On Glue 4.0 and earlier the default is 2,880 minutes, so the same hang costs $211.20 at $0.44.
Jobs that hit the timeout aren't retried, but each retry of a failed run is another billed run.
For teams, Usage Profiles let admins cap worker types, worker counts and run duration for jobs and notebook sessions.
These five lines are what I'd check in a pull request, the same habit as cost checks in code review for any other resource. An unset glue_version is the easiest 30% to miss.
Check what your jobs actually used
GetJobRun returns DPUSeconds for Flex and Auto Scaling runs. Glue Studio's Monitoring page shows a DPU hours column per job run, and crawler history shows the duration and DPU hours of each crawl.
On the billing side, the Price List tags Glue 6.0 usage with a -Gen2 suffix: USE1-ETL-DPU-Hour-Gen2 against USE1-ETL-DPU-Hour. Filtering usage types for the -Gen2 suffix shows which spend has moved to 6.0.
Frequently Asked Questions
Does AWS Glue charge for job startup time?
Is AWS Glue pricing the same in every region?
Do Glue Studio notebooks and data previews cost extra?
Is AWS Glue cheaper than EMR or Lambda?
What AWS Glue pricing comes down to
- Glue bills DPU-hours per second. The minimum is 1 minute for Glue 2.0+ jobs and 10 minutes for crawlers.
- Glue 6.0 cuts Spark, Flex, R-worker and session rates by 30%, but only for jobs that set it. Jobs without a version run on 5.1.
- Schedule shape and worker count move the bill more than the rate does.
- Surprise charges come from the idle timeout, the job timeout and crawl frequency.
Set glue_version explicitly on your busiest job, then price its schedule in the calculator and multiply the ETL line by 0.7. For the query engine that reads your Catalog, Amazon Athena pricing is the natural next read.
CloudBurn
Price Your Glue Pipeline One Component at a Time
CloudBurn's AWS Glue calculator estimates ETL jobs, crawlers, Data Catalog storage and requests, DataBrew, interactive sessions and Catalog statistics for your region. See which line drives the monthly total.