Size an IoT SIM card in India from the bytes each device report really uses, and measure that number against your own server, because the connection costs far more than the reading. When we sent an 82-byte sensor reading to our own site over HTTPS, a fresh TLS 1.3 connection used 4,844 bytes, and the same report on a connection that was already open used 870. Over a month of five-minute reports that is the difference between about 47 MB and 9 MB per device. The SIM itself has to be an M2M connection: in June 2024 the Department of Telecommunications told operators that new M2M connections are issued only on 13-digit numbers, under its M2M KYC rules (DoT letter of 14 June 2024).
We measured one report against our own site
On 18 November 2026 we wrote a short Python script, standard library only, that posts a device-style reading to the staging copy of elrootlabs.com. Staging runs on Cloudflare's edge with the same kind of certificate as the live site. The reading is 82 bytes of JSON: a device id, a timestamp, temperature, humidity, battery voltage and signal strength. The script sits between Python's TLS layer and the network socket, so it counts every encrypted byte in each direction, and its totals came within 11 bytes of the TCP byte counts the operating system reported.
We limited the key exchange to one curve, P-256, to keep the client's first message small, as a device would; one extra case uses OpenSSL's default settings. Each case ran five times and we kept the median; the five runs agreed within 40 bytes. The address we posted to is a static file, so the server refuses the POST with a 405 status and an empty body. That has the same shape as a bare acknowledgement from an ingest endpoint, and it changes nothing on the site.
| How the device connects | TLS handshake bytes | Total bytes for one report |
|---|---|---|
| New connection, TLS 1.3, post-quantum key share offered | 5,511 | 6,909 |
| New connection, TLS 1.3 | 3,476 | 4,844 |
| New connection, TLS 1.2 | 3,369 | 4,265 |
| New connection, TLS 1.3, resumed session | 914 | 2,282 |
| New connection, TLS 1.2, resumed session | 730 | 1,625 |
| Connection already open | 0 | 870 |
| The reading itself | none | 82 |

