Just two years ago, “DePIN” (decentralized physical infrastructure) felt like another hype cycle. Today, it’s become a visible driver of real blockchain use: you can point to real user adoption, terabytes moved, GPUs leased, and capital raised. That matters because DePIN isn’t a vibe, it’s a real utility backbone. And the part that quietly touches almost everything from blockchains and mapping to inference and public datasets is data.
And that’s the hinge for what comes next. Across DePIN verticals—wireless offload, decentralized mapping, GPU markets, oracle networks, storage—the same pattern shows up: data is both the payload and the product. DePIN for data is the data plane flipping from rented pipes to user-owned rails: same internet, fewer choke points, auditable receipts, in essence, a market for data, not a middleman.
This piece takes a clear look at DePIN’s current footing and momentum, where adoption is real and why it matters, then clarify what “DePIN for data” means—what it covers, how value flows, and where it’s already working, with examples from multiple networks; and then uses Pocket Network as a grounded case study to show how a user-owned data plane operates at the edge and in provisioning. The aim is practical: to provide enough context to understand the shift and offer concrete ways builders can try it without rewriting their stack.
State of the DePIN Ecosystem
By the numbers, DePIN is now a measurable slice of crypto. On CoinGecko, the DePIN category is valued at around $17.5B today, while CoinMarketCap’s DePIN view shows roughly $33.4B, a gap that mostly reflects different inclusion criteria, not directionality. On CoinGecko’s global dashboard (about $4.04T total), DePIN accounts for roughly 0.4% of the market by value at this snapshot.
Hardware participation is compounding as well. Messari reports that on IoTeX’s DePIN stack, registered devices climbed 337% YoY to 12,100, while ioID device owners increased 1,697% YoY by September 2025, clearly demonstrating momentum on the “real devices, real data” front.
For a broader headcount, DePINscan has tallied over 420 active DePIN projects with almost 42M devices in the wild. In its Technology Convergence Report (June 2025), the World Economic Forum frames DePIN as a $30–50B sector with over 1,500 projects today. It indicates it could reach approximately $3.5 trillion by 2028 as AI and blockchain converge.
On usage and capital, a few clean signals stand out:
- By the end of Q2 2025, Helium Mobile‘s cumulative carrier offload reached over 2,721TB, and total accounts climbed to more than 311,200, up 138.5% QoQ and 94.1% YoY, respectively, which is evidence of mainstream payload on a user-owned network.
- Bee Maps (built on Hivemapper) closed a $32M round on October 6, 2025, to scale contributor hardware and its AI pipeline. Official network stats cite 644 million km mapped in total, including 21 million km of unique roadway, underscoring a data supply that goes far beyond pilots.
- Akash Network generated over $1.0M in Q1 2025 lease revenue (+38% QoQ) as enterprise/AI GPU jobs grew; Q2 held about $0.82M despite fewer leases, reflecting a pivot to fewer, larger workloads and expanded access to A100/H100/H200-class GPUs.
- As of Q2 2025, Filecoin hosted 2,416 onboarded datasets (+3% QoQ), with 864 exceeding 1,000 TiB (+7.5% QoQ), pointing to continued enterprise and research adoption for high-volume, durable storage.
- On June 3, 2025, Pocket Network completed the Shannon upgrade cutover (“State Shift Day”), with 75–85% of POKT migrated within weeks. The tokenomics were switched to mint = burn, tying issuance directly to on-chain usage—positioning Pocket as a permissionless open API/data network.
These aren’t cherry-picked outliers; they’re representative proof points that DePIN has crossed from concept to operational usage across multiple verticals, even if growth is uneven by niche and region. From here, the interesting question isn’t whether DePIN exists; it’s how the model is being applied to data—production, movement, verification, and payment—across chains, APIs, and AI endpoints.
How DePIN Verticals Stack Up in 2025
Methodology: This chart compares the overall strength of each DePIN vertical in 2025 by summing five 0–5 scores across five categories (adoption, etc). The scores are a directional editorial composite drawn from public 2025 signals and reports (such as Messari research, CoinGecko category snapshots, etc., and project updates from Helium, Akash, etc).
What DePIN for Data Actually Means
First things first; let’s align on the baseline and explain what DePIN itself is, so the roles, incentives, and moving parts are clear.
What is DePIN
DePIN—decentralized physical infrastructure networks—are systems where real-world resources are supplied by many independent operators and coordinated by an open protocol. Instead of one company owning the radios, cameras, GPUs, or storage, participants contribute the hardware (or bandwidth, or energy), stake or register to the network, and earn based on measured usefulness. It’s not just a token representing a business like in typical web3 projects; it’s a business model for running infrastructure as a market.
Why “for Data” is its own lane
Plenty of DePIN verticals exist—wireless, compute, storage, mapping, etc., but data threads through them all. “DePIN for Data” focuses on the production, movement, verification, and payment of data itself: chain state, historical lookups, index queries, map tiles, telemetry, model outputs, and public datasets. This is different from DeFi, NFTs, or gaming content. Those ecosystems use data, but they don’t necessarily marketize the path that produces and serves it. DePIN for Data does: it treats the data plane as a marketplace with clear roles and receipts.
How it works—the operating model
A DePIN-for-data network splits the data plane into four jobs so each can evolve without breaking apps. Access is the URL you own (auth/routing/cache); Provisioning is the byte-serving layer run by independent operators (nodes, indexers, models); Accounting is an on-chain meter that prices requests as work; Assurance bakes in quality via quorums, archival checks, and normalized errors. The separation keeps your endpoint stable while suppliers compete and costs/receipts stay auditable.
To make the split easy to understand, here’s a quick reference that summarizes these separations:
Quick reference table
| Job | What it does | Who runs it | Why it matters |
| Access | Your URL, auth, routing, cache | App/team (or operator) | Keep control at the edge; change backends without breaking clients |
| Provisioning | Serve the bytes (nodes, indexes, APIs, models) | Independent suppliers | Compete on quality; diversify sources |
| Accounting | Price and record work on-chain | Protocol | Transparent costs and payments |
| Assurance | Validate results, normalize errors | Edge + protocol rules | Reliability by default, not scripts |
Auditability: the trait that makes it “DePIN”
Auditability is where DePIN for Data departs from traditional API aggregation. Requests map to measurable work; proofs and receipts land on-chain; and payouts follow those receipts. That gives you:
- cost you can attribute (and even show your users),
- performance you can benchmark across suppliers,
- and a shared record that the ecosystem can use to govern against (e.g., disqualifying poor service).
How it differs from data in other ecosystems
- DeFi coordinates value; DePIN for Data coordinates work. A swap routes liquidity; a data relay routes effort, and pays per useful output.
- NFTs/gaming curate assets and content; DePIN for Data curates the pipelines that produce, verify, and deliver bytes.
DePIN for Data Architectural Framework Across Sectors and Projects
Pocket Network as a DePIN-for-Data Reference
What Pocket Network is (at a glance)
Pocket Network is a decentralized access layer for open data. It coordinates gateways and independent node runners to serve on-chain reads/writes across many networks, using the POKT token to align costs and rewards. Pocket Network serves data to 50+ chains and allows developers to connect once with resilient, low-cost access; since launch (2020), the network has handled hundreds of billions of relays across a global node set, with an average of 40 million relays served daily.
Shannon—the current architecture—moves Pocket onto the Cosmos SDK, setting the stage for IBC interoperability and modular, DAO-governed upgrades. At the same time, it retools economics around verifiable work and transparent settlement.
Compute unit served daily on Pocket Network. Source: Poktscan
Why Pocket qualifies as DePIN for data
DePIN is about user-owned infrastructure doing real work. Pocket fits that frame at the data layer: the edge you control (your gateway URL) is cleanly separated from supply you don’t have to own (staked providers running nodes, indexers, or even model endpoints). Each request is measured as work and settled on-chain, so cost and reliability aren’t a promise from a vendor—they’re protocol behaviors you can inspect. In Shannon, usage burns POKT and issuance follows usage (mint = burn), shifting the system toward pay-for-work with auditable receipts.
The Roles and Flow
Shannon formalizes the roles so teams can specialize in a specific task. Here are the network actors under Shannon that anchor Pocket Network’s DePIN for data architecture:
- Permissionless Gateway–PATH (edge): a small server you run; it speaks to the protocol, enforces auth, does routing/caching, and exposes normal HTTP/JSON-RPC to your app. The PATH framework is the off-the-shelf way to run one. Under Shannon, teams can run their own gateway freely in a decentralized way.
- Supplier (provisioning): the operator running the actual data source—full/archive nodes, indexers, or even LLM endpoints / generic HTTP APIs—staked and rewarded per correct response.
- Source (builder): the team that creates/maintains the data service (e.g., a model endpoint or an indexer). Shannon introduces explicit incentives so sources themselves can participate economically, not just the hosts.
- Application: the consumer of data or consumer apps ingesting the network’s data. It originates requests, sets SLOs, and (in Shannon) stakes for usage, ensuring that traffic and costs are attributable to a specific app/account.
- Service: the published capability the network offers, for example, an Ethereum archive RPC, a REST indexer, or an LLM HTTP endpoint. It’s what apps target and gateways route to; it can be versioned and described independently of who runs it.
- RelayMiner: the attestation/settlement actor that turns usage into verifiable receipts and ties them to on-chain accounting so Suppliers are paid accurately and transparently.
The lifecycle:
Application → Gateway → Service → Supplier/Source → Assurance → RelayMiner → On-chain meter → Settlement
Pocket Network Data Plane Architecture
Pricing & accounting
Pocket Network prices by Compute Units (CUs), a standardized unit of work, so that builders can budget in dollars per work, not in token charts. Under Shannon, the average rate is 1 USD per 1B CUs paid in POKT token —the network’s native token, and the Foundation holds that peg to the dollar through the CUTTM (Compute Unit-to-Token Multiplier).
Settlement on Poket Network is simple; applications burn POKT for usage, and the protocol mints to pay supply, providing a burn-mint architecture that is DAO-programmable as usage grows. The framework makes Pocket Network’s data layer auditable, cost-for-work, and rewards-for-service at the protocol layer from end-to-end.
Scaling rewards with Rebates
To bootstrap demand without inflating supply, Pocket Network, under Shannon, introduced volume rebates for gateways. Daily throughput below 250B CUs earns no rebate; the rate then ramps linearly to 40% at 1.25T CUs/day. Rebates are funded from a capped quarterly budget (128T CUs) and distributed pro rata. This gives a predictable framework for finance teams and is meaningful at scale.
If you operate your own PATH gateway, you pay the published per-chain CU schedule directly and, once you cross the high-volume threshold, your effective $/M can drop substantially as rebates kick in.
Reliability by design
Pocket Network’s data plane has the most useful reliability features built in by default. Some of these include:
- Archival checks & quorums for deep-history reads (e.g., eth_getBalance at a historical block), so stale or incomplete endpoints can’t silently poison results.
- Opinionated error semantics so JSON-RPC errors map cleanly to HTTP, giving you consistent client behavior across suppliers.
Data you can serve on Pocket Network
Shannon widens the aperture of Pocket Network well beyond plain blockchain RPC. You can point a single gateway at multi-chain RPC across EVM and Cosmos families (with archive awareness where it matters), add general HTTP/public data as first-class lanes behind the same URL, and even register AI endpoints (e.g., LLM inference) so model calls are metered and settled like any other request.
A few quick, concrete, and real examples to help you understand better:
1) Multi-chain blockchain data (state & history)
Balances, nonces, contract reads, receipts, block headers, and true historical lookups when you need depth. Typical pulls: token transfer logs for analytics, cutoff-date balances for accounting, and so on.
Examples of Services include:
- Ethereum (eth),
- BNB Smart Chain (bsc),
- Polygon (poly),
- Base (base), and so on.
- Cosmos family, like Osmosis (osmosis), Celo (celo), etc.
2) Protocol & asset metadata
Structured reads that sit just above raw RPC, including token lists/metadata, NFT collection details, ABIs/schemas, and project/state summaries via indexers or chain modules.
Examples of Services (by network) include:
- Stargaze (stargaze) for NFT ecosystem data,
- Router Protocol (router) for cross-chain routing data,
- Bittensor (bittensor) for subnet/network state, and so on.
3) Market & reference datasets
Lightweight feeds your app consults constantly, such as prices/oracle readouts, gas estimates, network telemetry, bridge/rollup status, proof-of-reserves notes—small but essential feeds your app checks constantly.
Examples of Services are:
- Seda Protocol (seda) for oracle/market references; gas/telemetry via eth, base, op (e.g., gas price, pending count);
- status/metrics from networks like Hyperliquid (hyperliquid) and Akash (akash) when you need chain-native views.
4) AI Models & privacy-preserving endpoints
Model calls are first-class lanes, such as Chat/completions, embeddings, rerankers/classifiers, summarizers/extractors. Ideal for “natural-language over on-chain,” enrichment, or safety checks. Privacy-style queries are possible when you don’t want to reveal the exact needle.
Examples of Services in this category include:
- DeepSeek (deepseek),
- Qwen (qwen), and
- Task lanes such as text-to-image, image-to-text, and
- optical-character-recognition, etc.
The DePIN Data Plane Beyond Pocket Network
Zooming out, the lanes you just saw—access you control, supply as a market, lightweight assurance, and receipts—aren’t unique to one stack. They’re the same pattern emerging across DePIN: wireless turns coverage into addressable data, mapping turns contributor footage into tiles and embeddings, compute turns GPUs into model endpoints, and storage/indexing turns public state into queryable views.
The common pattern is simple. Keep an access point you own, compose Services behind it, let multiple suppliers compete on correctness and latency, and make every call verifiable. Because the edge is yours, you can swap or scale suppliers as markets shift—without touching client code.
Pocket Network is a clear implementation of that model at the access and settlement layers, but the point is bigger than one network. DePIN for data is a way of operating that makes pricing and reliability more than just promises, offering infrastructure you can inspect.
Closing Thoughts
A user-owned data plane is now practical. You can keep a single URL, route to plural suppliers, rely on built-in quality checks where it matters, and audit what you paid for—across chain state, structured protocol views, reference datasets, and model endpoints.
With the Shannon upgrade, those behaviors come packaged: price pegged to work, on-chain usage burns and supplier rewards, meaningful volume rebates, QoS by default, and roles clean enough for teams to specialize without duct tape. The result is a data layer you can actually ship—stable at the edge, diverse behind it, and measured end-to-end.
If you want the shortest path to “DePIN for data” without rewriting your app, run one gateway on Pocket Network, attach two services, and compare bills. If it helps, expand. If you operate infra, consider becoming a supplier and let demand route to you. Either way, you’re no longer betting on one provider’s roadmap; you’re participating in a market you can measure.