Pixelmine
Network Incentives

Why anyone runs a node.

Pixelmine’s storage is not rented from a data centre — it is contributed by people who choose to run a node. A network like that only holds together if contributing is genuinely worth it, so work is measured, proven, and rewarded. Crucially, it rewards work that can be checked, not work that is merely claimed.

Last updated · 30 July 2026

Four ways a node earns

Paid for the work
the network needs.

Each category rewards something the network actually depends on: serving data to others, holding files, staying reachable, and doing it well. Nothing rewards simply existing.

Serving others

Earned when another node pulls data from you — the act of genuinely serving the network rather than just sitting on a copy of it.

5 points per sync

Storing files

Earned when a file is really stored on your node. Only genuine uploads count — not database writes, not sync traffic — and the true size in bytes is recorded alongside it.

1 point per upload

Staying online

Earned passively for being reachable. A node checks in roughly every ten minutes, around 144 times a day, from the moment it boots.

1 point per check-in

Doing it well

Earned for syncs that actually succeed, and how quickly they finish. Being available is not the same as being useful, so quality is counted separately.

Per successful sync
How a score adds up

Four numbers,
one score.

A node’s standing is not a vague reputation anyone argues about. It is the plain sum of four counts, each traceable to events that actually happened: how much you served, how much you stored, how reliably you were there, and how well it went.

  • Serving is worth the most per event, because it is the thing the network most needs from you.
  • Storage records the real number of bytes alongside the count, so a thousand tiny files is not the same as a thousand real ones.
  • Quality is measured, not assumed: how many syncs succeeded out of how many were attempted, and how long they took.
How a point is awarded

It takes two nodes
to make a point.

The obvious way to cheat a system like this is to claim work you never did. So the most valuable points cannot be claimed alone: both nodes involved have to sign the same story before anything is recorded.

Node A asks Node B to sync Node B pulls the data Both nodes sign what happened Both signatures valid? NONo point awarded YES Giver = receiver? YESRejected: no self-credit NO 5 points recorded to Node A
Awarding a point for serving data
Proven, not claimed

Why a node can’t
simply invent its score.

Every protection here exists because someone would otherwise try the shortcut. Together they mean a node’s score reflects work the network can independently confirm.

  • Every report a node makes is signed with a key only that node holds, so nobody can report on another’s behalf or pose as a node they do not run.
  • Points for serving data need two signatures — from the node that asked and the node that delivered. You cannot invent a sync that never happened, because you would need someone else’s key to corroborate it.
  • A node cannot credit itself: a report where the giver and the receiver are the same node is thrown out.
  • Every signed report carries the time it happened, so an old one cannot be replayed again and again for repeat credit.
  • A node that never registered has no key on file, so its reports verify against nothing and are simply refused.
  • Tallies are kept away from the node itself. An operator with full control of their own machine still cannot quietly edit their own score.
Getting counted

How a node starts
earning at all.

Nothing is earned anonymously. Before a node can be credited for anything, the network has to know which key its claims will be checked against.

  • On startup a node introduces itself with its name, description, and public key. That key is what every later report it makes will be measured against.
  • Restarting does not spawn a second identity. Re-introducing itself simply refreshes the node’s details rather than creating a duplicate.
  • A node that never registered has no key on file, so its reports verify against nothing and earn nothing at all.
Open to inspection

A score you can look up,
not just take on trust.

Contribution only means something if anyone can check it. So a node’s record is not a private boast — it is readable, itemised, and comparable against every other node.

  • Any node’s full breakdown can be looked up: what it served, what it stored, how often it checked in, and how many of its syncs actually succeeded.
  • Quality goes further than a tally — it records the success rate out of everything attempted, and the average time those syncs took.
  • The network’s own totals are open too: how many nodes exist, and what they have contributed between them.
  • Nodes can be ranked by contribution, so the ones genuinely carrying the network are visible rather than anonymous.
