Key Takeaways- AWS Glue is a strong fit for AWS-native teams with Spark expertise and complex, custom transform needs. Teams that want simpler pricing and do not have a dedicated Spark engineer often find a managed ETL alternative easier to operate and predict.
- AWS Glue runs on a pay-as-you-go model with no upfront cost, but your bill is built from six independently moving components, not one single number.
- The base compute rate is $0.44 per DPU-hour for standard ETL jobs, crawlers, and interactive sessions. Flex execution drops that to $0.29 for batch jobs that can tolerate a delayed start, a real 34% savings if your pipeline is not time-sensitive.
- Billing is per second, but minimums apply. ETL jobs carry a 1-minute minimum; crawlers carry a 10-minute minimum. A crawler that finishes in 30 seconds still bills 10 full minutes every single run.
- The Data Catalog is free up to one million stored objects and one million requests per month. Past that threshold, every partition, table version, and index adds to a growing baseline cost that is easy to overlook.
- DataBrew and Data Quality are separately metered on top of your core ETL spend. Interactive DataBrew sessions bill at $1.00 per 30-minute window; jobs bill at $0.48 per node-hour. These are not included in the headline DPU rate.
- The default 10-DPU allocation on Spark jobs is the single most common source of bill shock. Most workloads need 3 to 5 DPUs, not 10. Trimming that default, enabling Flex execution, turning on Job Bookmarks, and switching from CSV to Parquet together can cut a typical monthly bill by 40 to 60%.
You run your first AWS Glue job and get billed sixty-six cents. Six months later, the same pipeline is live in production and might be costing you $5,000+. The final cost depends on a mix of variables: how many DPUs your ETL pipelines actually use, how long they run, how often your crawlers fire, and how much metadata you’re accumulating in the Data Catalog.
In this article, we break down every AWS Glue pricing component, including Zero-ETL, DataBrew, and Data Quality, cover the hidden cost traps teams hit most often, and show you how to estimate and reduce your bill before it runs away.
We’ve checked every figure against AWS’s own pricing page. Confirm current rates before you budget.
Table of Contents
AWS Glue pricing at a glance
| Pricing component | Rate / unit | Free tier or minimum | Best for | Biggest limitation |
|---|---|---|---|---|
| ETL jobs (Spark, Python Shell, Ray) | $0.44/DPU-hour ($0.29 Flex, $0.52 Memory-Optimized R) | 2 DPU minimum; 1-min billing minimum (v2.0+) | Scheduled batch or streaming transforms | Default 10-DPU allocation over-provisions most jobs |
| AWS Glue Data Catalog | $1 per 100K objects; $1 per 1M requests beyond free tier | 1M objects + 1M requests free per month | Centralized metadata for data lakes | Every table version, partition, and index is a separate object |
| Crawlers | $0.44/DPU-hour | 2 DPU minimum; 10-min billing minimum | Schema discovery on evolving sources | 10-min minimum bills a 30-second crawl for 10 minutes |
| Interactive Sessions & Dev Endpoints | $0.44-$0.52/DPU-hour | 5 DPU default; sessions idle-timeout, endpoints don’t | Interactive ETL code development | Development Endpoints run until manually stopped |
| DataBrew | $1.00 per 30-min session; $0.48 per node-hour for jobs | First 40 interactive sessions free for new users | No-code data prep for analysts | Separately metered on top of core ETL costs |
| Data Quality | $0.44/DPU-hour (recommendation, evaluation, anomaly detection) | 2 DPU minimum; 1-min billing minimum | Automated rule checks on cataloged data | Runs as extra DPU time layered onto existing ETL jobs |
| Zero-ETL | No charge for integration; $1.50/GB for application-source ingestion (1 MB min per request) | Integration itself is free | Real-time data movement from apps to S3, Redshift, or SageMaker Lakehouse without ETL code | Destination compute billed separately at standard DPU-hour rates; $1.50/GB adds up on high-volume change streams |
How AWS Glue’s pricing structure actually works
AWS Glue’s ETL architecture bills everything through the Data Processing Unit, or DPU. One DPU is 4 vCPUs and 16 GB of memory, and every job, crawler, or session is charged for exactly the time it runs.
The final number moves with job runtime, how many DPUs or workers you assign, which execution class you choose, and how hard you use the Data Catalog:
- Standard Spark and Python Shell jobs run at $0.44 per DPU-hour; Flex execution drops that to $0.29 for jobs that can wait; Memory-Optimized R workers push it to $0.52
- Spark jobs need at least 2 DPUs and default to 10; Spark Streaming jobs default to 2
- ETL jobs and Interactive Sessions bill in 1-minute minimums; Crawlers and Development Endpoints bill in 10-minute minimums
- The Data Catalog only starts charging past 1 million stored objects and 1 million requests a month
Six components, each scaling on a different variable, is exactly why a stable monthly number is hard to pin down before you’ve actually run the workload.
AWS Glue pricing components explained for 2026
ETL jobs (Spark, Spark Streaming, Python Shell, Ray)
Who this is for: teams running scheduled batch transforms or streaming ingestion, choosing between full Spark jobs and lightweight Python Shell scripts for simpler tasks.
Base price: $0.44 per DPU-hour standard, $0.29 with Flex execution for jobs that can tolerate a delayed start, $0.52 for Memory-Optimized R workers. Spark jobs need a 2 DPU minimum, with a 1-minute billing floor on Glue 2.0 and later.
What’s included: four job types, four worker sizes from G.1X up to G.8X, and no charge for startup or shutdown time.
Worker types at a glance
| Worker type | DPUs | vCPUs | Memory | Best for |
|---|---|---|---|---|
| G.1X | 1 | 4 | 16 GB | Python Shell scripts, light or single-threaded transforms |
| G.2X | 2 | 8 | 32 GB | Standard Spark jobs (the right default for most workloads) |
| G.4X | 4 | 16 | 64 GB | Memory-intensive joins, large dataset shuffles |
| G.8X | 8 | 32 | 128 GB | Very large datasets, complex ML transforms via Ray |
G.2X is the right default for most workloads. G.4X and G.8X are for jobs that are genuinely memory-bound or need to shuffle very large datasets. Picking them unnecessarily doubles or quadruples your per-DPU cost.
Where this starts breaking down: AWS defaults every Spark job to 10 DPUs whether the workload needs it or not. That single default is why a fifteen-minute test job costing sixty-six cents can turn into an eight-thousand-dollar monthly line once it’s running daily in production.
AWS Glue Data Catalog
Who this is for: teams managing metadata across a data lake with many tables, partitions, and versions, especially anyone running Iceberg tables or materialized views that need regular upkeep.
Base price: free for the first million objects stored and the first million requests each month. Past that, a dollar per 100,000 objects and a dollar per million requests.
What’s included: centralized schema storage, Lake Formation permission checks at no extra cost, and managed compute for table optimization, statistics generation, and materialized view refresh, billed at the standard DPU-hour rate.
To make the compute cost concrete: a statistics job running 10 minutes on 1 DPU costs roughly $0.07; an Iceberg compaction job running 30 minutes on 2 DPUs costs about $0.44. These add up quickly on an active Iceberg lake.
Where this starts breaking down: AWS counts tables, table versions, partitions, partition indexes, statistics, databases, and catalogs all as separate objects. A data lake that feels modest in table count can still cross a million objects fast, and the maintenance compute is a second charge layered on top of storage.
AWS Glue Crawlers
Who this is for: teams that want Glue to discover schemas and detect new tables or partitions through ETL automation instead of defining every table by hand.
Base price: $0.44 per DPU-hour, with a 2 DPU minimum and a 10-minute billing floor on every single run.
What’s included: automatic schema and partition detection that feeds straight into the Data Catalog, useful wherever source structure shifts without warning.
Where this starts breaking down: that 10-minute minimum doesn’t care how fast the crawl actually finishes. A crawler that completes in thirty seconds still bills ten minutes, and scheduling one hourly instead of only when schemas actually change can quietly add over a hundred dollars a month for work that took seconds.
Interactive sessions & development endpoints
Who this is for: engineers doing interactive ETL development, either through Glue Studio notebooks or the older development endpoint setup.
Base price: $0.44 to $0.52 per DPU-hour depending on worker type, with a 5 DPU default. Interactive Sessions carry a 1-minute minimum; Development Endpoints carry a 10-minute minimum.
What’s included: configurable idle timeouts on Interactive Sessions, defaulting to 30 minutes, and free Glue Studio Job Notebooks that only charge for the sessions running underneath them.
Where this starts breaking down: Development Endpoints don’t stop on their own. An engineer opens one to test something, moves on, and it keeps billing DPU-hours in the background until someone notices the charge or sets up a CloudWatch alarm to catch it.
AWS Glue DataBrew
Who this is for: data analysts and engineers who want a visual, no-code environment for profiling, cleaning, and normalizing data before it enters a pipeline.
Base price: $1.00 per 30-minute interactive session; $0.48 per node-hour for DataBrew jobs. The two meters are independent, sessions are for interactive work in the DataBrew UI, jobs are for scheduled transforms.
Free tier: first-time DataBrew users get the first 40 interactive sessions free. That’s roughly 20 hours of interactive profiling at no charge before billing starts.
How the 30-minute session window works: any click or edit in a DataBrew project keeps the session alive. The session auto-closes at the end of the current 30-minute period if you’re inactive. If you cross into a second 30-minute block, you’re billed for two sessions ($2.00). Multiple users on different projects are billed separately.
Worked examples:
- Single 20-minute profiling session: $1.00
- Active session that runs 35 minutes: $2.00 (spans two 30-minute billing windows)
- DataBrew job running on 5 nodes for 2 hours: 5 x 2 x $0.48 = $4.80
Where this starts breaking down: DataBrew sessions and DataBrew jobs are two separate meters running on top of your core ETL spend. Teams that leave DataBrew projects open throughout the workday accumulate session charges quickly without realizing the clock is running.
AWS Glue Data Quality
Who this is for: teams that want automated rule-based quality checks on cataloged datasets, detecting anomalies, evaluating freshness, and validating schemas without writing custom validation scripts.
Base price: $0.44 per DPU-hour for recommendation tasks, rule evaluation, and anomaly detection jobs. 2 DPU minimum, 1-minute billing minimum.
What’s included: data quality statistics storage at no extra charge, subject to a 100,000 statistics per account limit.
Where this starts breaking down: Data Quality runs as DPU time layered on top of your existing ETL jobs. If you’re already paying for a Glue job to run, Data Quality evaluation adds a second DPU-hour charge on the same pipeline.
AWS Glue Zero-ETL
Who this is for: teams that want to move data in near real-time from application sources like DynamoDB, Aurora, or RDS to S3, Redshift, or SageMaker Lakehouse without writing or maintaining ETL code.
Base price: Zero-ETL integration setup carries no additional charge. For integrations that ingest from application sources, there is an ingestion cost of $1.50/GB with a 1 MB minimum per request. Destination costs are billed separately at standard rates:
- S3 destination: standard DPU-hour rates for any downstream Glue processing
- Redshift Managed Storage destination: standard Redshift Serverless compute rates
- SageMaker Lakehouse destination: depends on storage type (S3 Tables vs. Redshift Managed Storage)
- DynamoDB Zero-ETL: carries an additional export charge from continuous backups
Worked example: ingesting 10 GB of application data = $15.00 in source ingestion fees, plus destination compute at your chosen target’s standard rates.
Where this starts breaking down: Zero-ETL sounds free because the integration setup costs nothing, but the $1.50/GB ingestion rate adds up fast for high-volume change streams. High-frequency updates like an active OLTP database with constant order writes can generate more data volume than a comparable batch ETL job, and destination compute charges compound on top.
What actually drives your monthly cost on AWS Glue
Your final bill is the product of six independently scaling meters. Understanding which ones are moving is the prerequisite to controlling the total.
1. Job runtime and DPU allocation
AWS defaults every Spark job to 10 DPUs, and most workloads never need that much. Trimming to 3-5 workers instead of the default is the single biggest lever you actually control. Also watch for data skew: when one worker handles significantly more records than the others, it stretches total job runtime and inflates cost even if average worker utilization looks normal.
2. Execution class and worker type
Flex execution cuts the rate to $0.29 per DPU-hour for batch jobs that can wait. A real 34% discount. Memory-Optimized R workers push it up to $0.52; use them only when a job is genuinely memory-bound. Picking the wrong class in either direction leaves money on the table.
3. Data Catalog and managed compute volume
Every partition, table version, and index counts against your free million objects. Once you’re past it, Iceberg compaction and statistics generation add DPU-hour charges on top of plain storage. A table with frequent schema changes can run up Catalog costs that aren’t obvious from the ETL job bill alone.
4. CDC workloads and schema changes
CDC (change data capture) pipelines run jobs far more frequently than batch pipelines, multiplying DPU-hour costs proportionally. Schema evolution where source schemas change and Glue needs to update catalog entries or reprocess, can trigger unexpected runs. Late-arriving data may require separate backfill jobs. If you’re planning a CDC or near-real-time pipeline, model the job frequency, not just the per-run cost.
5. Adjacent AWS charges and idle resources
Standard S3, Redshift, and CloudWatch rates apply on top of whatever Glue itself charges. Cross-region setups add AWS data transfer fees keep your S3 buckets, Glue jobs, and target databases in the same AWS region wherever possible. A forgotten Development Endpoint or open Interactive Session keeps racking up DPU-hours long after anyone is actively using it.
AWS Glue cost traps to avoid
These are the six patterns that reliably inflate AWS Glue bills for teams that don’t catch them early.
Trap 1: Leaving Development Endpoints running
A 5-DPU endpoint running for 8 hours costs $1.76. A team of 10 engineers occasionally forgetting endpoints can generate $18 from a single incident, and that compounds daily. Set the three CloudWatch alarms described above before your team opens their first endpoint.
Trap 2: Skipping Job Bookmarks on incremental workloads
Without bookmarks, every run re-scans your entire source. On a growing 100 GB S3 dataset, a daily job without bookmarks reads 100 GB every day; with bookmarks, it reads only the new files added since the last run. The cost multiplier compounds as the dataset grows.
Trap 3: Running Crawlers on a fixed schedule instead of on change
The 10-minute billing minimum means a 30-second crawl costs as much as a 10-minute one. Running a crawler hourly on a dataset that changes weekly wastes most of that compute. Only trigger crawlers when source schema changes are expected, or use event-based triggers instead of time-based ones.
Trap 4: Using CSV or JSON instead of Parquet
Parquet and ORC read only the columns a job needs. CSV and JSON scan every byte of every row. For analytical workloads, switching to Parquet typically cuts job runtime by 30-70%. A direct reduction in DPU-hour charges, and also the fastest way to reduce Crawler runtime on large S3 buckets.
Trap 5: Ignoring the Data Catalog object count
A data lake with 50 tables, 100 partitions each, is already at 5,000 objects before factoring in table versions. Iceberg tables with frequent compaction push this higher. Monitor your object count before it crosses the free million; once it does, every query against the Catalog adds to the request bill too.
Trap 6: Cross-region data movement
Running S3 buckets in one region and Glue jobs in another adds AWS inter-region transfer fees that sit completely outside the Glue bill. On large pipelines, those transfer fees can rival the compute cost. Keep source buckets, Glue jobs, and target databases in the same AWS region.
How to estimate your AWS Glue costs
Before opening the AWS Pricing Calculator, gather these five inputs. Estimating without them produces a number that will be wrong by the time it matters.
- Number of ETL jobs per day, week, and month (separate counts if frequency varies by job)
- Average job duration – run a sample job on a representative dataset first; test conditions routinely undercount production runtime
- Required worker count per job – start with G.2X workers at 3-5 DPUs and only scale up if the job is memory-bound or produces data skew
- Crawl frequency and expected crawl duration per source
- Estimated Data Catalog object count: approximate tables x average partitions x expected version depth
Build in a 30% buffer
Production workloads consistently exceed test conditions. Data volumes grow, schema changes trigger reprocessing, and business seasonality spikes job frequency at unpredictable intervals. Add 30% to your initial estimate and revisit it after the first full month of production traffic.
For rough benchmarking: a moderate deployment running 5-10 daily batch jobs with 4-6 DPUs each, plus an active Data Catalog with a few hundred tables, typically lands in the $500-$2,000/month range for compute before adjacent S3, Redshift, or CloudWatch charges.
What are the key factors for predicting AWS Glue costs for data lakes and warehouses
1. Data Processing Unit (DPU) volume
AWS Glue charges per DPU-hour used by your jobs. Larger data volumes or complex transformations require more DPUs to finish tasks quickly, directly scaling up your hourly compute expenses. Selecting the right worker type, G.1X for light scripts, G.2X for standard Spark, G.4X or G.8X for memory-heavy work, materially changes your DPU consumption rate.
2. Job execution duration
The total runtime of your Apache Spark or Python Shell scripts dictates final costs. AWS Glue bills jobs with a 1-minute minimum, meaning long-running, unoptimized ETL tasks heavily inflate your monthly bill. Data skew can cause single workers to run longer than the rest of the cluster, delaying job completion without any increase in the actual work being done.
3. Data Catalog storage and request volume
Storing metadata tables and schemas in the Glue Data Catalog is free up to the first million objects and first million requests. Beyond that, millions of objects stored for expansive data lakes generate a persistent baseline fee. Continuous queries from Amazon Athena or EMR against the Catalog add to the request-based charges.
4. Crawler runtime and frequency
Glue Crawlers automatically discover datasets and populate the Data Catalog, consuming DPUs during execution. Running crawlers too frequently on large, mostly unchanged S3 buckets creates unnecessary processing expenses. Optimizing crawler schedules or switching to event-driven triggers prevents redundant scanning of static data lakes.
5. Interactive sessions and development overhead
Engineers using Glue Interactive Sessions incur costs based on cluster size and active duration. Leaving development sessions running while idle can quickly drain budget. Pre-configured Glue blueprints and DataBrew sessions also consume compute and session credits independently of your production ETL jobs.
AWS Glue pricing vs alternatives
AWS Glue isn’t the only data integration option teams weigh once DPU math gets old. Here’s how its starting price and core strength compare to three alternatives.
| Platform | Starting price | Key strength | Best for |
|---|---|---|---|
| AWS Glue | $0.44/DPU-hour (no flat plan; billed across 6 components) | Native AWS integration with zero infrastructure to provision | Teams already deep in AWS with in-house Spark or PySpark expertise |
| Hevo | $0/month (free tier, 1M events); $299/month Starter | No-code pipelines with event-based, predictable monthly pricing | Teams that want managed ETL without writing or tuning Spark jobs |
| Integrate.io | $1,999/month flat | Fixed fee for unlimited volumes, pipelines, and connectors | Teams wanting full cost certainty regardless of workload growth |
| Fivetran | $0/month (free tier, 500K MAR); usage-based, $5/month base | 700+ connectors with stable, low-maintenance pipelines | Enterprises replicating from complex, mainstream SaaS and DB sources |
Where AWS Glue pricing falls short as you scale
Costs increase in ways that rarely show up on one dashboard, because Glue splits your bill across six independently metered pieces instead of a single number.
- Six separate billing components: six separately metered components load onto one bill, so a spike in any one of them moves the total without warning
- Unused compute: default DPU allocations and crawler minimums bill for capacity nobody actually used, even when ETL best practices call for right-sizing workers upfront
- Idle resources run up charges: Development Endpoints and idle Interactive Sessions keep accruing charges until somebody manually shuts them down
Teams switch once they realize they’re spending more engineering time chasing these six numbers than the pipelines themselves cost to run.
How Hevo approaches pricing differently
Hevo is built around a simpler idea: one predictable number per month, tied to rows loaded, not six separate meters running at different speeds. It runs ETL as a service, so there’s no DPU sizing decision to make in the first place.
- Managed infrastructure means you never size a DPU, pick a worker type, or tune a Spark job yourself
- Predictable, event-based pricing replaces Glue’s six line items with a single number tied to rows successfully loaded
- A no-code pipeline builder means teams without a dedicated Spark engineer can still run production ETL
Teams tend to look at Hevo once DPU math and multi-line AWS bills start costing more engineering time than the pipelines they’re running.
AWS Glue vs Hevo: which is the better fit?
Choosing between Hevo vs AWS Glue comes down to how much Spark expertise your team has, and how much infrastructure you actually want to own.
| Criteria | AWS Glue | Hevo Data |
|---|---|---|
| Pricing structure | Usage-based across 6 metered components: DPU-hours, Catalog objects and requests, and session time | Event-based monthly SaaS model tied to rows successfully loaded |
| Scaling predictability | Low. Job runtime, worker sizing, and Catalog growth all move independently | High. Cost scales directly with monthly active rows |
| Infrastructure management | Serverless, but still requires manual DPU and worker sizing plus execution-class tuning | Fully managed. No sizing or tuning decisions required |
| Engineering skill requirement | Requires PySpark or Spark proficiency to write and optimize jobs | No-code visual pipeline builder; no Spark expertise needed |
| Workflow complexity | High: custom Spark logic, streaming, ML workloads through Ray, and built-in data quality rules | Focused: no-code replication and transformation, with dbt for advanced logic |
| Cost visibility | Abstract. Costs span 6 AWS billing line items plus adjacent service charges | Transparent. One dashboard shows rows loaded per pipeline |
| Best fit | AWS-native teams with dedicated data engineers and custom transform needs | Lean teams wanting managed, predictable ETL without a Spark specialist |
When AWS Glue makes sense (and when Hevo is a better choice)
Go for AWS Glue if
- You already have Spark expertise on staff: your team is fluent in PySpark and wants full control over transform logic
- You’re deep in the AWS ecosystem: native integration with S3, Redshift, and Lake Formation matters more than a separate vendor relationship
- Your workloads need custom processing: large-scale batch or streaming jobs that off-the-shelf connectors can’t handle on their own
- Flexibility beats predictability: you’d rather fine-tune every DPU and worker setting than accept a flat, less granular price
Go for Hevo Glue if
- You want predictable operational costs: a single monthly number beats usage-driven pricing that shifts across six components
- You need a managed platform: reliable data movement without hiring or maintaining Spark expertise in-house
- Speed matters more than granular control: fast implementation and simplified scaling outweigh code-level tuning of every job
Frequently asked questions about AWS Glue pricing
Does AWS Glue have hidden costs?
Not hidden exactly, but easy to miss until the invoice arrives. Development Endpoints left running, crawler minimums on frequent schedules, Data Catalog overages, cross-region data transfer fees, and adjacent S3 or Redshift charges all sit outside the headline $0.44 per DPU-hour rate.
Why does AWS Glue pricing increase as usage grows?
Because every component scales on its own. More jobs mean more DPU-hours, a growing data lake means more Catalog objects, and both follow the same trend toward pure consumption-based billing across the market.
Can I predict my monthly AWS Glue costs accurately?
Only if your workload is stable and already tuned. Teams running fixed-schedule batch jobs with right-sized DPU allocations can forecast within reason. Teams with growing data volume, frequent schema changes, or CDC workloads tend to see wider swings. A moderate deployment typically runs $500-$2,000/month in compute before adjacent charges.
What is the cheapest way to run AWS Glue?
Four changes together make the biggest dent: enable Flex execution for any batch job that doesn’t need an immediate start; enable Job Bookmarks on every incremental workload; switch source files from CSV to Parquet; and reduce your default DPU allocation from 10 to 3-5 for typical Spark jobs. Done together, these four optimizations can cut a typical bill by 40-60%.
How does Zero-ETL affect my bill?
The Zero-ETL integration itself is free to set up. What you pay for is application-source ingestion at $1.50/GB (with a 1 MB minimum per request), plus destination compute at the target’s standard rates. For low-volume integrations, Zero-ETL can be very cost-effective. For high-frequency change streams the ingestion cost can exceed what a comparable batch ETL pipeline would charge.
Do I need to know PySpark to use AWS Glue?
For anything beyond simple Python Shell scripts, yes. Writing and tuning Spark jobs, choosing worker types, and optimizing partitioning all require Spark or PySpark proficiency on your team.
When should teams switch from AWS Glue to Hevo?
Once the engineering time spent tuning DPUs and reconciling six AWS billing lines costs more than the pipelines are worth, or once a team without dedicated Spark expertise has to take over running them.
Is Hevo more expensive than AWS Glue overall?
It depends on workload complexity. Hevo keeps ETL cost at zero for up to 1 million events a month, with Starter beginning at $299. A moderately busy Glue setup running several daily jobs plus an active Data Catalog often lands in a similar range or higher once every component is added up.
Share it with your connections.
-
Share To X
-
Share To LinkedIn
-
Share To Facebook
-
Copy Link
