- 14 minutes to read

What does logging to Nodinite cost in Azure? Blob Storage vs Event Hub

When Azure services log to Nodinite, the Log Events pass through intermediate storage in your Azure subscription — a Blob Storage container or an Event Hub — before the Pickup Service moves them into the Nodinite Log Databases. The Nodinite license is a fixed-price offering that doesn't charge per GB or per event logged, but Azure does bill you for that staging step: storage transactions, Event Hub capacity, retention, and network traffic.

This page gives an honest breakdown of what adds to the Azure bill, with illustrative numbers by volume and message size, so you can choose the cheaper option for your workload and avoid the settings that quietly multiply the cost. It applies to every logging option that uses Blob Storage or Event Hub:

Note

All prices on this page are illustrative list prices (USD, pay-as-you-go, North America/Europe regions), not quotes. Prices change and differ by region and agreement. Use the Azure pricing calculator with your own volumes before you decide.

Understanding where the cost comes from

Every Log Event follows the same path. Each numbered step is a place where Azure can bill you:

graph LR SRC["fa:fa-cloud 1. Source
APIM, Function, Logic App"] --> |"2. Write"| STG["fa:fa-boxes-stacked 3. Staging
Blob container or Event Hub"] STG --> |"4. Read over the network"| PS["fa:fa-truck-pickup Pickup Service"] PS --> |"5. Delete or checkpoint"| STG PS --> DB["fa:fa-database 6. Nodinite Log Database"] style SRC fill:#2678BD style STG fill:#E47528 style PS fill:#3F827B style DB fill:#3F827B

Diagram: The Log Event path. Blue is the Azure source, orange is the Azure staging resource where most of the logging cost is billed, green is the Nodinite side.

Cost components explained

# Component What Azure bills Scales with
1 Source Source compute or actions that create the event (APIM gateway capacity, Function execution time, Logic Apps actions) Number of events; usually small
2 Write Blob: one write operation per event. Event Hub: ingress events, counted in 64 KB units Number of events (Event Hub: also event size)
3 Staging Blob: GB stored while waiting. Event Hub: throughput units (fixed hourly price) and retention storage Blob: almost nothing. Event Hub: peak MB/s and retention days
4 Network Data transfer out of the Azure region, when Nodinite runs on-premises, in another cloud, or in another region Total GB, so payload size matters most
5 Delete or checkpoint Blob: one read per event; delete is free. Event Hub: small checkpoint writes to a storage account Number of events; usually small
6 Nodinite side Your own SQL Server storage for the Log Databases, controlled by Message Types retention GB you choose to keep

The key point: Blob Storage costs scale with the number of events, Event Hub costs scale with throughput, and network costs scale with bytes.

Blob Storage vs Event Hub

Aspect Blob Storage container Event Hub (Standard tier)
Billing model Pay per operation (write, read, list) plus GB stored Fixed hourly price per throughput unit (TU), plus a small per-event ingress fee
Price basis used here Write operations $0.05 per 10,000, read operations $0.004 per 10,000 (Hot, LRS) $0.03 per TU-hour (about $22 per month), $0.028 per million ingress events
Minimum monthly cost Close to $0 when idle About $22 per month (1 TU) even when idle
Maximum event size No practical limit 1 MB for the Event Hub; APIM's log-to-eventhub policy limits events to 200 KB
How the Pickup Service reads Destructive read: each blob is deleted after successful pickup Non-destructive read: events stay until the retention period expires; the Pickup Service stores checkpoints in a storage container
Data kept in Azure Seconds to minutes (only what is waiting for pickup) The full retention window (1 to 7 days on Standard)
Outage buffer Blobs wait indefinitely until the Pickup Service is back Only as long as the retention period
Cheaper when Low to medium event counts, or large payloads High event counts with small payloads

Blob Storage: cost follows the number of events

With the Pickup Service deleting each blob after pickup, stored GB is close to zero. What you pay for is one write and one read per Log Event, plus a list call per polling cycle (about $0.43 per month for a 30-second polling interval). A 5 KB event and a 1 MB event cost the same in transactions.

Event Hub: cost follows the peak throughput

A throughput unit allows up to 1 MB/s or 1,000 events/s of ingress. You size for your peak, not your average, and you pay for every TU every hour. Ingress is billed per 64 KB unit, so a 190 KB event counts as three events. The ingress fee is small; the TUs dominate.

Event Hub Basic costs half as much per TU, but retention is limited to 1 day and it allows a single consumer group. A one-day retention means that an outage of the Pickup Service or the Nodinite database lasting longer than a day loses log events, so use Basic only where that is acceptable. Basic is a valid choice when one TU is enough; scaling up later, by adding TUs or moving to Standard or Premium, increases the fixed monthly cost.

Illustrative cost examples

These tables use the following assumptions. Change any of them and the figures change, so treat them as a way to see what drives the cost, not as a forecast.

  • Event size is the size of the JSON Log Event, including base64-encoded payload (base64 adds about one third to the payload size) and context properties
  • Volume is spread over a 30-day month; Event Hub is sized for a peak four times the average, with at least 1 TU
  • Blob Storage is Hot tier, LRS, with soft delete off, polled every 30 seconds
  • Event Hub is Standard tier with 1-day retention, which stays inside the included 84 GB per TU in every Event Hub example below

Data volume generated per month

Log Events/month 5 KB/event 15 KB/event 70 KB/event 190 KB/event 1.4 MB/event
1 million ~5 GB ~15 GB ~70 GB ~190 GB ~1.4 TB
10 million ~50 GB ~150 GB ~700 GB ~1.9 TB ~14 TB
100 million ~500 GB ~1.5 TB ~7 TB ~19 TB ~140 TB

Staging cost per month: Blob Storage

Log Events/month Any event size
1 million ~$6
10 million ~$54
100 million ~$540

Staging cost per month: Event Hub (Standard)

Log Events/month 5 KB/event 15 KB/event 70 KB/event 190 KB/event 1.4 MB/event
1 million ~$22 (1 TU) ~$22 (1 TU) ~$22 (1 TU) ~$22 (1 TU) Not possible (over 1 MB)
10 million ~$22 (1 TU) ~$22 (1 TU) ~$44 (2 TU) ~$67 (3 TU) Not possible
100 million ~$25 (1 TU) ~$68 (3 TU) ~$246 (11 TU) ~$665 (30 TU) Not possible

At low volume, Blob Storage is cheaper because there's no fixed cost. At high volume with small events, Event Hub is cheaper because one TU absorbs millions of events. With large events, Event Hub needs many TUs (and a Standard namespace tops out at 40 TUs), while Blob Storage stays flat.

Network egress per month, when Nodinite runs outside the Azure region

This is often the largest line item, and it is the same for Blob Storage and Event Hub, because it's the bytes that leave Azure. It applies when the Pickup Service runs on-premises, in another cloud, or reads over the internet. Calculated at the internet egress list price: first 100 GB free, then $0.087/GB, falling to $0.083/GB after 10 TB.

Log Events/month 5 KB/event 15 KB/event 70 KB/event 190 KB/event 1.4 MB/event
1 million $0 $0 $0 ~$8 ~$113
10 million $0 ~$4 ~$52 ~$157 ~$1,194
100 million ~$35 ~$122 ~$600 ~$1,609 ~$10,483

Tip

When the Pickup Service and the staging resource are in the same Azure region, this transfer is free. Between Azure regions it's about $0.02/GB. Over ExpressRoute, the cost depends on your circuit: metered plans bill outbound GB, unlimited plans don't.

Hidden costs that are easy to miss

These settings are often enabled by default or by policy, and they can cost more than the logging itself.

Setting Why it adds cost Example (10 million events/month at 70 KB) What to do
Blob soft delete Blobs the Pickup Service deleted are kept, and billed, for the soft-delete period (7 days by default on new storage accounts) About $3/month at Hot LRS; grows with volume and retention days Turn it off on the staging account, or use a dedicated account for log staging
Blob versioning and change feed Extra stored versions and change records for every write Varies Keep them off on the staging account
Microsoft Defender for Storage malware scanning On-upload scanning is billed per GB scanned (about $0.15/GB), on top of the per-account plan About $105/month Agree with your security team whether to exclude the staging account, or set a monthly scanning cap
Storage diagnostic logs to Log Analytics Every write, read, and delete becomes a log row ingested at Log Analytics prices (about $2.30/GB) About $100/month Log only what you need, for example only failed requests, or send to a storage account instead
Geo-redundant storage (GRS, RA-GRS) Higher write price plus geo-replication transfer per GB Roughly doubles the write cost Use LRS (or ZRS) for transient staging data
Cool, Cold, or Archive tier Higher per-operation price and early deletion fees (minimum 30, 90, or 180 days) on blobs that live for seconds Several times the Hot cost Keep the staging container on Hot
Hierarchical namespace (Data Lake Storage) Operations are billed per 4 MB chunk, and directory operations add transactions Higher for large events Use a standard (flat namespace) storage account
Event Hub auto-inflate Scales TUs up on a spike but never scales them down A one-off spike to 10 TUs costs about $219/month until you reduce it manually Set a sensible maximum, and monitor and reduce TUs after spikes
Event Hub Capture Billed per TU; Nodinite doesn't need it About $73 per TU per month Leave Capture off
Event Hub retention beyond included storage Standard includes 84 GB per TU; storage over that is billed Only at high volume with long retention Size retention for outage recovery, not archiving (see below)
Private endpoints An hourly fee plus a per-GB processing fee in each direction About $7/month plus $0.01/GB Required by many security policies; include it in the estimate
Backout container growth Invalid blobs are moved to the backout container and stay there Small, unless a source keeps sending bad events Monitor the backout container and fix the source

How to reduce the cost

Step 1: Place the Pickup Service close to the staging resource

Network egress grows with every byte. If Nodinite runs on-premises, check the egress table above with your real volumes first. Running the Pickup Service in the same Azure region removes that cost; the Pickup Service then forwards to your Nodinite Log API.

Step 2: Choose the staging option by volume and size

  • Low to medium event counts, or payloads above about 150 KB: Blob Storage
  • High event counts with small payloads (millions of events per day): Event Hub
  • You can mix: send large-payload flows to Blob Storage and high-volume small events to Event Hub

Step 3: Log what you need, not everything

Every event you don't send saves a write, a read, and its bytes over the network. Filter health probes and polling calls at the source, avoid logging the same message at several steps when one carries the payload, and leave out headers you'll never search on. Use Message Types and Search Fields so the events you do keep stay useful.

Step 4: Configure the staging resources for transient data

For Blob Storage: Hot tier, LRS, flat namespace, soft delete and versioning off, and a lifecycle management rule as a safety net for blobs left behind. Enable Remove Empty Blobs in the Blob Container configuration.

For Event Hub: start with 1 TU, cap auto-inflate, leave Capture off, and set retention for outage recovery. In production, keep at least 24 hours; 3 to 7 days covers a weekend outage. See the Event Hub configuration for the checkpoint container setup.

Step 5: Turn off duplicate Azure logging of the same payloads

If Nodinite keeps the payloads and the long-term history, you may not need Azure to store them too. Check Application Insights and Log Analytics for payload logging and long retention that duplicate what Nodinite already stores. For workload-specific settings, see Reduce Azure API Management Logging Costs, Reduce Azure Logic Apps Run History Retention to Lower TCO, and Reduce Azure Functions Logging Costs.

Source-side costs by logging option

The staging and network costs above are the same for every source. The source itself adds its own, usually smaller, cost:

Logging option Additional source-side cost Read more
Azure API Management policy No extra billed API calls, but buffering and base64-encoding bodies uses gateway capacity Reduce Azure API Management Logging Costs
Serilog sink in Azure Functions or App Service A few milliseconds of execution time per event on consumption plans; nothing extra on dedicated plans Reduce Azure Functions Logging Costs
Logic Apps custom logging (Blob action) Consumption: one billed connector action per log step. Standard: runs on the compute you already pay for About Logic Apps Logging options
Logic Apps diagnostic settings to Event Hub Diagnostic events are small; the large cost is usually the run history, not the stream Reduce Azure Logic Apps Run History Retention to Lower TCO

Costs on the Nodinite side

Nodinite is a fixed-price offering: the license cost doesn't change with the number of Log Events or GB you log. The Log Events end up in Log Databases on your SQL Server, so storage there is your own cost, whether on-premises or in Azure. You control it with Message Types retention: for example, keep invoices for 7 years and test messages for 30 days. This is usually far cheaper than storing the same payloads in Log Analytics or Application Insights at per-GB ingestion prices.

Built for developers and the business

The largest benefit doesn't appear in any cost table. Azure Monitor (Application Insights, Log Analytics, and Logic Apps run history) is built for developers and operators: access goes through Azure RBAC on resources and workspaces, data is searched with KQL queries, and each Azure service keeps its own data. Giving a business user access means Azure portal access, query skills, and knowing which service to look in.

Nodinite is built for developers and the business, with the same logged data:

Need Azure Monitor Nodinite
Who can search the data Users with Azure RBAC access to each resource or workspace Anyone you grant a Role, with no Azure portal access
How they search KQL queries Log Views with Search Fields, by Order ID, Invoice Number, or Customer ID
What they can see Everything in the resource or table they can access Only the Log Views their Roles allow, down to Message Type and business data
Across services One resource or workspace at a time One Log View across Functions, Logic Apps, API Management, BizTalk, and on-premises systems
Business processes Separate tooling, such as Business Process Tracking for Logic Apps BPM on the data you already log

When business users can answer "did the order arrive?" or "was the invoice sent?" themselves, the questions stop going to developers and the operations team. That saves time on both sides, every day, and it's why many customers value self-service more than the Azure savings.

Important pricing notes

Actual costs depend on:

  • Azure region, currency, and your pricing agreement (EA, MCA, CSP, reservations)
  • number of Log Events and their real size after base64 encoding
  • peak traffic, not only the monthly average
  • where the Pickup Service and the Nodinite databases run
  • storage account settings: redundancy, tier, soft delete, Defender, diagnostics
  • Event Hub tier, TUs, auto-inflate, and retention
  • private endpoints, firewalls, and ExpressRoute

Microsoft references

Next Steps