Where it’s weaker

What the system
doesn’t claim to solve.

The design is candid about its own edges, which is worth considerably more than pretending they aren’t there.

  • Serving and quality need two signatures, so they cannot be faked alone. Storage and check-ins are signed by a single node — enough to stop impersonation, but there a node is still attesting to its own work.
  • That is a deliberate trade rather than an oversight: the categories worth cheating hardest are the ones made unfakeable, while the cheaper ones stay cheap to report.
  • The tally is kept away from the node on purpose, so an operator cannot rewrite their own score. The cost is that scoring leans on that one service — even though the storage network itself does not.
How points are distributed

From work, to points,
to money.

Points travel along a chain. A node earns them for work the network can actually verify, passes a share of them on to the people in its community, and those points can eventually be exchanged for money — which Pixelmine pays out.

STEP 01

The node earns

A node collects points for work the network checks: serving data to others, storing files, staying reachable, and doing it well.

STEP 02

The node shares

It passes a share of what it earned on to the people in its community. How large that share is, is entirely the node’s own call.

STEP 03

Points accumulate

Those points build up against a member’s identity, held as a balance rather than paid out a fraction at a time.

STEP 04

Points become money

Once the balance passes a set threshold, points can be exchanged for money — and it is Pixelmine that pays it.

verified work → node earns points → shared with the community → member balance → exchanged for money
  • The share is the pivot of the whole thing: it decides how much of what a node earns stays with the operator carrying the costs, and how much reaches the people in the community. Because that choice is public and each node makes it alone, how generous a community is becomes something people can weigh when deciding where to spend their time.
  • How much to share is left to each node’s discretion. Two communities on the same network can make very different choices — one generous, one not — and nobody at the centre overrides either.
  • The threshold means exchanges happen in meaningful amounts rather than an endless trickle of tiny payouts.
  • Pixelmine stands behind the exchange itself. An operator never has to fund payouts out of their own pocket — the company converts accumulated points into money.
  • Because the network records what each node earned, and each settlement is signed, the chain from work done to points paid can be checked rather than simply believed.
The revenue split

Following the money
through two splits.

The whole model is really two divisions and a choice, once Pixelmine has covered what it costs to run the platform. The revenue left after those expenses is shared out across nodes by the points they earned; each node then decides how much of its slice reaches the people in its community. Here it is with round numbers.

  • First, across the network. Pixelmine first sets aside what it costs to run the platform; the revenue that remains for the period is then divided among nodes in proportion to the points each one earned. A node holding a fifth of the network’s points receives a fifth of that shared pool.
  • Then, inside the community. The node decides what portion of its slice is passed on. That figure is nobody’s decision but its own.
  • Finally, among members. The members’ pool is divided between them according to the points they each earned in that community.
  • Earn more points as a node and your slice of the same revenue grows. Earn the same while the network grows around you, and it shrinks — a share is always relative to everyone else’s.
node’s slice  =  node points ÷ all network points × net revenue
members’ pool  =  node’s slice × the share the node chose

* Only a sample computation — a node’s slice, and what stays with the operator, vary with the points the node earns.

Both panels are a sample computation to illustrate how the split works — not actual figures. The first sets running costs aside before the ¥5,000,000 is shared across the network.

The community’s share

Each community decides
what it gives back.

A node does not have to keep everything it earns. How much of it reaches the people in the community is the node’s own decision — as is the threshold before those points can be exchanged. No share is imposed from the centre, and no node is obliged to match another.

Which is the point: an incentive that one authority can quietly change for everyone is not really the community’s at all.

In short

A network that pays
for what it needs.

Storage, bandwidth, and uptime are real costs. Pixelmine meets them by sharing its revenue — after covering what it costs to run the platform — with the people who supply them, passing a share on to the communities they host, and standing behind the exchange at the end, while making sure those rewards can only ever be earned, never simply asserted.

Back to design Back to overview