> ## Documentation Index
> Fetch the complete documentation index at: https://docs.livepeer.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Gateway Deployment Terms

> Terminology and concept definitions for Livepeer gateways - operational modes, setup types, node types, and key deployment terms.

export const LinkArrow = ({href, label, description, newline = true, borderColor, className = '', style = {}, ...rest}) => {
  const linkArrowStyle = {
    display: 'inline-flex',
    alignItems: 'center',
    justifyContent: 'center',
    gap: "var(--lp-spacing-1)",
    width: 'fit-content',
    ...borderColor && ({
      borderColor
    })
  };
  return <span className={className} style={style} {...rest}>
      {newline && <br />}
      <span style={linkArrowStyle}>
        <a href={href} target="_blank" rel="noopener noreferrer">
          {label}
        </a>
        <Icon icon="arrow-up-right" size={14} color="var(--lp-color-accent)" />
      </span>
      {description && description}
      {description && <div style={{
    height: "var(--lp-spacing-3)"
  }} />}
    </span>;
};

export const CustomDivider = ({color = "var(--lp-color-border-default)", middleText = "", spacing = "default", style = {}, className = "", ...rest}) => {
  const spacingPresets = {
    default: {
      margin: "24px 0"
    },
    overlap: {
      margin: "-1rem 0 -1rem 0"
    },
    tight: {
      margin: "0 0 -1rem 0"
    },
    section: {
      margin: "0 0 -2rem 0"
    },
    sectionOverlap: {
      margin: "-1rem 0 -2rem 0"
    },
    deepOverlap: {
      margin: "-1rem 0 -1.5rem 0"
    }
  };
  const spacingStyle = spacingPresets[spacing] || spacingPresets.default;
  return <div role="separator" aria-orientation="horizontal" className={className} style={{
    display: "flex",
    alignItems: "center",
    ...spacingStyle,
    fontSize: style?.fontSize || "16px",
    height: "fit-content",
    ...style
  }} {...rest}>
      <span style={{
    marginRight: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
      </span>
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      {middleText && <>
          <Icon icon="circle" size={2} />
          <span style={{
    margin: "0 8px",
    fontWeight: "bold",
    color: color,
    opacity: 0.7
  }}>
            {middleText}
          </span>
          <Icon icon="circle" size={2} />
        </>}
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      <span style={{
    marginLeft: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <span style={{
    display: "inline-block",
    transform: "scaleX(-1)"
  }}>
          <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
        </span>
      </span>
    </div>;
};

export const TableCell = ({children, align = "left", header = false, style = {}, className = "", ...rest}) => {
  const Component = header ? "th" : "td";
  return <Component className={className} style={{
    padding: "0.75rem 1rem",
    textAlign: align,
    border: header ? "none" : "1px solid var(--lp-color-border-default)",
    ...style
  }} {...rest}>
      {children}
    </Component>;
};

export const TableRow = ({children, header = false, hover = false, style = {}, className = "", ...rest}) => {
  const rowId = `table-row-${Math.random().toString(36).substr(2, 9)}`;
  return <>
      {hover && <style>{`
          #${rowId}:hover {
            background-color: var(--lp-color-bg-card);
          }
        `}</style>}
      <tr id={rowId} className={className} style={{
    ...header && ({
      backgroundColor: "var(--lp-color-accent-strong)",
      color: "var(--lp-color-on-accent)",
      fontWeight: "bold"
    }),
    ...style
  }} {...rest}>
        {children}
      </tr>
    </>;
};

export const StyledTable = ({children, variant = "default", style = {}, className = "", ...rest}) => {
  const wrapperVariants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)",
      overflow: "hidden"
    },
    bordered: {
      border: "2px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-page)",
      overflow: "hidden"
    },
    minimal: {
      border: "none",
      backgroundColor: "transparent",
      overflow: "visible"
    }
  };
  return <div data-docs-styled-table-shell className={className} style={{
    width: "100%",
    padding: 0,
    margin: 0,
    ...wrapperVariants[variant],
    ...style
  }} {...rest}>
      <table data-docs-styled-table style={{
    width: "100%",
    borderCollapse: "collapse",
    borderSpacing: 0,
    margin: 0,
    backgroundColor: "transparent"
  }}>
        {children}
      </table>
    </div>;
};

## Deployment

A **deployment** is the complete configuration of a Livepeer Gateway, defined by three independent choices: operational mode, setup type, and node type. These axes are orthogonal - each can be selected independently of the others.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Axis</TableCell>
      <TableCell header>Options</TableCell>
      <TableCell header>What it decides</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Operational mode**</TableCell>
      <TableCell>On-chain / Off-chain</TableCell>
      <TableCell>How your Gateway integrates with the Livepeer Protocol - blockchain interaction, Orchestrator discovery, payment settlement, ETH management</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Setup type**</TableCell>
      <TableCell>go-livepeer / SDK / GWID / Hosted</TableCell>
      <TableCell>What software you run and how you install it</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Node type**</TableCell>
      <TableCell>Video / AI / Dual</TableCell>
      <TableCell>What workloads your Gateway routes</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider style={{margin: "-1rem 0 -1rem 0"}} />

## Operational Mode

The operational mode determines how your Gateway connects to the Livepeer Network and settles payments with Orchestrators. This is a product decision that affects your entire operational model.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header />

      <TableCell header><Icon icon="cloud" size={14} /> Off-chain</TableCell>
      <TableCell header><Icon icon="link" size={14} /> On-chain</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Protocol integration**</TableCell>
      <TableCell>None - no blockchain interaction at the Gateway</TableCell>
      <TableCell>Connects to the Livepeer Protocol on Arbitrum</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Orchestrator discovery**</TableCell>
      <TableCell>Manual - you specify Orchestrator addresses (`-orchAddr`)</TableCell>
      <TableCell>Automatic - protocol discovers registered Orchestrators</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Payment settlement**</TableCell>
      <TableCell>Remote signer handles all payment operations</TableCell>
      <TableCell>Gateway manages its own Ethereum wallet and Probabilistic Micropayments</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**ETH required**</TableCell>
      <TableCell>No - community signer is free</TableCell>
      <TableCell>Yes - deposit + reserve on Arbitrum</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Crypto knowledge**</TableCell>
      <TableCell>None at the Gateway layer</TableCell>
      <TableCell>Wallet, keystore, Arbitrum RPC, bridging</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<Note>
  Operational mode is independent of node type. Both on-chain and off-chain Gateways can route <Badge color="blue">Video</Badge>, <Badge color="purple">AI</Badge>, or <Badge color="green">Dual</Badge> workloads.
</Note>

<CustomDivider style={{margin: "-1rem 0 -1rem 0"}} />

## Setup Type

The setup type determines what software you run and how you install it.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Setup type</TableCell>
      <TableCell header>Description</TableCell>
      <TableCell header>Operational modes</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**go-livepeer**</TableCell>
      <TableCell>The standard Livepeer Gateway binary. Install via Docker (recommended) or build from source. Supports all node types and both operational modes.</TableCell>
      <TableCell>On-chain, Off-chain</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**SDK / Custom**</TableCell>
      <TableCell>Build a Gateway client in Python, browser, mobile, or embedded systems using the remote signer architecture. No Go binary required.</TableCell>
      <TableCell>Off-chain only</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**GWID**</TableCell>
      <TableCell>Gateway Wizard - a managed DevOps platform for single-click Livepeer Gateway deployment. Community project, not maintained by Livepeer.</TableCell>
      <TableCell>On-chain, Off-chain</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Hosted**</TableCell>
      <TableCell>Use an existing Gateway operator (Livepeer Studio, Livepeer Cloud, Daydream) instead of running your own. You pay their service rate.</TableCell>
      <TableCell>Managed by provider</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider style={{margin: "-1rem 0 -1rem 0"}} />

## Node Type

The node type determines what workloads your Gateway routes to Orchestrators.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Node type</TableCell>
      <TableCell header>Workloads</TableCell>
      <TableCell header>OS support</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell><Badge color="blue">Video</Badge></TableCell>
      <TableCell>RTMP transcoding to HLS. Replaces cloud transcoding services (Mux, AWS MediaLive, Wowza).</TableCell>
      <TableCell>Linux, Windows (WSL2/Docker)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell><Badge color="purple">AI</Badge></TableCell>
      <TableCell>Inference routing - text-to-image, image-to-video, LLM, audio-to-text, live-video-to-video, and more.</TableCell>
      <TableCell>Linux</TableCell>
    </TableRow>

    <TableRow>
      <TableCell><Badge color="green">Dual</Badge></TableCell>
      <TableCell>Both video transcoding and AI inference on a single Gateway node.</TableCell>
      <TableCell>Linux only (AI component requires Linux)</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider style={{margin: "-1rem 0 -1rem 0"}} />

## Key Terms

<AccordionGroup>
  <Accordion title="Deployment" icon="layer-group">
    The holistic configuration of a Livepeer Gateway. A deployment is defined by three independent choices: **operational mode** (on-chain or off-chain), **setup type** (go-livepeer, SDK, GWID, or hosted), and **node type** (Video, AI, or Dual). For example, "an off-chain go-livepeer AI Gateway" describes a single deployment across all three axes.
  </Accordion>

  <Accordion title="Gateway" icon="server">
    The routing layer between applications and the Livepeer Orchestrator network. A Gateway receives requests (video streams, AI inference jobs), selects Orchestrators, routes the work, and returns results. A Gateway does not perform compute - it routes to Orchestrators that do. No GPU is required.
  </Accordion>

  <Accordion title="Orchestrator" icon="microchip">
    A node that performs compute work on the Livepeer Network - video transcoding, AI inference, or both. Orchestrators register on the Livepeer Protocol, advertise their capabilities and pricing, and receive work from Gateways.
  </Accordion>

  <Accordion title="Remote signer" icon="key">
    A separate service that holds an Ethereum key and signs payment tickets on behalf of an off-chain Gateway. The Gateway itself holds no ETH. A community-hosted remote signer at `signer.eliteencoder.net` is publicly available and free to use.
  </Accordion>

  <Accordion title="Probabilistic micropayments (PM)" icon="ticket">
    The payment mechanism used by the Livepeer Protocol. Instead of paying for every job individually, Gateways send lottery tickets to Orchestrators. Over time, the expected value of winning tickets equals the fair payment. This reduces on-chain transaction costs.
  </Accordion>

  <Accordion title="NaaP (Network as a Platform)" icon="users">
    A reference implementation for multi-tenant Gateway operation. Provides JWT-based authentication, developer API keys, and per-user usage tracking on top of a Livepeer Gateway. Repository: [github.com/Livepeer/naap](https://github.com/livepeer/naap).
  </Accordion>

  <Accordion title="SPE (Special Purpose Entity)" icon="building">
    An organisation funded by the Livepeer treasury through a governance proposal. SPEs have defined mandates, budgets, and milestone accountability. Multiple Gateway operators (Livepeer Cloud SPE, LLM SPE) are funded through this model.
  </Accordion>

  <Accordion title="Broadcaster (deprecated term)" icon="circle-exclamation">
    The pre-2023 name for a Gateway. Older community guides and documentation may reference `-broadcaster=true` - this flag has been replaced by `-gateway`. The terms are functionally equivalent.
  </Accordion>
</AccordionGroup>

## Payment Clearinghouse

A Payment Clearinghouse is an abstraction implementation of a <LinkArrow href="/v2/gateways/guides/payments-and-pricing/remote-signers" label="remote signer" newline={false} /> with additional commercial services including:

* Multi-user support,
* API key authentication,
* Usage accounting, and
* Billing in fiat, stablecoins, or credits.

<CustomDivider style={{margin: "-1rem 0 -1rem 0"}} />

## Operational Mode Asymmetry: Gateways vs Orchestrators

Gateways and Orchestrators share go-livepeer but differ fundamentally in how operational modes apply:

* **Gateways have a genuine on-chain/off-chain fork.** Off-chain Gateways use a remote signer for payment operations and are a sustainable production configuration. On-chain Gateways manage their own wallet. This fork affects the entire setup, payment, and monitoring journey.
* **Orchestrators do not have this fork.** Off-chain Orchestrators (`-network offchain`) cannot be discovered by the protocol, cannot earn inflation rewards, and cannot join the Active Set. Off-chain is a testing/development configuration for Orchestrators, not a production choice. Orchestrator documentation treats on-chain as the default.

This asymmetry is why the Gateway documentation requires on-chain/off-chain branching throughout while the Orchestrator documentation does not.