The totals include the request, the reply and the handshake, all encrypted. They do not include TCP/IP headers, DNS lookups or retransmissions; the monthly figures further down add an allowance for the headers.
The handshake costs more than the reading
In the fresh TLS 1.3 case, 3,476 of the 4,844 bytes were handshake, and 2,879 of those came from the server. The three certificates it sends account for 2,512 of them: our site's certificate (943 bytes), the intermediate that signed it (675) and a cross-signed root (894). The reading was 82 of the 4,844 bytes, less than 2 bytes in every 100.
The reply also outweighed the request. On a connection that was already open, the request was 260 bytes and the reply 610, almost all of it response headers; curl counted a 502-byte header block on the same reply. A device that only needs "received" back still downloads every header the server and the edge attach. If you run the ingest endpoint, you decide what it sends back.
These are our numbers, for our server and our certificate chain. A different host, an RSA certificate or a longer chain moves them, which is the main reason to run the measurement against the server your devices will actually talk to.
TLS 1.3 cost more than TLS 1.2 on our server
We expected TLS 1.3 to be the lighter protocol. On our server it was heavier: 4,844 bytes against 4,265 for a fresh connection, and 2,282 against 1,625 for a resumed one. The difference sits in the first reply. After a TLS 1.3 handshake the server sent new session tickets, which made the first reply on every new connection 1,091 to 1,108 bytes against 610 for a later reply on the same connection. RFC 8446 allows a server to send a ticket at any time after the handshake, and to send several (section 4.6.1). A device that keeps its connection open pays for the tickets once; a device that reconnects for every report pays every time.
We would not move a fleet to TLS 1.2 because of this. The lesson is narrower: a setting on the server changed which protocol was cheaper, so measure before you size the plan.
The post-quantum case is worth budgeting for. When the client offered OpenSSL 3.5's default key exchange, which includes the hybrid X25519MLKEM768 group, a fresh connection grew by 2,065 bytes to 6,909. If your device's TLS library offers it, plan for the bytes rather than switching it off without thinking; our post on post-quantum cryptography covers what those bytes protect.
What that means per device per month
To turn bytes per report into a plan size we assumed a 30-day month and counted 1 MB as a million bytes. For TCP/IP headers we used the minimum sizes, 20 bytes for an IPv4 header (RFC 791) and 20 for a TCP header (RFC 9293), so 40 bytes a packet. Counting the packets in the exchange, a new connection takes about 15 (opening, handshake, request, reply, acknowledgements and closing), which adds 600 bytes. A report on an open connection takes about 4, which adds 160. If your devices get IPv6 addresses, each header is 20 bytes larger, because the IPv6 header is 40 bytes (RFC 8200).
| How the device connects | Bytes per report | Every minute | Every 5 minutes | Every 15 minutes | Every hour |
|---|---|---|---|---|---|
| New connection each report, TLS 1.3 | 5,444 | 235.2 MB | 47.0 MB | 15.7 MB | 3.9 MB |
| New connection each report, TLS 1.3 resumed | 2,882 | 124.5 MB | 24.9 MB | 8.3 MB | 2.1 MB |
| New connection each report, TLS 1.2 resumed | 2,225 | 96.1 MB | 19.2 MB | 6.4 MB | 1.6 MB |
| One connection kept open | 1,030 | 44.5 MB | 8.9 MB | 3.0 MB | 0.7 MB |
| The reading alone | 82 | 3.5 MB | 0.7 MB | 0.2 MB | 0.1 MB |
For a fleet of 1,000 devices reporting every five minutes, that is 47.0 GB a month if every report opens a fresh TLS 1.3 connection, and 8.9 GB if each device keeps one connection open. The reading itself is 0.7 GB of it.
The kept-open row assumes the connection survives between reports. On a mobile network that depends on how long the operator's network and your server keep an idle connection alive, which we did not measure, and the keep-alive packets that hold it open are not in the table. At hourly reporting a device will usually reconnect, so read the hourly column from the resumed rows.
Cut the bytes in the firmware before you buy a bigger plan
Most of the bill is set by how the firmware connects, so that is where the savings are.
- Keep one connection open and send every report on it. If you cannot, resume the TLS session when you reconnect: on our server that took a TLS 1.2 report from 4,265 bytes to 1,625.
- Batch readings when nobody needs them within the minute. Five one-minute readings sent together every five minutes add 335 bytes to the request. With a fresh TLS 1.3 connection per report, that brings a device from 235.2 MB a month to 49.9 MB; on an open connection, from 44.5 MB to 11.8 MB. The price is that data arrives up to five minutes late. Batching also saves battery, as the worked ESP32 estimate in our IoT prototype guide shows.
- Keep the reply small. Your ingest endpoint can answer with a status line and the few headers the device reads.
- Measure once more on a real SIM before you order. Our script ran on an office connection, and a mobile network adds its own behaviour around idle connections and retries.
The SIM itself: a 13-digit M2M connection under DoT's KYC rules
India treats a device's mobile connection as machine-to-machine (M2M), with its own numbering and KYC rules. In a letter to all access licensees dated 14 June 2024, the Department of Telecommunications answered requests from some authorities and system integrators for 10-digit SIMs for M2M use, without end-user KYC. It said M2M SIMs can only be issued under its guidelines of 16 May 2018 as amended, that only 13-digit SIMs have been allowed for new M2M connections to M2M Service Providers since 1 October 2018, and that operators must follow the existing KYC framework for every new M2M connection (DoT letter). So a consumer 10-digit SIM is the wrong route for a fleet of devices.
We have not compared operators' plans here. We have no first-hand plan data to show, and plans change. Work out the need first, then put these questions to each operator:
- Will the SIMs be issued as 13-digit M2M connections, and what KYC do you need from us and from the end customer?
- Is the data allowance shared across the whole fleet or capped per SIM, and what happens when one SIM goes over: it slows down, stops, or costs more?
- How long does an idle connection stay open on your network before it is dropped? The answer decides whether the kept-open row applies to you.
- Will devices get IPv4 or IPv6 addresses?
- Can we see usage per SIM, so a device stuck in a reconnect loop shows up before the bill does?
Frequently asked questions
How much mobile data does an IoT device use per month? It depends far more on how the device connects than on the size of the reading. In our measurement, the same 82-byte reading every five minutes came to 47.0 MB a month with a fresh TLS 1.3 connection per report and 8.9 MB on a connection kept open, with TCP/IP headers estimated at the minimum sizes in RFC 791 and RFC 9293.
Do I need a 13-digit SIM for an IoT device in India? For a new M2M connection, yes. The Department of Telecommunications' letter of 14 June 2024 says only 13-digit SIMs have been allowed for new M2M connections since 1 October 2018, issued under its M2M KYC guidelines.
Does TLS 1.3 use less data than TLS 1.2? Not on our server. TLS 1.3 used 4,844 bytes for a fresh report against 4,265 for TLS 1.2, because the server sent new session tickets after every TLS 1.3 handshake, which RFC 8446 allows. Measure against your own server before you choose.
