> ## Documentation Index
> Fetch the complete documentation index at: https://companyname-a7d5b98e-docs-what-is-a-node.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# What is a node?

> Overview of TON nodes, validator roles, and how apps connect to the network.

export const Image = ({src, darkSrc, alt = '', darkAlt, href, target, height = 342, width = 608, noZoom = false, center = false}) => {
  const isSVG = src.match(/\.svg(?:[#?].*?)?$/i) !== null;
  const shouldInvert = isSVG && !darkSrc;
  const shouldCreateLink = href !== undefined;
  const minPx = 9;
  const maxPx = 608;
  const expectedPx = `a number or a string with a number that is greater than ${minPx - 1} and less than or equal to ${maxPx}`;
  const createInvalidPropCallout = (title, received, expected) => {
    return <Danger>
        <span className="font-bold">
          Invalid <code>{title.toString()}</code> passed!
        </span>
        <br />
        <span className="font-bold">Received: </span>
        {received.toString()}
        <br />
        <span className="font-bold">Expected: </span>
        {expected.toString()}
        {}
      </Danger>;
  };
  const checkValidDimensionValue = value => {
    switch (typeof value) {
      case "string":
      case "number":
        const num = Number(value);
        return Number.isSafeInteger(num) && num >= minPx && num <= maxPx;
      default:
        return false;
    }
  };
  let callouts = [];
  if (height && !checkValidDimensionValue(height)) {
    callouts.push(createInvalidPropCallout("height", height, expectedPx));
  }
  if (width && !checkValidDimensionValue(width)) {
    callouts.push(createInvalidPropCallout("width", width, expectedPx));
  }
  if (callouts.length !== 0) {
    return callouts;
  }
  const heightPx = Number(height);
  const widthPx = Number(width);
  const shouldCenter = center === "true" || center === true ? true : false;
  const shouldNotZoom = noZoom === "true" || noZoom === true ? true : false;
  const images = <>
      <img className="block dark:hidden" src={src} alt={alt} {...height && ({
    height: heightPx
  })} {...width && ({
    width: widthPx
  })} {...(shouldCreateLink || shouldInvert || shouldNotZoom) && ({
    noZoom: "true"
  })} />
      <img className={`hidden dark:block ${shouldInvert ? "invert" : ""}`} src={darkSrc ?? src} alt={darkAlt ?? alt} {...height && ({
    height: heightPx
  })} {...width && ({
    width: widthPx
  })} {...(shouldCreateLink || shouldInvert || shouldNotZoom) && ({
    noZoom: "true"
  })} />
    </>;
  if (shouldCreateLink) {
    if (shouldCenter) {
      return <div style={{
        display: "flex",
        justifyContent: "center"
      }}>
          <a href={href} target={target ?? "_self"}>
            {images}
          </a>
        </div>;
    }
    return <a href={href} target={target ?? "_self"}>
        {images}
      </a>;
  }
  if (shouldCenter) {
    return <div style={{
      display: "flex",
      justifyContent: "center"
    }}>{images}</div>;
  }
  return images;
};

A node is a server running TON blockchain software. It stores the chain state, verifies blocks and transactions, and propagates new data to other nodes and clients.

This matters when deciding whether to rely on a public API or run infrastructure, and when tracing how a wallet action becomes an on-chain transaction.

## What a node does

A *full node* keeps the latest blockchain state and relays blocks and messages across the peer-to-peer network. A *validator* is a full node that participates in consensus and produces blocks. Many full nodes also expose a *liteserver* endpoint so wallets and apps can query data or submit messages without running a full node themselves.

TON also has *lite clients*. They do not store chain state locally. Instead, they request the data they need from liteserver-enabled full nodes.

## Node types and roles

* **Full node** — stores the latest state and propagates blocks and messages. See [Node roles and modes](/ecosystem/node/overview).
* **Archive node** — a full node that keeps the entire history for analytics and explorers. See [Node roles and modes](/ecosystem/node/overview).
* **Validator node** — produces blocks and participates in consensus. See [Running a validator](/ecosystem/node/run-validator).
* **Liteserver** — a mode that exposes a gateway for lite clients and APIs. See [Interacting with TON nodes](/ecosystem/node/overview#interacting-with-ton-nodes).

## Who runs nodes

* **Validators** — stake Toncoin, participate in consensus, and produce blocks.
* **Infrastructure providers** — run full nodes and liteservers to back APIs.
* **Explorers and indexers** — run archive nodes to serve historical data.
* **Community operators** — add connectivity and redundancy to the network.

## How apps reach the network

Wallets and dApps act as lite clients: they do not keep chain state locally and instead connect to an [API provider](/ecosystem/api/overview) or a liteserver gateway. The gateway forwards requests to full nodes. Validators are the subset of nodes that finalize new blocks, and the results propagate back through the network.

<Image src="/resources/images/nodes/node-flow.svg" alt="Flow from a user wallet or dApp through an API or liteserver gateway to TON full nodes and validators." />

## Run a node

Use public APIs for prototypes and light workloads. Full nodes typically back apps that require stricter uptime targets or direct access to the network.

* [Set up a node with MyTonCtrl](/ecosystem/node/setup-mytonctrl)
* [Set up a local network with MyLocalTon](/ecosystem/node/setup-mylocalton)

## See also

* [Node roles and modes](/ecosystem/node/overview)
* [Running a validator](/ecosystem/node/run-validator)
* [Liteserver mode](/ecosystem/node/overview#interacting-with-ton-nodes)