Direct answer: at Azure Digital Twins public list prices on 11 November 2026 (eastus, USD, excluding tax and discounts), there are only three billing dimensions: Operations $2.50/million, Messages $1.00/million, and Query Units $0.50/million. There is no upfront or termination fee; billing is monthly by consumption. Operations meter API response bodies in 1 KB increments: 0.5 KB counts as 1, 1.5 KB as 2; Messages meter event-route payloads in 1 KB increments: 0.5 KB counts as 1, 1.5 KB as 2; Query Units depend on query complexity and result-set size. At 100M operations + 50M messages + 100M QU: $250 + $50 + $50 = $350/month; 100M calls with 2 KB responses = 200M operations = $500. The budget risks are large response bodies, large event payloads, complex queries and high-frequency polling, not the unit prices.
This guide is for architects, IoT/data platform, SRE, finance and procurement building IoT/building/factory/energy digital twins, evaluating Azure Digital Twins versus IoT Hub device twins, or budgeting the twin graph/event routes/queries. It separates official prices, editorial calculations and exclusions, covering the three meters, 1 KB rounding, monthly TCO, Query Units, device/event volume, optimization and a 90-day checklist. Prices come from the Digital Twins pricing page, Azure Retail Prices API and Microsoft Learn overview/Query Units docs (11 November 2026). This is not procurement advice.
(1) Three meters: operations $2.5/million, messages $1/million, query units $0.5/million; there is no "instance fee". (2) Operations meter API response bodies in 1 KB increments and messages meter payloads in 1 KB increments: 1.5 KB counts as 2, so large bodies double the bill. (3) Query Units depend on complexity and result-set size; dashboards/large-result queries can cost more than CRUD. Event Hub/Grid/Service Bus egress bills separately.
Three meters: operations, messages, query units
Billing has three dimensions: Operations (each ADT API call, metered by response body in 1 KB increments), Messages (messages sent by event routes to destinations outside ADT such as Event Grid/Event Hub/Service Bus, metered by payload in 1 KB increments), and Query Units (on-demand computation for the Query API, affected by complexity and result-set size). The pricing page has no separate storage/instance fee; billing is monthly by consumption. Downstream Event Hubs/Grid/Service Bus, storage and compute bill at their own prices.
| Meter | Price (eastus) | Unit | Note |
|---|---|---|---|
| Operations | $2.50 | Per million | API calls; response 1 KB increments |
| Messages | $1.00 | Per million | Event routes outside ADT; payload 1 KB increments |
| Query Units | $0.50 | Per million QU | Query API complexity/result set |
| Instance/storage fee | None | — | No separate meter on the pricing page |
| Downstream Event Hubs/Grid | Separate | Each service | Event route targets |
Sources: Digital Twins pricing page and Retail API (eastus, 11 November 2026). Retail API per 1K: Message 0.001, Operations 0.0025, Query Units 0.0005; converted to per million. Excludes tax and discounts.
1 KB rounding: 0.5 KB counts as 1, 1.5 KB as 2
Official FAQ: operations meter API response bodies in 1 KB units—0.5 KB counts as 1, 1.5 KB as 2; messages meter event payloads in 1 KB units—0.5 KB counts as 1, 1.5 KB as 2. So a 1 MB response is not 1 operation but about 1,024; a 1 MB event is about 1,024 messages. Large objects/JSON/history arrays are the easiest way to inflate the bill.
| Scenario | Billed units | Cost |
|---|---|---|
| 1M API calls, 0.5 KB response | 1M ops | $2.50 |
| 1M API calls, 1.5 KB response | 2M ops | $5.00 |
| 1M API calls, 1 MB response | ~1.024B ops | $2,560 |
| 1M events, 0.5 KB payload | 1M messages | $1.00 |
| 1M events, 1.5 KB payload | 2M messages | $2.00 |
| 1M events, 1 MB payload | ~1.024B messages | $1,024 |
Editorial calculation: 1 KB=1 unit, rounded up; 1 MB=1,024 KB; cost = units/million × price; excludes downstream, tax and discounts.
Monthly TCO: small/medium/large
Stack the three meters: small 10M ops + 5M messages + 10M QU = $25 + $5 + $5 = $35/month; medium 100M ops + 50M messages + 100M QU = $250 + $50 + $50 = $350/month; large 1B ops + 500M messages + 1B QU = $2,500 + $500 + $500 = $3,500/month. If API responses/event payloads average 2 KB, ops/messages double; if query result sets are large, QU can exceed ops cost.
| Scale | Ops | Messages | QU | Total/month |
|---|---|---|---|---|
| Small | 10M = $25 | 5M = $5 | 10M = $5 | $35 |
| Medium | 100M = $250 | 50M = $50 | 100M = $50 | $350 |
| Large | 1B = $2,500 | 500M = $500 | 1B = $500 | $3,500 |
| Medium, 2 KB bodies | 200M = $500 | 100M = $100 | 100M = $50 | $650 |
| Medium, 10 QU/query | 100M = $250 | 50M = $50 | 1B = $500 | $800 |
Editorial calculation: each meter's volume/million × price; 2 KB and 10 QU/query are example assumptions; excludes downstream event services, storage, compute, tax and discounts.
Query Units: complexity and result set
Official definition: a Query Unit (QU) is on-demand computation for the Query API, abstracting CPU/IOPS/memory. Consumption is affected by query complexity and result-set size—a query returning 10 results usually uses more QU than a similar query returning 1. The Query API response header includes `query-charge`, readable by the SDKs; that is the reliable budget input, not a guessed "QU per query". At $0.50/million QU: 10M QU=$5; 100M QU=$50; 1B QU=$500. Dashboards/large graph scans/complex joins can cost more than CRUD.
| Queries | QU/query | Total QU | Cost/month |
|---|---|---|---|
| 1M | 1 | 1M | $0.50 |
| 1M | 10 | 10M | $5.00 |
| 10M | 10 | 100M | $50.00 |
| 10M | 100 | 1B | $500.00 |
| 100M | 10 | 1B | $500.00 |
Editorial calculation: queries × QU/query × $0.50/million; QU/query is an example assumption; actual usage follows the `query-charge` header/monitoring; excludes tax and discounts.
Device/event volume: event routes are the message line
ADT Messages only count messages sent by event routes to destinations outside ADT; inbound telemetry itself is not counted (it usually goes through IoT Hub/other services and bills there). If each device update routes one event: 1,000 devices×1/min×43,200 min/month ≈ 43.2M messages = $43.20/month; 10,000 devices = 432M = $432/month. At 2 KB payload, double it. Route only changes that downstream needs, batch/merge, or aggregate downstream to cut messages.
| Devices/update | Messages/month | Cost/month (1 KB) | 2 KB |
|---|---|---|---|
| 1,000 × 1/min | ~43.2M | $43.20 | $86.40 |
| 5,000 × 1/min | ~216M | $216.00 | $432.00 |
| 10,000 × 1/min | ~432M | $432.00 | $864.00 |
| 1,000 × 1/5 min | ~8.64M | $8.64 | $17.28 |
| 1,000 × 1/hour | ~720K | $0.72 | $1.44 |
Editorial calculation: devices × frequency × 43,200 minutes/month; assumes one routed event per update; excludes inbound telemetry, IoT Hub, downstream Event Hubs/Grid, tax and discounts.
Optimization and 90-day checklist
Six optimizations: (1) compress API responses/event payloads under 1 KB; (2) batch/merge events to cut messages; (3) route only changes downstream needs, avoid full fan-out; (4) limit query result sets/paging and monitor `query-charge`; (5) cache hot twins/query results to cut repeated ops; (6) budget Event Hubs/Grid/Service Bus, storage and compute separately. 90 days: weeks 1–2 inventory APIs, event routes, queries and downstream targets; weeks 2–3 calculate ops/messages with 1 KB rounding; weeks 3–4 sample QU via `query-charge`; weeks 4–6 optimize payloads/batching/caching; weeks 6–8 load-test peaks/queries; weeks 8–10 reconcile downstream event/storage bills; weeks 10–12 set ops/messages/QU alerts.
| Cost item | Trigger | Control |
|---|---|---|
| Operations | API calls × response KB | Compress/cache/reduce polling |
| Messages | Event routes × payload KB | Route only needed changes/batch |
| Query Units | Query complexity/result set | Page/limit results/read query-charge |
| Downstream Event Hubs/Grid | Event targets | Budget per target |
| IoT Hub/inbound | Device telemetry | Billed by IoT Hub |
| Storage/compute | History/analytics/apps | Per downstream service |
Editorial summary: resources outside the price list bill as other Azure services; IoT Hub/Event Hubs/storage/compute are not estimated here.
FAQ
How is Azure Digital Twins billed?
Three dimensions: Operations $2.50/million, Messages $1.00/million, Query Units $0.50/million; no upfront/termination fee, monthly by usage. Operations meter response bodies in 1 KB increments; Messages meter payloads in 1 KB increments.
What does 1 KB rounding mean?
A 0.5 KB API response counts as 1 operation, 1.5 KB as 2; a 0.5 KB event payload counts as 1 message, 1.5 KB as 2; 1 MB is about 1,024 units.
What do 100M operations cost?
If each response is ≤1 KB: 100M/1M×$2.50=$250. At an average 2 KB, it is 200M ops=$500. Large response bodies double the bill.
What do Messages count?
Only messages sent by event routes to destinations outside ADT (Event Grid/Event Hub/Service Bus, etc.), metered by payload in 1 KB increments; inbound telemetry/IoT Hub bills separately.
How do I estimate Query Units?
QU depends on query complexity and result-set size; read the `query-charge` response header from the Query API and multiply by $0.50/million. Don't guess a fixed QU per query.
What do 1,000 devices updating every minute cost?
If each update routes one 1 KB event: 1,000×43,200≈43.2M messages=$43.20/month; at 2 KB, $86.40. Inbound telemetry/IoT Hub/downstream are extra.
ADT or IoT Hub device twins?
Choose ADT for a twin graph/relationships/complex queries/event routes; IoT Hub device twins are more direct for device registration/twin management. They can be combined; costs are separate.
How do I reduce cost?
Six steps: compress responses/events under 1 KB, batch/merge events, route only needed changes, limit query result sets and monitor query-charge, cache hot data, and budget downstream Event Hubs/storage/compute separately.
Research method and limitations
Official facts (pricing FAQ, Retail API, Learn overview/Query Units docs): three meter prices, operations metered by response body in 1 KB increments, messages by payload in 1 KB increments, Query Units affected by complexity/result set, `query-charge` header, no upfront/termination fee. Editorial calculations: 1 KB=1 unit, 1 MB=1,024 KB; small/medium/large TCO; 2 KB/10 QU examples; devices×frequency×43,200 minutes.
Seven limitations: (1) eastus USD list prices only, excluding tax/contract discounts/regional differences; (2) API/event/query volumes, payload sizes and QU/query are editorial assumptions; (3) excludes IoT Hub, Event Hubs/Grid/Service Bus, storage, compute, network and labour; (4) no real API/event/query benchmark; (5) multi-target event routing/retry metering needs bill verification; (6) the boundary with other digital-twin services (e.g., Fabric digital twin builder) is not covered; (7) prices/metering change—recheck official pages and bills before purchase.
Sources and basis
- Microsoft Azure, Azure Digital Twins Pricing: azure.microsoft.com/en-us/pricing/details/digital-twins. Operations/Messages/Query Units prices, 1 KB rounding, billing FAQ. Accessed 11 November 2026.
- Azure Retail Prices API (productName eq Digital Twins, eastus): prices.azure.com/api/retail/prices. Message 0.001/1K, Operations 0.0025/1K, Query Units 0.0005/1K. Accessed 11 November 2026.
- Microsoft Learn, What is Azure Digital Twins?: digital-twins/overview. Twin graph, models, event system, queries, IoT Hub relationship. Accessed 11 November 2026.
- Microsoft Learn, Query Units in Azure Digital Twins: concepts-query-units. QU definition, complexity/result-set impact, `query-charge` header. Accessed 11 November 2026.
Data cut-off 11 November 2026; prices/features follow Microsoft official pages and bills; this is not procurement, architecture or legal advice.