Is AWS Glue an ETL tool? Yes. It’s Amazon’s serverless ETL service: it extracts data from sources like Amazon S3, RDS, and DynamoDB, transforms it with Spark or Python, and loads it into a lake or warehouse. AWS Glue pricing follows that design. You pay for processing time in DPU-hours, plus a few catalog and request fees.
The $0.44 per DPU-hour rate sits at the top of AWS’s pricing page, but it’s only part of what you pay. Crawler minimums, interactive sessions left open overnight, and the cheaper Glue 6.0 rates (which only apply to jobs you’ve upgraded) all change the final bill.
Below, we walk through every Glue charge at current US East (N. Virginia) list prices, run the math on four worked examples, including a full monthly bill, and show which fixes cut the most spend.
How AWS Glue billing works
AWS Glue pricing is the pay-as-you-go model AWS uses to bill Glue: an hourly rate per data processing unit (DPU) for jobs, crawlers, and sessions, billed by the second, plus monthly fees for Data Catalog storage and requests above a free tier.
There’s no upfront fee and no minimum monthly spend. There’s also no commitment discount to lean on. Glue isn’t on AWS’s list of services eligible for Savings Plans, so the levers you control are the Glue version, the execution class, and how many DPUs each job gets.
What is a DPU in AWS Glue?
A DPU (data processing unit) is Glue’s unit of compute. One DPU equals 4 vCPUs and 16 GB of memory. Every Glue worker type maps to a number of DPUs, and that number drives the bill.
A job with 10 G.2X workers uses 20 DPUs. Run it for 30 minutes, and you’ve consumed 10 DPU-hours.
Billing rules that set the floor
Glue bills in one-second increments, rounded up, but each job type has its own minimums and defaults:
- Spark jobs: Glue 2.0 and later bill with a 1-minute minimum (Glue 0.9 and 1.0 had a 10-minute minimum). Spark jobs need at least 2 DPUs and default to 10.
- Spark streaming jobs: Same 2-DPU minimum, with a default of 2 DPUs, billed for as long as the stream runs.
- Python shell jobs: Default to 0.0625 DPU, with 1 DPU as the only other option, and a 1-minute minimum.
- Interactive sessions: 2-DPU minimum, 5-DPU default, and a 1-minute minimum per session.
- Development endpoints: 2-DPU minimum, 5-DPU default, and a 10-minute minimum per endpoint.
- Crawlers: Billed per second with a 10-minute minimum per run.
That crawler minimum surprises a lot of teams. A crawler that finishes in 90 seconds still bills for 10 minutes.
Glue rates at a glance
Every rate below is the on-demand list price in US East (N. Virginia), taken from AWS’s Glue pricing page and AWS’s published price list as of October 2026. Every other region we checked across North America, Europe, and Asia Pacific matches these figures. For São Paulo, however, a standard ETL DPU-hour lists at $0.69 there.
Schema Registry carries no additional charge.
ETL job pricing
ETL jobs usually make up the bulk of a Glue bill, and the per-hour rate runs from $0.203 to $0.52 depending on how each job is set up.
Spark and Spark streaming jobs
Spark batch and streaming jobs bill at $0.44 per DPU-hour on Glue 2.0 through 5.1. AWS’s own example: a Spark job that runs for 15 minutes on 6 DPUs costs $0.66 (6 DPUs × 0.25 hours × $0.44).
Streaming jobs use the same rate, but they keep running until you stop them. A 2-DPU streaming job running all month (730 hours) uses 1,460 DPU-hours, or about $642 at $0.44. For low-volume streams, the G.025X worker is a quarter of a DPU, which AWS describes as one-fourth of the cost.
Glue 6.0 and later rates
AWS released Glue 6.0 in August 2026 with Spark 4.1.1, Python 3.13, and Iceberg v3 support. It also cut the price by 30% per DPU-hour compared with Glue 5.1, which brings the standard Spark rate to $0.308.
The discount lives on its own rate lines. Jobs on Glue 5.1 and earlier keep paying $0.44, and a job created without a Glue version defaults to 5.1. So a team that never touches its job configs never sees the lower price.
The same 15-minute, 6-DPU job costs about $0.46 on Glue 6.0. Upgrading still takes testing. Glue 6.0 moves to Spark 4.1, Scala 2.13, and Python 3.13, and it removes the AWS SDK for Java 1.x, so older scripts can need changes before they run.
Flex execution
Flex is a cheaper execution class for Spark jobs whose start and finish times can vary. AWS recommends it for non-urgent jobs such as pre-production runs, tests, and one-time loads. In exchange, Flex costs $0.29 per DPU-hour on Glue 3.0 through 5.1 (about 34% less than standard) and $0.203 on Glue 6.0 and later.
There are limits. Flex needs Glue 3.0 or later and G.1X or G.2X workers. R workers, G.12X, and G.16X don’t support it, and neither do streaming jobs. Flex also bills each worker only for the time it ran.
On Glue 6.0, AWS’s sample 15-minute, 6-DPU job drops to about $0.30 with Flex, less than half the original $0.66.
Memory-optimized R workers
R workers pair each DPU’s 4 vCPUs with 32 GB of memory instead of 16. The rate is $0.52 per DPU-hour on Glue 4.0 to 5.1, and $0.364 on Glue 6.0 and later.
They’re worth it when a job spills to disk or fails with out-of-memory errors on G workers. Don’t use them by default. An R.1X costs about 18% more per hour than a G.1X, it can’t use Flex, and AWS notes higher startup latency for R types.
Python shell jobs
Python shell jobs run plain Python, with no Spark cluster, at $0.44 per DPU-hour. Because they default to 0.0625 DPU, they’re cheap. A 10-minute run costs under half a cent.
The one setting to watch is the 1-DPU option, which costs 16 times more per hour. Very small, short tasks can also fit AWS Lambda, which bills per request and per millisecond of compute and often undercuts a Python shell job at that size.
Ray jobs
Glue for Ray bills at $0.44 per M-DPU-hour, but AWS closed it to new customers on April 30, 2026. Existing customers can keep using it. AWS points new Ray workloads to Amazon EKS with the KubeRay Operator instead.
Interactive sessions and development endpoints
Both give engineers a live environment to write and test Glue code. They’re priced the same per hour, but they bill very differently once nobody’s using them.
Interactive sessions
Interactive sessions (including Glue Studio job notebooks) cost $0.44 per DPU-hour on Glue 5.1 and earlier and $0.308 on Glue 6.0 and later, with a 5-DPU default and a 1-minute minimum. AWS’s example: a 24-minute session on 5 DPUs costs $0.88 (5 × 0.4 hours × $0.44).
A session keeps billing until someone stops it or it hits its idle timeout. For Spark sessions, that idle timeout defaults to the session’s overall timeout of 48 hours (2,880 minutes). A 5-DPU session someone forgets on a Friday afternoon can bill about $105 before it stops on Sunday. A %idle_timeout of 15 or 30 minutes in each notebook stops a forgotten session from billing for days.
Development endpoints
Development endpoints are the older option, and they only support Glue 0.9 and 1.0. They bill $0.44 per DPU-hour from the moment they’re provisioned, with a 10-minute minimum, and they don’t time out.
A 5-DPU endpoint left running for a month costs about $1,606. AWS strongly recommends migrating to interactive sessions, and if you still have an endpoint in your account, check whether anyone’s using it.
Glue Studio data previews
Data previews in Glue Studio also bill on the DPU meter. Each preview session uses 2 DPUs, runs for 30 minutes, stops on its own, and bills in 30-minute blocks. At $0.44 per DPU-hour, each preview session costs $0.44, which adds up slowly unless a team previews constantly.
Crawler pricing
Crawlers scan your data stores, infer schemas, and write table definitions into the Data Catalog. They cost $0.44 per DPU-hour, billed per second, with a 10-minute minimum per run.
AWS’s example: a crawler that runs for 30 minutes on 2 DPUs costs $0.44 (2 × 0.5 hours × $0.44). You don’t pick a crawler’s DPU count the way you do for a job, so the run time and the schedule are what you can control.
Short, frequent runs get expensive because of that minimum. Using AWS’s 2-DPU figure, a crawler that finishes in one minute still bills about $0.15 per run. Schedule it hourly and that’s around $106 a month for one crawler, where the actual one minute of work would cost about $11.
Data Catalog pricing
The Data Catalog stores metadata (tables, partitions, schemas) for Glue, Athena, EMR, and Redshift Spectrum. It has the most generous free tier in Glue.
Storage and requests
- Storage: The first million objects are free each month, then $1.00 per 100,000 objects per month. Tables, table versions, partitions, partition indexes, statistics, and databases all count as objects.
- Requests: The first million requests each month are free, then $1.00 per million.
The data itself sits in S3 or Redshift and bills at those services’ rates. The Catalog adds no charge for it.
Partitions usually push teams past the free tier first. A table partitioned by day, region, and customer can create hundreds of thousands of partition objects on its own. At 3 million objects, you’d pay $20 a month for the 2 million above the free tier.
Iceberg compaction, statistics, and materialized views
Catalog-managed table maintenance bills on the DPU meter at $0.44 per DPU-hour, per second, with a 1-minute minimum:
- Iceberg compaction: Rewrites small files into larger ones. AWS’s example of 2 DPUs for 30 minutes costs $0.44.
- Column statistics: Generates stats that help query engines plan. AWS’s example of 1 DPU for 10 minutes costs about $0.07.
- Materialized view refresh: Same rate, billed for the DPU time each refresh uses.
Compaction is usually worth the DPU time, since small files slow down the queries and Spark jobs that read the table. Iceberg is also becoming a default format for AI workloads, which is why teams are building AI-ready Iceberg lakes.
DataBrew pricing
DataBrew is Glue’s visual, no-code data prep tool, and it has its own pricing model:
- Interactive sessions: $1.00 per 30-minute session. A session starts when you open a project, each session covers 30 minutes, and you’re billed for the total number of sessions used. AWS also offers first-time users a free session allowance.
- Jobs: $0.48 per node-hour, billed per minute. AWS’s example of 5 nodes for 10 minutes costs $0.40.
Data Quality pricing
Glue Data Quality checks datasets against rules (completeness, freshness, ranges) and bills on the DPU meter at $0.44 per DPU-hour on Glue 5.1 and earlier and $0.308 on Glue 6.0 and later, with a 2-DPU minimum and a 1-minute minimum.
AWS’s examples on the pricing page give a sense of scale:
- Rule recommendations: 5 DPUs for 10 minutes costs about $0.37.
- Rule evaluation on a cataloged table: 5 DPUs for 20 minutes costs about $0.73.
- Checks inside an ETL job: A 6-DPU job that runs 20 minutes costs $0.88 on Glue 5.1, about $0.62 on Glue 6.0, or $0.58 with Flex on 5.1.
Anomaly detection on Data Catalog tables adds 1 DPU per statistic for the time it takes to detect (about 10 to 20 seconds each). Inside ETL jobs, it carries no extra charge. Storing data quality statistics is free, up to 100,000 statistics per account, kept for two years.
Zero-ETL pricing
Zero-ETL integrations replicate data from sources like Salesforce, SAP, or DynamoDB into Redshift or SageMaker Lakehouse, so you don’t write or schedule the job yourself.
Glue charges no integration fee, but the pieces still bill:
- Application sources: $1.50 per GB ingested, billed per MB, with a 1 MB minimum per ingestion request.
- Writing to S3 through SageMaker Lakehouse: $0.44 per DPU-hour for the compute that processes the data.
- Redshift targets: Standard Redshift pricing.
- DynamoDB sources: Exports bill under DynamoDB pricing.
Model ingestion first. Ten GB a day from an application source comes to about $450 a month in ingestion alone, before any Redshift or S3 compute.
How to calculate AWS Glue cost
For any DPU-billed Glue SKU, the monthly formula is: DPUs × hours per run × rate per DPU-hour × runs per month
Round each run up to the minimum first: 1 minute for jobs, sessions, and Data Quality, 10 minutes for crawlers and dev endpoints. Then add Data Catalog fees above the free tier, plus DataBrew and zero-ETL charges if you use them.
To get real DPU-hours for jobs that already run, AWS documents two methods. For standard jobs, it’s execution time × max capacity ÷ 3,600.
For auto scaling and Flex jobs, divide the DPUSeconds field from get-job-run by 3,600.
Then estimate a full bill with these steps:
- Note each job’s type, Glue version, worker type, worker count, average runtime, and schedule. Add crawlers, sessions, DataBrew, and zero-ETL sources.
- Pull real usage if you have it: In AWS Cost Explorer, filter by Service = Glue and group by usage type (such as USE1-ETL-DPU-Hour, USE1-ETL-Flex-DPU-Hour, and USE1-GlueInteractiveSession-DPU-Hour) to see where DPU-hours go.
- Add each component to the AWS Pricing Calculator, with your region set first.
- Run the same estimate on Glue 6.0 and with Flex for non-urgent jobs, then compare.
Note that Glue 6.0 usage shows up under its own usage types (ETL-DPU-Hour-Gen2 and ETL-Flex-DPU-Hour-Gen2, with a region prefix like USE1-), so Cost Explorer shows which jobs actually moved after an upgrade.
The examples below show the formula on single runs before you scale it to a monthly bill.
Example 1: A 15-minute Spark job
This is AWS’s own example, priced three ways:
Run it nightly and the monthly cost ranges from $19.80 down to about $9.
Example 2: A crawler run
AWS’s example crawler runs for 30 minutes on 2 DPUs: 2 × 0.5 hours × $0.44 = $0.44.
A short crawler shows the minimum at work. A 1-minute run on 2 DPUs bills as 10 minutes: 2 × (10 ÷ 60) × $0.44 = about $0.15. That’s 10 times the cost of the work it actually did.
Example 3: An interactive session
A 24-minute session on 5 DPUs costs 5 × 0.4 hours × $0.44 = $0.88, or about $0.62 on Glue 6.0. The same session left open until its 48-hour default timeout costs 5 × 48 × $0.44 = $105.60.
Example 4: A sample monthly bill
Here’s a sample bill for a mid-size data platform team in US East (N. Virginia). The usage figures are illustrative assumptions, so swap in your own.
The "Glue 6.0 rates" column assumes every job and session runs on Glue 6.0, which cuts about 26% on its own (crawlers and Catalog maintenance keep their rates). The "Optimized" column adds two changes: eight of the 12 nightly jobs move to Flex at $0.203, and the crawlers run daily instead of hourly. Together, that’s about 44% below the starting bill.
Is AWS Glue expensive? Cost traps and fixes
No. On Glue 6.0, a DPU-hour costs $0.308, about what the same 4 vCPUs and 16 GB cost on EMR Serverless (more on that below). Older versions pay $0.44, roughly 45% more. Bills climb when capacity keeps running after the work is done. Each trap below is paired with a fix:
- Idle interactive sessions: The 48-hour default idle timeout can bill a forgotten session all weekend. Set %idle_timeout to 15 or 30 minutes in each notebook.
- Development endpoints that never time out: They bill from provisioning until someone deletes them. Retire them and move the work to interactive sessions.
- Over-allocated DPUs: Spark jobs default to 10, and a job sized for its largest-ever input pays for capacity it rarely uses. Check each job’s real DPU-hours, lower the worker count, and turn on auto scaling (Glue 3.0 and later) so idle workers drop mid-run.
- Non-urgent jobs on standard pricing: Nightly batch, backfills, and test runs rarely need a guaranteed start time. Move them to Flex at $0.203 per DPU-hour on Glue 6.0.
- Old Glue versions: Jobs on 5.1 or earlier, including any created without a version, pay $0.44 instead of $0.308. Upgrade to Glue 6.0 after testing against Spark 4.1 and Python 3.13, and set the version explicitly on every job.
- Frequent crawler runs: Hourly or 15-minute schedules on data that changes once a day multiply the 10-minute minimum. Crawl on the data’s real cadence, and for schemas you already know, populate the Catalog through the Glue API’s CreateTable instead (requests are free up to a million a month).
- Long job timeouts: Glue 4.0 and earlier default to a 2,880-minute timeout, so a hung 10-DPU job can bill about $211 before it stops. Set each job’s timeout close to its normal runtime.
- Reprocessing the same data: Jobs that read the full dataset every run pay for rows they have already handled. Turn on job bookmarks so incremental loads only read new data.
- CloudWatch logging: Verbose logs and job metrics add CloudWatch charges outside the Glue line item. Drop debug output in production and set retention on Glue log groups.
Tools that track Glue spend alongside the rest of your AWS bill can flag this creep automatically, and the same account-wide habits that keep other line items down apply to Glue.
When your backups can replace a Glue copy job
Some Glue pipelines exist only to copy production databases into S3 so someone can answer an audit, investigation, or analytics question months later. Those jobs bill DPU-hours every run, and the copies they write add storage cost on top.
If those databases are already backed up, the backup can serve that request. With Eon, you can query backed-up RDS and DynamoDB data without restoring the database or writing a Glue job for it.
Eon’s Cloud Backup Posture Management (CBPM), the category we created, discovers resources like S3 buckets and databases, classifies them by data type, and applies backup policy automatically, so new buckets and tables that match a policy get picked up without anyone tagging them.
Eon also cuts backup storage costs by 30% to 50% through global deduplication. NETGEAR, for one, cut backup storage costs 35% and recovered a 10TB SQL Server database 88% faster after moving to Eon.
Most cloud teams can’t say what they spend on backup, and Eon’s Cost Explorer breaks that spend down by resource, resource type, or source account.
AWS Glue vs. EMR Serverless: What’s the cost difference?
On Glue 6.0, the per-hour difference is small. An EMR Serverless worker the size of one DPU (4 vCPUs, 16 GB) costs about $0.30 an hour on x86 in US East (N. Virginia), against $0.308 on Glue 6.0 and $0.44 on Glue 5.1. That’s based on EMR Serverless rates of $0.052624 per vCPU-hour and $0.0057785 per GB-hour.
The bigger difference is the billing unit. Glue charges per DPU-hour for a managed Spark runtime with the Data Catalog, crawlers, bookmarks, and Data Quality built in. EMR Serverless charges per vCPU-hour and GB-hour for the resources your Spark or Hive job actually uses.
Glue tends to win when the built-in pieces save engineering time. EMR Serverless tends to win for teams that already know their Spark configs and want to size memory and CPU separately.
Should you use AWS Glue in 2026?
For most AWS-centered teams running batch ETL on S3 data, yes. The pricing works best when jobs run on a schedule and stop.
AWS Glue is a good fit if you:
- Run scheduled batch ETL from S3, RDS, or DynamoDB into a lake or warehouse.
- Want the Data Catalog, crawlers, and bookmarks without running your own Spark cluster.
- Can move non-urgent jobs to Flex and upgrade to Glue 6.0.
Look at other options if you:
- Run large Spark workloads around the clock and want to tune CPU and memory separately (EMR Serverless or EMR on EC2 may cost less).
- Need Ray for new workloads, since Glue for Ray is closed to new customers.
- Only run a few tiny scripts, where Lambda or a Python shell job is cheaper than spinning up Spark.
The bottom line on Glue costs
AWS Glue pricing rewards teams that check their defaults. The base rate is fair, and Glue 6.0 with Flex makes it cheaper still. In our sample bill, the biggest single saving came from moving nightly jobs to Glue 6.0 and Flex, which cut that line from $2,112 to $1,142.
The other place to look is the pipelines themselves. A Glue job that copies production data into S3 just so it can be queried later may be paying to duplicate data your backups already hold. Check what’s covered before you tune another copy job.
Is part of your Glue bill going to copies of data you’ve already backed up? Book a demo and see how Eon lets you query backed-up data without a restore, and shows what those backups cost.
Frequently asked questions
How much does AWS Glue cost per month?
AWS Glue costs anywhere from a few dollars a month for a handful of short jobs to several thousand dollars for a busy data platform. A 6-DPU Spark job that runs 15 minutes every night costs about $19.80 a month on Glue 5.1, or about $13.86 on Glue 6.0.
Is AWS Glue expensive?
No, Glue’s compute rates are moderate: Spark jobs cost $0.308 to $0.44 per DPU-hour, or $0.203 with Flex on Glue 6.0. Bills get expensive when idle interactive sessions, dev endpoints, oversized jobs, and frequent crawlers keep the DPU meter running.
How do you calculate AWS Glue cost?
You calculate AWS Glue cost by multiplying DPUs × hours per run × rate per DPU-hour × runs per month, after rounding each run up to its minimum (1 minute for jobs, 10 for crawlers). Add Data Catalog fees above the free tier, then check the total in the AWS Pricing Calculator.
Is AWS Glue free?
No. Glue jobs, crawlers, and sessions all bill by the DPU-hour. The Data Catalog is free for the first million objects stored and first million requests each month, and first-time DataBrew users get a free allowance of interactive sessions.
Is AWS Glue an ETL tool?
Yes. AWS Glue is Amazon’s serverless data integration service, and ETL is its core job: Spark or Python jobs extract, transform, and load data, while the Data Catalog and crawlers keep track of schemas.
Is AWS Glue 6.0 cheaper than older versions?
Yes. Glue 6.0 costs 30% less per DPU-hour than Glue 5.1: $0.308 versus $0.44 for standard Spark jobs and interactive sessions, and $0.203 versus $0.29 for Flex. Jobs only get the lower rate after you move them to Glue 6.0.


.webp)

