> ## 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 Glossary

> Key terms for Livepeer gateway operators - deployment modes, payment mechanics, orchestrator routing, and node configuration.

export const LinkIcon = ({href, target = '_blank', rel = 'noopener noreferrer', style = {}, className = '', icon = 'arrow-up-right-from-square', size = 12, ...iconProps}) => {
  return <a href={href} target={target} rel={rel} className={className} style={{
    borderBottom: 'none',
    textDecoration: 'none',
    ...style
  }}>
      <Icon icon={icon} size={size} {...iconProps} />
    </a>;
};

export const CopyText = ({text, label, className = '', style = {}, ...rest}) => {
  const handleCopy = () => {
    navigator.clipboard.writeText(text);
  };
  return <span className={className} style={{
    display: 'flex',
    alignItems: 'center',
    padding: '0.2rem 0.4rem',
    borderRadius: "4px",
    fontSize: '0.85rem',
    fontFamily: 'monospace',
    backgroundColor: 'var(--lp-color-bg-card)',
    border: '1px solid var(--lp-color-border-default)',
    minWidth: 0,
    overflow: 'hidden',
    ...style
  }} {...rest}>
      {label && <strong style={{
    flexShrink: 0,
    marginRight: "var(--lp-spacing-2)"
  }}>{label}</strong>}
      <span style={{
    overflow: 'hidden',
    textOverflow: 'ellipsis',
    whiteSpace: 'nowrap',
    flex: 1,
    minWidth: 0
  }}>
        {text}
      </span>
      <button onClick={handleCopy} style={{
    background: 'none',
    border: 'none',
    cursor: 'pointer',
    padding: '0 0 0 0.4rem',
    display: 'inline-flex',
    alignItems: 'center',
    color: 'var(--lp-color-text-secondary)',
    flexShrink: 0
  }} title="Copy to clipboard">
        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
          <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
          <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
        </svg>
      </button>
    </span>;
};

export const glossaryBadges = [{
  color: 'blue',
  label: 'Video'
}, {
  color: 'purple',
  label: 'AI'
}, {
  color: 'green',
  label: 'Livepeer'
}, {
  color: 'yellow',
  label: 'Technical'
}];

export const LazyLoad = ({children, height = "200px", offset = "200px", fadeDuration = 400, className = "", style = {}, ...rest}) => {
  const ref = useRef(null);
  const [visible, setVisible] = useState(false);
  const [ready, setReady] = useState(false);
  useEffect(() => {
    const el = ref.current;
    if (!el) return;
    const observer = new IntersectionObserver(([entry]) => {
      if (entry.isIntersecting) {
        setVisible(true);
        observer.disconnect();
      }
    }, {
      rootMargin: offset
    });
    observer.observe(el);
    return () => observer.disconnect();
  }, []);
  useEffect(() => {
    if (!visible) return;
    const frameId = requestAnimationFrame(() => {
      setReady(true);
    });
    return () => cancelAnimationFrame(frameId);
  }, [visible]);
  const placeholder = <div ref={ref} className={className} style={{
    minHeight: height,
    ...style
  }} {...rest} />;
  if (!visible) return placeholder;
  return <div ref={ref} className={className} style={{
    opacity: ready ? 1 : 0,
    transition: `opacity ${fadeDuration}ms ease-in`,
    ...style
  }} {...rest}>
      {children}
    </div>;
};

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 DynamicTable = ({tableTitle = null, headerList = [], itemsList = [], monospaceColumns = [], columnWidths = {}, contentFitColumns = [], showSeparators = false, margin, className = "", style = {}, ...rest}) => {
  if (!headerList.length) {
    return <div>No headers provided</div>;
  }
  const safeContentFitColumns = Array.isArray(contentFitColumns) ? contentFitColumns : [];
  const usesContentFitColumns = safeContentFitColumns.length > 0;
  const isContentFitColumn = header => safeContentFitColumns.includes(header);
  const getColumnStyle = header => {
    const widthStyle = columnWidths[header] ? {
      width: columnWidths[header],
      minWidth: columnWidths[header],
      maxWidth: columnWidths[header]
    } : {};
    const contentFitStyle = !columnWidths[header] && isContentFitColumn(header) ? {
      width: "1%",
      whiteSpace: "nowrap"
    } : {};
    return {
      ...contentFitStyle,
      ...widthStyle
    };
  };
  return <div className={className} style={style} {...rest}>
      {tableTitle && <div style={{
    fontStyle: "italic",
    margin: 0
  }}>
          <strong>{tableTitle}</strong>
        </div>}
      <div style={{
    overflowX: "auto",
    ...margin != null && ({
      margin
    })
  }} role="region" tabIndex={0} aria-label={tableTitle ? `Scrollable table: ${tableTitle}` : "Scrollable table"}>
        <table data-docs-dynamic-table style={{
    width: "100%",
    tableLayout: usesContentFitColumns ? "auto" : "fixed",
    borderCollapse: "collapse",
    fontSize: "0.9rem",
    marginTop: 0
  }}>
          <thead>
            <tr style={{
    backgroundColor: "var(--lp-color-accent)",
    color: "var(--lp-color-on-accent)",
    borderBottom: "1px solid var(--lp-color-border-default)"
  }}>
              {headerList.map((header, index) => <th key={index} style={{
    padding: "10px 8px",
    textAlign: "left",
    fontWeight: "600",
    color: "var(--lp-color-on-accent)",
    ...getColumnStyle(header)
  }}>
                  {header}
                </th>)}
            </tr>
          </thead>
          <tbody>
            {itemsList.filter(item => showSeparators || !item?.__separator).map((item, rowIndex) => item?.__separator ? <tr key={rowIndex} style={{
    backgroundColor: "var(--lp-color-accent)",
    color: "var(--lp-color-on-accent)",
    borderBottom: "1px solid var(--lp-color-accent)"
  }}>
                  <td colSpan={headerList.length} style={{
    padding: "6px 8px",
    fontWeight: "700",
    color: "var(--lp-color-on-accent)",
    letterSpacing: "0.01em"
  }}>
                    {(item[headerList[0]] ?? item.Category) ?? "Category"}
                  </td>
                </tr> : <tr key={rowIndex} style={{
    borderBottom: "1px solid var(--lp-color-border-default)"
  }}>
                  {headerList.map((header, colIndex) => {
    const value = (item[header] ?? item[header.toLowerCase()]) ?? "-";
    const isMonospace = monospaceColumns.includes(colIndex);
    return <td key={colIndex} style={{
      padding: "8px 8px",
      fontFamily: isMonospace ? "monospace" : "inherit",
      wordWrap: "break-word",
      overflowWrap: "break-word",
      ...getColumnStyle(header)
    }}>
                        {isMonospace ? <code>{value}</code> : value}
                      </td>;
  })}
                </tr>)}
          </tbody>
        </table>
      </div>
    </div>;
};

export const SearchTable = ({TableComponent = null, tableTitle = null, headerList = [], itemsList = [], monospaceColumns = [], margin, searchPlaceholder = 'Search...', searchColumns = [], categoryColumn = 'Category', filterColumns = [], columnWidths = {}, contentFitColumns = [], columnVariant = {}, categoryBadges = [], textIcons = [], showSeparators = false, separatorColumn = null, boldFirstColumn = true, className = '', style = {}}) => {
  const allFilterCols = [categoryColumn, ...filterColumns];
  const [query, setQuery] = useState('');
  const [selections, setSelections] = useState(() => {
    const init = {};
    allFilterCols.forEach(col => {
      init[col] = 'All';
    });
    return init;
  });
  const safeHeaderList = Array.isArray(headerList) ? headerList : [];
  const safeItemsList = Array.isArray(itemsList) ? itemsList : [];
  const safeMonospaceColumns = Array.isArray(monospaceColumns) ? monospaceColumns : [];
  const safeSearchColumns = Array.isArray(searchColumns) ? searchColumns : [];
  const activeColumns = safeSearchColumns.length ? safeSearchColumns : safeHeaderList;
  const normalizedQuery = query.trim().toLowerCase();
  const badgeColorMap = {};
  categoryBadges.forEach(b => {
    badgeColorMap[b.label.toLowerCase()] = b.color;
  });
  const textIconMap = {};
  textIcons.forEach(t => {
    textIconMap[t.label.toLowerCase()] = t.icon;
  });
  const getOptionsForColumn = (colName, colIndex) => {
    let scoped = safeItemsList;
    for (let i = 0; i < colIndex; i++) {
      const prevCol = allFilterCols[i];
      const prevSel = selections[prevCol];
      if (prevSel !== 'All') {
        scoped = scoped.filter(item => String(item?.[prevCol] || '') === prevSel);
      }
    }
    return [...new Set(scoped.map(item => String(item?.[colName] || '')).filter(Boolean))].sort((a, b) => a.localeCompare(b, 'en', {
      sensitivity: 'base'
    }));
  };
  const filteredItems = safeItemsList.filter(item => allFilterCols.every(col => {
    const sel = selections[col];
    return sel === 'All' || String(item?.[col] || '') === sel;
  }));
  const searchedItems = !normalizedQuery ? filteredItems : filteredItems.filter(item => activeColumns.some(column => {
    const value = (item?.[column] ?? item?.[String(column).toLowerCase()]) ?? '';
    return String(value).toLowerCase().includes(normalizedQuery);
  }));
  const sortedItems = [...searchedItems].sort((a, b) => {
    for (const col of allFilterCols) {
      const cmp = String(a[col] || '').localeCompare(String(b[col] || ''), 'en', {
        sensitivity: 'base'
      });
      if (cmp !== 0) return cmp;
    }
    return 0;
  });
  const firstColumnName = safeHeaderList[0];
  const renderVariant = (value, variant, item, header) => {
    if (variant === 'bold' && typeof value === 'string') {
      return <strong>{value}</strong>;
    }
    if (variant === 'badge' && typeof value === 'string') {
      const colorName = badgeColorMap[value.toLowerCase()];
      if (colorName) {
        return <Badge color={colorName}>{value}</Badge>;
      }
    }
    if (variant === 'textIcon' && typeof value === 'string') {
      const icon = textIconMap[value.toLowerCase()];
      if (icon) {
        return <span style={{
          display: 'inline-flex',
          alignItems: 'center',
          gap: '0.35rem'
        }}>
            {icon} {value}
          </span>;
      }
    }
    if (variant === 'addressWrapper' && typeof value === 'string') {
      const href = item?.[`_${header}Href`] ?? item?._addressHref;
      return <div style={{
        display: 'flex',
        alignItems: 'center',
        gap: '0.35rem',
        width: '100%',
        minWidth: 0
      }}>
          <CopyText text={value} style={{
        flex: 1
      }} />
          {href && <LinkIcon href={href} color="var(--lp-color-accent)" />}
        </div>;
    }
    return value;
  };
  const displayItems = sortedItems.map(item => {
    const out = {
      ...item,
      _sepKey: String(item[separatorColumn || categoryColumn] || '')
    };
    for (const header of safeHeaderList) {
      if (columnVariant[header] && out[header] !== undefined) {
        out[header] = renderVariant(out[header], columnVariant[header], item, header);
      }
    }
    if (boldFirstColumn && firstColumnName && !columnVariant[firstColumnName] && typeof out[firstColumnName] === 'string') {
      out[firstColumnName] = <strong>{out[firstColumnName]}</strong>;
    }
    return out;
  });
  const withSeparators = [];
  let lastSep = '';
  displayItems.forEach(item => {
    const sepKey = item._sepKey || '';
    if (showSeparators && sepKey && sepKey !== lastSep) {
      withSeparators.push({
        __separator: true,
        [safeHeaderList[0]]: sepKey.toUpperCase()
      });
      lastSep = sepKey;
    }
    withSeparators.push(item);
  });
  const selectStyle = {
    minWidth: '150px',
    padding: '8px 12px',
    borderRadius: '8px',
    border: '1px solid var(--lp-color-border-default)',
    background: 'var(--lp-color-bg-page)',
    color: 'var(--lp-color-text-secondary)'
  };
  const updateSelection = (col, colIndex, value) => {
    const next = {
      ...selections,
      [col]: value
    };
    for (let i = colIndex + 1; i < allFilterCols.length; i++) {
      next[allFilterCols[i]] = 'All';
    }
    setSelections(next);
  };
  return <div className={className} style={style}>
      <div style={{
    marginBottom: "var(--lp-spacing-2)",
    display: 'flex',
    flexWrap: 'wrap',
    gap: "var(--lp-spacing-2)",
    alignItems: 'center'
  }}>
        <input type="text" value={query} placeholder={searchPlaceholder} onChange={e => setQuery(e.target.value)} aria-label="Filter table rows" style={{
    width: '100%',
    maxWidth: '420px',
    padding: '8px 12px',
    borderRadius: '8px',
    border: '1px solid var(--lp-color-border-default)',
    background: 'var(--lp-color-bg-page)',
    color: 'var(--lp-color-text-secondary)'
  }} />
        {allFilterCols.map((col, colIndex) => {
    const options = getOptionsForColumn(col, colIndex);
    if (options.length === 0) return null;
    const parentLabel = colIndex > 0 && selections[allFilterCols[colIndex - 1]] !== 'All' ? selections[allFilterCols[colIndex - 1]] : col.toLowerCase() + 's';
    return <select key={col} value={selections[col]} onChange={e => updateSelection(col, colIndex, e.target.value)} aria-label={`Filter by ${col}`} style={selectStyle}>
              <option value="All">All {parentLabel}</option>
              {options.map(o => <option key={o} value={o}>
                  {o}
                </option>)}
            </select>;
  })}
      </div>

      {typeof TableComponent === 'function' ? <TableComponent tableTitle={tableTitle} headerList={safeHeaderList} itemsList={withSeparators} monospaceColumns={safeMonospaceColumns} columnWidths={columnWidths} contentFitColumns={contentFitColumns} showSeparators={showSeparators} margin={margin} /> : <Warning>SearchTable requires a `TableComponent` prop.</Warning>}
    </div>;
};

{/* ==========================SECTION: SEARCH TIP========================= */}

<Tip>
  **Finding terms quickly**

  * **Cmd+K** (Mac) / **Ctrl+K** (Windows) - search all Livepeer docs
  * **Cmd+F** (Mac) / **Ctrl+F** (Windows) - search within this page
  * Use the category filter below to narrow by topic
</Tip>

<Note>
  Machine-readable term index: [glossary-data.json](./glossary-data.json)
</Note>

Terms used across Gateway deployment, payment configuration, Orchestrator routing, and node operation on the Livepeer Network.

<CustomDivider />

<LazyLoad height="600px">
  <SearchTable
    TableComponent={DynamicTable}
    showSeparators={true}
    filterColumns={["Niche"]}
    columnWidths={{ Definition: '50%' }}
    columnVariant={{ Category: "badge" }}
    categoryBadges={glossaryBadges}
    headerList={["Term", "Category", "Niche", "Definition"]}
    searchColumns={["Term", "Definition"]}
    itemsList={[
{ Term: "Arbitrage", Category: "economic", Niche: "pricing", Definition: "Exploiting price differences between markets; in the Livepeer context, selecting lower-cost orchestrators when multiple are available for the same capability." },
{ Term: "Arbitrum", Category: "web3", Niche: "chain", Definition: "A Layer 2 Optimistic Rollup settling to Ethereum that processes transactions off-chain while inheriting Ethereum-grade security; hosts the Livepeer protocol smart contracts." },
{ Term: "Bring Your Own Compute (BYOC)", Category: "livepeer", Niche: "deployment", Definition: "A deployment pattern enabling teams to supply custom Docker containers running Python AI workloads for Livepeer streaming." },
{ Term: "Broadcaster (deprecated)", Category: "livepeer", Niche: "role", Definition: "Legacy term for the gateway node - the node publishing streams and submitting video for transcoding; now replaced by 'Gateway' in all current documentation." },
{ Term: "BroadcastSessionsManager", Category: "livepeer", Niche: "protocol", Definition: "An internal go-livepeer component that manages active transcoding sessions between a gateway and its selected orchestrators." },
{ Term: "Capability", Category: "livepeer", Niche: "protocol", Definition: "An AI service or job type (pipeline/model pair) that an orchestrator can perform, advertised to the network so gateways can route matching requests." },
{ Term: "Cascade", Category: "livepeer", Niche: "upgrade", Definition: "The strategic vision for Livepeer to become the leading platform for real-time AI video pipelines, named as a protocol upgrade milestone." },
{ Term: "Clearinghouse", Category: "economic", Niche: "payment", Definition: "A contract or system handling settlement of payments between gateways and orchestrators, including multi-user support, API key authentication, usage accounting, and fiat/stablecoin billing." },
{ Term: "Codec", Category: "video", Niche: "encoding", Definition: "Software or hardware that compresses and decompresses digital video, typically using lossy compression." },
{ Term: "Cold Start", Category: "ai", Niche: "concept", Definition: "The latency incurred when an AI model must be loaded from storage into GPU memory before it can serve its first inference request, typically ranging from 5 to 90 seconds." },
{ Term: "CPU (Central Processing Unit)", Category: "technical", Niche: "hardware", Definition: "The primary general-purpose processor in a computer; in Livepeer, CPU handles node software overhead while GPU handles intensive transcoding and AI inference workloads." },
{ Term: "Demand Aggregation", Category: "operational", Niche: "process", Definition: "Consolidating requests from multiple users or applications for efficient routing to the orchestrator network." },
{ Term: "Deposit", Category: "economic", Niche: "payment", Definition: "Funds (ETH) locked by a gateway into the TicketBroker smart contract to pay orchestrators via probabilistic micropayments." },
{ Term: "Dispersal", Category: "video", Niche: "processing", Definition: "Distribution of encoded video segments across multiple orchestrator nodes for redundancy and parallel processing." },
{ Term: "Dual Gateway", Category: "livepeer", Niche: "deployment", Definition: "A deployment where a single gateway node operates both video transcoding and AI inference workloads simultaneously." },
{ Term: "Encoding Ladder", Category: "video", Niche: "encoding", Definition: "A structured set of video renditions at varying resolutions and bitrates for optimal cross-device adaptive bitrate viewing." },
{ Term: "ETH", Category: "web3", Niche: "token", Definition: "The native cryptocurrency of Ethereum, used to pay transaction fees (gas) and to fund gateway payment deposits on Arbitrum." },
{ Term: "Failover", Category: "operational", Niche: "monitoring", Definition: "Automatic switching to a backup orchestrator when the primary fails or becomes unresponsive during a session." },
{ Term: "GB (Gigabyte)", Category: "technical", Niche: "hardware", Definition: "A unit of digital storage equal to 1,073,741,824 bytes (binary); used in Livepeer hardware specifications for RAM, VRAM, and storage requirements." },
{ Term: "Gateway", Category: "livepeer", Niche: "role", Definition: "A node that submits jobs, routes work to orchestrators, manages payment flows, and provides a protocol interface between applications and the Livepeer network." },
{ Term: "Gateway-as-a-Service", Category: "livepeer", Niche: "deployment", Definition: "A hosted deployment model allowing users to access gateway functionality without managing their own infrastructure." },
{ Term: "Gateway Middleware", Category: "livepeer", Niche: "protocol", Definition: "A pluggable logic layer inserted into the gateway request pipeline for custom processing such as authentication, rate-limiting, or request transformation." },
{ Term: "GeForce", Category: "technical", Niche: "hardware", Definition: "NVIDIA's consumer-grade discrete GPU brand, encompassing the GTX and RTX product lines; the most common GPU family used by Livepeer orchestrator operators." },
{ Term: "Group of Pictures (GOP)", Category: "video", Niche: "encoding", Definition: "An ordered arrangement of I-frames and inter-frames within a coded video stream; the set of frames between keyframes." },
{ Term: "GPU Worker", Category: "technical", Niche: "infra", Definition: "A Livepeer node with GPU hardware that performs transcoding or AI inference tasks for an orchestrator." },
{ Term: "GTX (NVIDIA GTX)", Category: "technical", Niche: "hardware", Definition: "NVIDIA's previous-generation consumer GPU product line; capable of Livepeer video transcoding but lacks the Tensor cores of the RTX series needed for accelerated AI inference." },
{ Term: "HTTP Live Streaming (HLS)", Category: "video", Niche: "protocol", Definition: "An HTTP-based streaming protocol by Apple that encodes video into multiple quality levels with an index playlist for adaptive delivery." },
{ Term: "HTTP Ingest", Category: "video", Niche: "processing", Definition: "Receiving a live video stream via HTTP push (rather than RTMP) for transcoding or AI processing." },
{ Term: "HuggingFace", Category: "ai", Niche: "platform", Definition: "An AI platform and open-source community providing model repositories, datasets, and inference APIs; a primary source for AI models deployed on Livepeer orchestrator nodes." },
{ Term: "Inference", Category: "ai", Niche: "concept", Definition: "Running a trained AI model on new input data to produce predictions or generated output, as opposed to training the model." },
{ Term: "Interval-Based Payment", Category: "economic", Niche: "payment", Definition: "A compensation model where payment tickets are sent at regular time intervals rather than per segment or per request." },
{ Term: "Latency", Category: "technical", Niche: "infra", Definition: "The delay between a request being made (e.g., a frame captured or a segment submitted) and the response or output being received." },
{ Term: "Live AI", Category: "ai", Niche: "concept", Definition: "Real-time AI processing applied to live video streams, typically using pipelines such as live-video-to-video running at interactive frame rates." },
{ Term: "LivepeerNode", Category: "livepeer", Niche: "protocol", Definition: "The core Go struct in go-livepeer representing a running Livepeer node instance, encapsulating configuration, session state, and network connections." },
{ Term: "livepeer-python-gateway", Category: "livepeer", Niche: "sdk", Definition: "An open-source Python reference implementation of a Livepeer gateway, enabling job submission, payment flow management, and pipeline routing from Python applications." },
{ Term: "Marketplace", Category: "livepeer", Niche: "product", Definition: "The decentralized market on the Livepeer network matching gateway demand with orchestrator supply, governed by capability, price, and performance." },
{ Term: "MaxPricePerCapability", Category: "livepeer", Niche: "config", Definition: "A CLI configuration flag setting the maximum price a gateway will pay for a specific AI pipeline/model pair (capability), overriding the general MaxPricePerUnit for that task type." },
{ Term: "MaxPricePerUnit", Category: "livepeer", Niche: "config", Definition: "A CLI configuration flag setting the maximum price per pixelsPerUnit that a gateway will accept from orchestrators; orchestrators priced above this threshold are excluded." },
{ Term: "Micropayment Ticket", Category: "economic", Niche: "payment", Definition: "A small-value signed data structure sent from a gateway to an orchestrator representing a probabilistic payment; only winning tickets are redeemed on-chain." },
{ Term: "Model", Category: "ai", Niche: "concept", Definition: "A mathematical structure (neural network with learned weights) enabling predictions or generation from new inputs when run as inference." },
{ Term: "Network as a Platform (NaaP)", Category: "livepeer", Niche: "product", Definition: "A reference architecture and implementation for multi-tenant gateway operation providing JWT-based authentication, developer API keys, and per-user usage tracking on top of a Livepeer gateway." },
{ Term: "Off-Chain Gateway", Category: "livepeer", Niche: "deployment", Definition: "A gateway node that operates without blockchain integration, using a remote signer for payment operations and specifying orchestrators manually rather than relying on protocol discovery." },
{ Term: "On-Chain Gateway", Category: "livepeer", Niche: "deployment", Definition: "A gateway node connected to the Livepeer protocol on Arbitrum, managing its own Ethereum wallet and using on-chain probabilistic micropayments for orchestrator settlement." },
{ Term: "Operational Mode", Category: "livepeer", Niche: "config", Definition: "The deployment configuration that determines how a gateway connects to the Livepeer network: on-chain (Arbitrum-based payments, protocol discovery) or off-chain (remote signer, manual orchestrator addresses)." },
{ Term: "Orchestrator", Category: "livepeer", Niche: "role", Definition: "A supply-side node contributing GPU resources, receiving jobs from gateways, performing video transcoding or AI inference, and earning ETH and LPT rewards." },
{ Term: "Orchestrator Discovery", Category: "livepeer", Niche: "protocol", Definition: "The process by which a gateway finds and evaluates available orchestrators - either automatically via the on-chain ServiceRegistry or manually via configured -orchAddr flags." },
{ Term: "Per Pixel (Price Per Pixel)", Category: "livepeer", Niche: "economics", Definition: "Livepeer's unit-based pricing mechanism where fees are calculated based on the number of pixels processed during a transcoding or AI inference job." },
{ Term: "Per-Pixel Pricing", Category: "economic", Niche: "pricing", Definition: "A cost model charging for transcoding work based on the total number of pixels processed (width × height × frame count), enabling standardized comparison across resolutions." },
{ Term: "Per-Request Pricing", Category: "economic", Niche: "pricing", Definition: "A cost model charging per individual AI inference request rather than per pixel, used for AI pipeline jobs where pixel count is not a meaningful unit." },
{ Term: "Pipeline", Category: "livepeer", Niche: "protocol", Definition: "A configured end-to-end AI processing workflow defining input type, model, and output, routed by the gateway to capable orchestrators." },
{ Term: "Probabilistic Micropayments", Category: "economic", Niche: "payment", Definition: "A lottery-based payment mechanism where gateways send signed tickets to orchestrators; only winning tickets are redeemed on-chain, amortizing gas costs across many transactions." },
{ Term: "Profile", Category: "video", Niche: "encoding", Definition: "An output specification defining a single transcoding rendition: resolution, bitrate, codec, and frame rate." },
{ Term: "Protocol Layer", Category: "livepeer", Niche: "protocol", Definition: "The on-chain layer on Arbitrum governing staking, delegation, rewards, orchestrator registration, and payment verification via smart contracts." },
{ Term: "Real-Time Messaging Protocol (RTMP)", Category: "video", Niche: "protocol", Definition: "A protocol for streaming audio, video, and data over TCP on port 1935, commonly used for live video ingest from encoders such as OBS into a media server." },
{ Term: "Redemption", Category: "economic", Niche: "payment", Definition: "The on-chain process of cashing in a winning probabilistic micropayment ticket for its face value in ETH via the TicketBroker contract." },
{ Term: "Remote Signer", Category: "technical", Niche: "security", Definition: "A separate service that holds an Ethereum private key and signs payment tickets on behalf of an off-chain gateway, so the gateway itself holds no ETH." },
{ Term: "Rendition", Category: "video", Niche: "processing", Definition: "A single encoded version of a source video at a specific resolution, bitrate, and codec configuration, produced by an orchestrator." },
{ Term: "Reserve", Category: "economic", Niche: "payment", Definition: "ETH held as collateral in the TicketBroker contract backing outstanding probabilistic payment tickets; used if the gateway's deposit is depleted." },
{ Term: "RTX (NVIDIA RTX)", Category: "technical", Niche: "hardware", Definition: "NVIDIA's current consumer GPU product line featuring dedicated Tensor cores that accelerate AI/ML inference workloads; RTX GPUs are well-suited for Livepeer AI pipeline tasks." },
{ Term: "Scaling", Category: "operational", Niche: "process", Definition: "Increasing gateway capacity to handle more concurrent requests, either horizontally (deploying additional gateway nodes) or vertically (adding resources to an existing node)." },
{ Term: "Segment", Category: "video", Niche: "processing", Definition: "A time-sliced chunk of multiplexed audio and video independently submitted to an orchestrator for transcoding in parallel with other segments." },
{ Term: "Self-Hosted", Category: "technical", Niche: "deployment", Definition: "A deployment model in which the operator runs their own infrastructure rather than relying on a managed cloud service; Livepeer gateways and AI nodes can be self-hosted on any compatible hardware." },
{ Term: "Service Margin", Category: "economic", Niche: "pricing", Definition: "A markup that gateway operators add on top of orchestrator costs when reselling gateway access to end users." },
{ Term: "ServiceRegistry", Category: "livepeer", Niche: "contract", Definition: "A smart contract on Arbitrum where orchestrators register their service URI so that on-chain gateways can discover and contact them." },
{ Term: "Session", Category: "livepeer", Niche: "protocol", Definition: "An active, persistent connection between a gateway and an orchestrator during which one or more jobs (segments or AI requests) are processed." },
{ Term: "Settlement", Category: "economic", Niche: "payment", Definition: "The on-chain finalization of off-chain payment obligations via ticket redemption through the TicketBroker contract." },
{ Term: "Signer", Category: "technical", Niche: "security", Definition: "The cryptographic key holder or process that authorizes payment tickets and Ethereum transactions on behalf of a gateway node." },
{ Term: "SLA (Service Level Agreement)", Category: "technical", Niche: "operations", Definition: "A formal commitment between a service provider and a customer defining expected performance levels, uptime guarantees, and remediation obligations." },
{ Term: "TicketBroker", Category: "livepeer", Niche: "contract", Definition: "The smart contract on Arbitrum that manages the probabilistic micropayment system - holding gateway deposits and reserves, and processing winning ticket redemptions." },
{ Term: "Transcoding", Category: "video", Niche: "processing", Definition: "Direct digital-to-digital conversion of a video stream from one encoding format, resolution, or bitrate to one or more output renditions for adaptive delivery." },
{ Term: "USD Pricing", Category: "economic", Niche: "pricing", Definition: "A pricing configuration where work costs are denominated in US dollars, with automatic dynamic conversion to wei as the ETH/USD exchange rate fluctuates." },
{ Term: "Warm Model", Category: "ai", Niche: "concept", Definition: "An AI model that is already loaded into GPU memory on an orchestrator and ready to serve inference requests immediately, without cold-start latency." },
{ Term: "Webhook", Category: "technical", Niche: "dev", Definition: "An HTTP callback that sends a POST request to a configured URL when a gateway event occurs, notifying external systems in real time." },
{ Term: "Weight Factors", Category: "livepeer", Niche: "config", Definition: "Configurable scoring parameters - including stake weight, price weight, and random selection weight - that the gateway uses to rank and select orchestrators during discovery." },
{ Term: "Wei", Category: "web3", Niche: "token", Definition: "The smallest denomination of Ether, where 1 ETH equals 10^18 Wei; used in on-chain price calculations and payment ticket values." },
]}
  />
</LazyLoad>

<CustomDivider />

## Livepeer Protocol Terms

<AccordionGroup>
  <Accordion title="Bring Your Own Compute (BYOC)" icon="book-open">
    **Definition**: Bring-Your-Own-Container - a deployment pattern enabling teams to supply custom Docker containers running Python AI workloads for Livepeer streaming.

    **Also known as**: BYOC

    **Context**: On Livepeer, BYOC lets Gateway and Orchestrator operators deploy containerized custom AI models as pipelines without waiting for official pipeline support.

    **Status**: current

    **Pages**: `gateways/compute`, `gateways/pipelines`
  </Accordion>

  <Accordion title="Broadcaster (deprecated)" icon="book-open">
    **Definition**: Legacy term for the Gateway node - the node publishing streams and submitting video for transcoding; now replaced by "Gateway" in all current documentation.

    **Also known as**: Gateway (current term); the `-broadcaster=true` CLI flag has been replaced by `-gateway`

    **Context**: Older community guides and go-livepeer releases prior to 2023 used "Broadcaster." The terms are functionally equivalent; the rename reflects the expanded role beyond video broadcasting.

    **Status**: deprecated - replaced by "Gateway"

    **Pages**: `gateways/architecture`, `gateways/protocol`
  </Accordion>

  <Accordion title="BroadcastSessionsManager" icon="book-open">
    **Definition**: An internal go-livepeer component that manages active transcoding sessions between a Gateway and its selected Orchestrators.

    **Context**: The BroadcastSessionsManager tracks session state, handles failover logic, and maintains per-Orchestrator session pools within a running Gateway node.

    **Status**: current

    **Pages**: `gateways/code`, `gateways/architecture`
  </Accordion>

  <Accordion title="Capability" icon="book-open">
    **Definition**: An AI service or job type (pipeline/model pair) that an Orchestrator can perform, advertised to the network so Gateways can route matching requests.

    **Context**: Gateways use capability advertisements to discover which Orchestrators support a given AI pipeline and model, enabling targeted routing without manual Orchestrator configuration.

    **Status**: current

    **Pages**: `gateways/discovery`, `gateways/protocol`
  </Accordion>

  <Accordion title="Cascade" icon="book-open">
    **Definition**: The strategic vision for Livepeer to become the leading platform for real-time AI video pipelines, named as a protocol upgrade milestone.

    **Context**: Cascade represents both a named upgrade phase and the overarching product direction enabling AI inference on the Livepeer Network alongside traditional video transcoding.

    **Status**: current

    **Pages**: `gateways/protocol`
  </Accordion>

  <Accordion title="Clearinghouse" icon="book-open">
    **Definition**: A contract or system handling settlement of payments between Gateways and Orchestrators, including multi-user support, API key authentication, usage accounting, and fiat/stablecoin billing.

    **Context**: In Gateway deployments, a clearinghouse is an abstraction over a remote signer that adds commercial services. It enables Gateway operators to offer multi-tenant billing without each user needing their own ETH wallet.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Dual Gateway" icon="book-open">
    **Definition**: A deployment where a single Gateway node operates both video transcoding and AI inference workloads simultaneously.

    **Also known as**: Dual mode

    **Context**: A dual Gateway routes RTMP transcoding requests and AI inference requests from the same node instance, requiring Linux (the AI component does not support Windows or macOS natively).

    **Status**: current

    **Pages**: `gateways/architecture`, `gateways/modes`
  </Accordion>

  <Accordion title="Gateway" icon="book-open">
    **Definition**: A node that submits jobs, routes work to Orchestrators, manages payment flows, and provides a protocol interface between applications and the Livepeer Network.

    **Context**: A Gateway does not perform compute - it routes work to Orchestrators that do. Gateways can operate on-chain (with Arbitrum-based payments) or off-chain (using a remote signer). No GPU is required to run a Gateway.

    **Status**: current

    **Pages**: `gateways/index`, `gateways/architecture`
  </Accordion>

  <Accordion title="Gateway-as-a-Service" icon="book-open">
    **Definition**: A hosted deployment model allowing users to access Gateway functionality without managing their own infrastructure.

    **Context**: Gateway-as-a-service offerings (for example, Livepeer Studio, Livepeer Cloud, or Daydream) run Gateway nodes on the operator's behalf. The user pays the service's rate and receives an API endpoint rather than running go-livepeer directly.

    **Status**: current

    **Pages**: `gateways/modes`, `gateways/architecture`
  </Accordion>

  <Accordion title="Gateway Middleware" icon="book-open">
    **Definition**: A pluggable logic layer inserted into the Gateway request pipeline for custom processing such as authentication, rate-limiting, or request transformation.

    **Context**: Gateway middleware lets operators intercept and modify requests or responses at the Gateway layer without forking go-livepeer. Middleware is typically configured in code for SDK-based deployments or via hooks in go-livepeer.

    **Status**: current

    **Pages**: `gateways/architecture`, `gateways/code`
  </Accordion>

  <Accordion title="LivepeerNode" icon="book-open">
    **Definition**: The core Go struct in go-livepeer representing a running Livepeer node instance, encapsulating configuration, session state, and network connections.

    **Context**: LivepeerNode is the central object in the Gateway codebase. Understanding its structure is relevant when building custom Gateway middleware or debugging Gateway internals.

    **Status**: current

    **Pages**: `gateways/code`, `gateways/architecture`
  </Accordion>

  <Accordion title="livepeer-python-gateway" icon="book-open">
    **Definition**: An open-source Python reference implementation of a Livepeer Gateway, enabling job submission, payment flow management, and pipeline routing from Python applications.

    **Context**: Maintained by the community as a lightweight alternative for developers building Python-native integrations.

    **Status**: current

    **Pages**: `gateways/sdks`, `gateways/architecture`
  </Accordion>

  <Accordion title="Marketplace" icon="book-open">
    **Definition**: The decentralised market on the Livepeer Network matching Gateway demand with Orchestrator supply, governed by capability, price, and performance.

    **Context**: The Livepeer marketplace is not a discrete application but an emergent property of the protocol: Orchestrators advertise capabilities and prices, Gateways select and route work, and payment flows coordinate supply with demand.

    **Status**: current

    **Pages**: `gateways/economics`, `gateways/architecture`
  </Accordion>

  <Accordion title="MaxPricePerCapability" icon="book-open">
    **Definition**: A CLI configuration flag setting the maximum price a Gateway will pay for a specific AI pipeline/model pair (capability), overriding the general MaxPricePerUnit for that task type.

    **Context**: MaxPricePerCapability lets Gateway operators fine-tune spending limits per AI task, for example paying more for a high-quality image-to-video pipeline while capping spend on cheaper text-to-image tasks.

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/config`
  </Accordion>

  <Accordion title="MaxPricePerUnit" icon="book-open">
    **Definition**: A CLI configuration flag setting the maximum price per pixelsPerUnit that a Gateway will accept from Orchestrators; Orchestrators priced above this threshold are excluded.

    **Also known as**: MaxPrice

    **Context**: MaxPricePerUnit acts as a hard gate in Orchestrator selection. Setting it too low reduces the available Orchestrator pool; too high increases cost. It can be expressed in wei or as a USD-denominated value with automatic conversion.

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/config`
  </Accordion>

  <Accordion title="Network as a Platform (NaaP)" icon="book-open">
    **Definition**: Network-as-a-Product - a reference architecture and implementation for multi-tenant Gateway operation providing JWT-based authentication, developer API keys, and per-user usage tracking on top of a Livepeer Gateway.

    **Also known as**: NaaP

    **Context**: NaaP enables Gateway operators to expose Livepeer infrastructure to third-party developers with managed access control and billing, turning a single Gateway deployment into a platform business. Repository: github.com/Livepeer/naap.

    **Status**: current

    **Pages**: `gateways/architecture`, `gateways/protocol`
  </Accordion>

  <Accordion title="Off-Chain Gateway" icon="book-open">
    **Definition**: A Gateway node that operates without blockchain integration, using a remote signer for payment operations and specifying Orchestrators manually rather than relying on protocol discovery.

    **Context**: Off-chain is a sustainable production mode for Gateways (unlike off-chain Orchestrators, which are only for testing). An off-chain Gateway holds no ETH; a community-hosted remote signer at signer.eliteencoder.net is publicly available and free to use.

    **Status**: current

    **Pages**: `gateways/modes`
  </Accordion>

  <Accordion title="On-Chain Gateway" icon="book-open">
    **Definition**: A Gateway node connected to the Livepeer Protocol on Arbitrum, managing its own Ethereum wallet and using on-chain Probabilistic Micropayments for Orchestrator settlement.

    **Context**: On-chain Gateways require ETH deposited on Arbitrum for the payment deposit and reserve, and use protocol-based Orchestrator discovery. This mode provides access to the full registered Orchestrator pool but requires crypto-wallet management.

    **Status**: current

    **Pages**: `gateways/modes`
  </Accordion>

  <Accordion title="Operational Mode" icon="book-open">
    **Definition**: The deployment configuration that determines how a Gateway connects to the Livepeer Network: on-chain (Arbitrum-based payments, protocol discovery) or off-chain (remote signer, manual Orchestrator addresses).

    **Context**: Operational mode is an independent axis from node type and setup type. Both on-chain and off-chain Gateways can route video, AI, or dual workloads. Off-chain is a valid production configuration for Gateways.

    **Status**: current

    **Pages**: `gateways/modes`, `gateways/config`
  </Accordion>

  <Accordion title="Orchestrator" icon="book-open">
    **Definition**: A supply-side node contributing GPU resources, receiving jobs from Gateways, performing video transcoding or AI inference, and earning ETH and LPT rewards.

    **Context**: From the Gateway's perspective, Orchestrators are the compute providers it routes work to. Gateways select Orchestrators based on capability, price, performance score, and stake weight, then maintain sessions with selected Orchestrators.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/protocol`
  </Accordion>

  <Accordion title="Orchestrator Discovery" icon="book-open">
    **Definition**: The process by which a Gateway finds and evaluates available Orchestrators - either automatically via the on-chain ServiceRegistry or manually via configured `-orchAddr` flags.

    **Context**: On-chain Gateways use the ServiceRegistry contract on Arbitrum to discover registered Orchestrators and their service URIs. Off-chain Gateways bypass discovery and connect directly to specified addresses.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/architecture`
  </Accordion>

  <Accordion title="Pipeline" icon="book-open">
    **Definition**: A configured end-to-end AI processing workflow defining input type, model, and output, routed by the Gateway to capable Orchestrators.

    **Context**: On Livepeer, a pipeline is the combination of a pipeline type (e.g., text-to-image, live-video-to-video) and a specific model ID. Gateways match incoming AI requests to Orchestrators advertising the corresponding capability.

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>

  <Accordion title="Protocol Layer" icon="book-open">
    **Definition**: The on-chain layer on Arbitrum governing staking, delegation, rewards, Orchestrator registration, and payment verification via smart contracts.

    **Context**: Gateways interact with the protocol layer when operating in on-chain mode - reading Orchestrator registrations from the ServiceRegistry, submitting deposits to the TicketBroker, and settling payments through probabilistic ticket redemption.

    **Status**: current

    **Pages**: `gateways/protocol`, `gateways/architecture`
  </Accordion>

  <Accordion title="ServiceRegistry" icon="book-open">
    **Definition**: A smart contract on Arbitrum where Orchestrators register their service URI so that on-chain Gateways can discover and contact them.

    **Context**: The ServiceRegistry is the on-chain source of truth for Orchestrator endpoints. On-chain Gateways query it at startup and during session establishment; off-chain Gateways bypass it entirely by using `-orchAddr`.

    **Status**: current

    **Pages**: `gateways/protocol`, `gateways/contracts`
  </Accordion>

  <Accordion title="Session" icon="book-open">
    **Definition**: An active, persistent connection between a Gateway and an Orchestrator during which one or more jobs (segments or AI requests) are processed.

    **Context**: Gateways reuse sessions across segments to amortize connection setup overhead. Session affinity improves performance by keeping warm models loaded on the Orchestrator; the BroadcastSessionsManager handles session lifecycle.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/architecture`
  </Accordion>

  <Accordion title="TicketBroker" icon="book-open">
    **Definition**: The smart contract on Arbitrum that manages the probabilistic micropayment system - holding Gateway deposits and reserves, and processing winning ticket redemptions.

    **Context**: TicketBroker is the payment settlement layer every on-chain Gateway interacts with. Gateways fund it via deposit and reserve; Orchestrators redeem winning tickets through it. Off-chain Gateways use a remote signer pointing to the same contract.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/contracts`
  </Accordion>

  <Accordion title="Weight Factors" icon="book-open">
    **Definition**: Configurable scoring parameters - including stake weight, price weight, and random selection weight - that the Gateway uses to rank and select Orchestrators during discovery.

    **Context**: Weight factors (e.g., `selectRandWeight`, `selectStakeWeight`, `selectPriceWeight`) let Gateway operators tune the trade-off between cost, decentralization, and performance in Orchestrator selection. Adjusting these requires understanding their interaction with the scoring algorithm.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/discovery`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Economic Terms

<AccordionGroup>
  <Accordion title="Arbitrage" icon="book-open">
    **Definition**: Exploiting price differences between markets; in the Livepeer context, selecting lower-cost Orchestrators when multiple are available for the same capability.

    **External**: [Arbitrage (Wikipedia)](https://en.wikipedia.org/wiki/Arbitrage)

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/economics`
  </Accordion>

  <Accordion title="Deposit" icon="book-open">
    **Definition**: Funds (ETH) locked by a Gateway into the TicketBroker smart contract to pay Orchestrators via Probabilistic Micropayments.

    **Context**: An on-chain Gateway must maintain a deposit on Arbitrum. The deposit covers the expected value of outstanding payment tickets sent to Orchestrators. If the deposit is depleted, the reserve acts as backstop.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Interval-Based Payment" icon="book-open">
    **Definition**: A compensation model where payment tickets are sent at regular time intervals rather than per segment or per request.

    **Context**: Interval-based payments reduce per-segment overhead by batching payment obligations into timed intervals. This is an alternative to per-segment ticket issuance in the Livepeer probabilistic micropayment system.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Micropayment Ticket" icon="book-open">
    **Definition**: A small-value signed data structure sent from a Gateway to an Orchestrator representing a probabilistic payment; only winning tickets are redeemed on-chain.

    **Also known as**: Payment ticket, probabilistic micropayment ticket

    **Context**: Gateways issue micropayment tickets to Orchestrators as work is performed. The lottery-based mechanism means only a fraction of tickets result in on-chain transactions, dramatically reducing gas costs while preserving expected-value fairness.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Per Pixel (Price Per Pixel)" icon="book-open">
    **Definition**: Livepeer's unit-based pricing mechanism where fees are calculated based on the number of pixels processed during a transcoding or AI inference job.

    **Context**: A 4K frame costs more to process than a 720p frame because it contains more pixels; enables pricing that scales with workload complexity.

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/transcoding`
  </Accordion>

  <Accordion title="Per-Pixel Pricing" icon="book-open">
    **Definition**: A cost model charging for transcoding work based on the total number of pixels processed (width × height × frame count), enabling standardised comparison across resolutions.

    **External**: [Pay-per-pixel (Livepeer Forum)](https://forum.livepeer.org/t/a-guide-for-determining-price-per-pixel/2197)

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/transcoding`
  </Accordion>

  <Accordion title="Per-Request Pricing" icon="book-open">
    **Definition**: A cost model charging per individual AI inference request rather than per pixel, used for AI pipeline jobs where pixel count is not a meaningful unit.

    **External**: [Livepeer AI pipelines](https://docs.livepeer.org/ai/pipelines/audio-to-text)

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/pipelines`
  </Accordion>

  <Accordion title="Probabilistic Micropayments" icon="book-open">
    **Definition**: A lottery-based payment mechanism where Gateways send signed tickets to Orchestrators; only winning tickets are redeemed on-chain, amortizing gas costs across many transactions.

    **Context**: Probabilistic Micropayments are the core payment layer for Livepeer. The Gateway manages ticket issuance and ensures the deposit and reserve on the TicketBroker contract are sufficient to cover expected redemptions.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Redemption" icon="book-open">
    **Definition**: The on-chain process of cashing in a winning probabilistic micropayment ticket for its face value in ETH via the TicketBroker contract.

    **Context**: Orchestrators (or their redeemer process) submit winning tickets to TicketBroker to claim ETH. The Gateway's deposit and reserve fund these redemptions. High redemption frequency relative to deposit size is a signal to top up.

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Reserve" icon="book-open">
    **Definition**: ETH held as collateral in the TicketBroker contract backing outstanding probabilistic payment tickets; used if the Gateway's deposit is depleted.

    **Context**: An on-chain Gateway must fund both a deposit (normal operating balance) and a reserve (safety backstop). The reserve prevents Orchestrators from being left unpaid if the deposit runs out between top-ups.

    **Status**: current

    **Pages**: `gateways/payments`
  </Accordion>

  <Accordion title="Service Margin" icon="book-open">
    **Definition**: A markup that Gateway operators add on top of Orchestrator costs when reselling Gateway access to end users.

    **Context**: Gateway operators running NaaP or Gateway-as-a-service offerings use a service margin to cover infrastructure, development, and operational overhead while remaining price-competitive with direct Orchestrator costs.

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/economics`
  </Accordion>

  <Accordion title="Settlement" icon="book-open">
    **Definition**: The on-chain finalization of off-chain payment obligations via ticket redemption through the TicketBroker contract.

    **Context**: Settlement occurs when an Orchestrator redeems a winning ticket, converting the probabilistic payment into an actual ETH transfer. The Gateway's deposit funds these settlements; the reserve backstops them.

    **Status**: current

    **Pages**: `gateways/payments`
  </Accordion>

  <Accordion title="USD Pricing" icon="book-open">
    **Definition**: A pricing configuration where work costs are denominated in US dollars, with automatic dynamic conversion to wei as the ETH/USD exchange rate fluctuates.

    **Context**: USD pricing shields Gateway operators from ETH price volatility. The Gateway (or an external price feed integration) queries an ETH/USD oracle and adjusts the wei-denominated MaxPrice accordingly, keeping spend stable in fiat terms.

    **Status**: current

    **Pages**: `gateways/pricing`, `gateways/config`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Video Terms

<AccordionGroup>
  <Accordion title="Codec" icon="book-open">
    **Definition**: Software or hardware that compresses and decompresses digital video, typically using lossy compression.

    **External**: [Video codec (Wikipedia)](https://en.wikipedia.org/wiki/Video_codec)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/encoding`
  </Accordion>

  <Accordion title="Dispersal" icon="book-open">
    **Definition**: Distribution of encoded video segments across multiple Orchestrator nodes for redundancy and parallel processing.

    **Context**: When a Gateway disperses work, it splits a stream's segments across multiple Orchestrators simultaneously, enabling parallel transcoding and reducing the impact of a single slow or failing node.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/architecture`
  </Accordion>

  <Accordion title="Encoding Ladder" icon="book-open">
    **Definition**: A structured set of video renditions at varying resolutions and bitrates for optimal cross-device adaptive bitrate viewing.

    **External**: [Encoding ladder (Cloudinary)](https://cloudinary.com/glossary/encoding-ladder)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/profiles`
  </Accordion>

  <Accordion title="Group of Pictures (GOP)" icon="book-open">
    **Definition**: An ordered arrangement of I-frames and inter-frames within a coded video stream; the set of frames between keyframes.

    **Also known as**: GOP

    **External**: [Group of pictures (Wikipedia)](https://en.wikipedia.org/wiki/Group_of_pictures)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/encoding`
  </Accordion>

  <Accordion title="HTTP Live Streaming (HLS)" icon="book-open">
    **Definition**: An HTTP-based streaming protocol by Apple that encodes video into multiple quality levels with an index playlist for adaptive delivery.

    **Also known as**: HLS

    **External**: [HTTP Live Streaming (Wikipedia)](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/streaming`
  </Accordion>

  <Accordion title="HTTP Ingest" icon="book-open">
    **Definition**: Receiving a live video stream via HTTP push (rather than RTMP) for transcoding or AI processing.

    **External**: [HTTP (Wikipedia)](https://en.wikipedia.org/wiki/HTTP)

    **Status**: current

    **Pages**: `gateways/ingest`, `gateways/streaming`
  </Accordion>

  <Accordion title="Profile" icon="book-open">
    **Definition**: An output specification defining a single transcoding rendition: resolution, bitrate, codec, and frame rate.

    **External**: [Output profile (Wikipedia)](https://en.wikipedia.org/wiki/Advanced_Video_Coding)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/config`
  </Accordion>

  <Accordion title="Real-Time Messaging Protocol (RTMP)" icon="book-open">
    **Definition**: A protocol for streaming audio, video, and data over TCP on port 1935, commonly used for live video ingest from encoders such as OBS into a media server.

    **Also known as**: RTMP

    **External**: [RTMP (Wikipedia)](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol)

    **Status**: current

    **Pages**: `gateways/ingest`, `gateways/streaming`
  </Accordion>

  <Accordion title="Rendition" icon="book-open">
    **Definition**: A single encoded version of a source video at a specific resolution, bitrate, and codec configuration, produced by an Orchestrator.

    **External**: [Video rendition (Cloudinary)](https://cloudinary.com/glossary/video-rendition)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/encoding`
  </Accordion>

  <Accordion title="Segment" icon="book-open">
    **Definition**: A time-sliced chunk of multiplexed audio and video independently submitted to an Orchestrator for transcoding in parallel with other segments.

    **External**: [HTTP Live Streaming segments (Wikipedia)](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/protocol`
  </Accordion>

  <Accordion title="Transcoding" icon="book-open">
    **Definition**: Direct digital-to-digital conversion of a video stream from one encoding format, resolution, or bitrate to one or more output renditions for adaptive delivery.

    **External**: [Transcoding (Wikipedia)](https://en.wikipedia.org/wiki/Transcoding)

    **Status**: current

    **Pages**: `gateways/transcoding`, `gateways/index`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## AI Terms

<AccordionGroup>
  <Accordion title="Cold Start" icon="book-open">
    **Definition**: The latency incurred when an AI model must be loaded from storage into GPU memory before it can serve its first inference request, typically ranging from 5 to 90 seconds.

    **Also known as**: Cold model

    **External**: [Cold start latency (OpenMetal)](https://openmetal.io/resources/blog/cold-start-latency-private-ai-inference/)

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>

  <Accordion title="HuggingFace" icon="book-open">
    **Definition**: An AI platform and open-source community providing model repositories, datasets, and inference APIs; a primary source for AI models deployed on Livepeer Orchestrator nodes.

    **Also known as**: Hugging Face, HF

    **External**: [HuggingFace](https://huggingface.co/)

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="Inference" icon="book-open">
    **Definition**: Running a trained AI model on new input data to produce predictions or generated output, as opposed to training the model.

    **External**: [Inference engine (Wikipedia)](https://en.wikipedia.org/wiki/Inference_engine)

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>

  <Accordion title="Live AI" icon="book-open">
    **Definition**: Real-time AI processing applied to live video streams, typically using pipelines such as live-video-to-video running at interactive frame rates.

    **Context**: Live AI on Livepeer routes live stream frames through Orchestrator GPU workers running models like StreamDiffusion. The Gateway manages session continuity and Orchestrator selection to maintain the low-latency budget required for interactive output.

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>

  <Accordion title="Model" icon="book-open">
    **Definition**: A mathematical structure (neural network with learned weights) enabling predictions or generation from new inputs when run as inference.

    **External**: [Machine learning (Wikipedia)](https://en.wikipedia.org/wiki/Machine_learning)

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>

  <Accordion title="Warm Model" icon="book-open">
    **Definition**: An AI model that is already loaded into GPU memory on an Orchestrator and ready to serve inference requests immediately, without cold-start latency.

    **External**: [Cold start latency (OpenMetal)](https://openmetal.io/resources/blog/cold-start-latency-private-ai-inference/)

    **Status**: current

    **Pages**: `gateways/pipelines`, `gateways/routing`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Web3 Terms

<AccordionGroup>
  <Accordion title="Arbitrum" icon="book-open">
    **Definition**: A Layer 2 Optimistic Rollup settling to Ethereum that processes transactions off-chain while inheriting Ethereum-grade security; hosts the Livepeer Protocol smart contracts.

    **External**: [Arbitrum One (docs.Arbitrum.io)](https://docs.arbitrum.io/welcome/arbitrum-gentle-introduction)

    **Status**: current

    **Pages**: `gateways/protocol`, `gateways/payments`
  </Accordion>

  <Accordion title="ETH" icon="book-open">
    **Definition**: The native cryptocurrency of Ethereum, used to pay transaction fees (gas) and to fund Gateway payment deposits on Arbitrum.

    **External**: [Ether (ethereum.org)](https://ethereum.org/what-is-ether/)

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/protocol`
  </Accordion>

  <Accordion title="Wei" icon="book-open">
    **Definition**: The smallest denomination of Ether, where 1 ETH equals 10^18 Wei; used in on-chain price calculations and payment ticket values.

    **External**: [Ether denominations (ethereum.org)](https://ethereum.org/glossary/)

    **Status**: current

    **Pages**: `gateways/payments`, `gateways/pricing`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Technical Terms

<AccordionGroup>
  <Accordion title="GPU Worker" icon="book-open">
    **Definition**: A Livepeer node with GPU hardware that performs transcoding or AI inference tasks for an Orchestrator.

    **Context**: In Gateway routing, the Gateway selects Orchestrators that have available GPU workers capable of handling the requested AI pipeline or transcoding profile. The Gateway itself does not require a GPU.

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/architecture`
  </Accordion>

  <Accordion title="Latency" icon="book-open">
    **Definition**: The delay between a request being made (e.g., a frame captured or a segment submitted) and the response or output being received.

    **External**: [Latency (Wikipedia)](https://en.wikipedia.org/wiki/Latency_\(engineering\))

    **Status**: current

    **Pages**: `gateways/routing`
  </Accordion>

  <Accordion title="Remote Signer" icon="book-open">
    **Definition**: A separate service that holds an Ethereum private key and signs payment tickets on behalf of an off-chain Gateway, so the Gateway itself holds no ETH.

    **Context**: A community-hosted remote signer at signer.eliteencoder.net is publicly available and free to use for off-chain Gateways. Custom remote signers can be built using any language that implements the signing API, enabling SDK-based Gateway deployments.

    **Status**: current

    **Pages**: `gateways/security`, `gateways/config`
  </Accordion>

  <Accordion title="Signer" icon="book-open">
    **Definition**: The cryptographic key holder or process that authorizes payment tickets and Ethereum transactions on behalf of a Gateway node.

    **Context**: In an on-chain Gateway, the signer is typically a local keystore file. In an off-chain Gateway, signing is delegated to a remote signer service. The signer never needs to hold large ETH balances in the off-chain model.

    **Status**: current

    **Pages**: `gateways/security`, `gateways/config`
  </Accordion>

  <Accordion title="Webhook" icon="book-open">
    **Definition**: An HTTP callback that sends a POST request to a configured URL when a Gateway event occurs, notifying external systems in real time.

    **External**: [Webhook (Wikipedia)](https://en.wikipedia.org/wiki/Webhook)

    **Status**: current

    **Pages**: `gateways/events`, `gateways/config`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Hardware Terms

<AccordionGroup>
  <Accordion title="CPU (Central Processing Unit)" icon="book-open">
    **Definition**: The primary general-purpose processor in a computer; in Livepeer, CPU handles node software overhead while GPU handles intensive transcoding and AI inference workloads.

    **Tags**: `technical:hardware`

    **External**: [Wikipedia](https://en.wikipedia.org/wiki/Central_processing_unit)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="GB (Gigabyte)" icon="book-open">
    **Definition**: A unit of digital storage equal to 1,073,741,824 bytes (binary); used in Livepeer hardware specifications for RAM, VRAM, and storage requirements.

    **Tags**: `technical:hardware`

    **External**: [Wikipedia](https://en.wikipedia.org/wiki/Gigabyte)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="GeForce" icon="book-open">
    **Definition**: NVIDIA's consumer-grade discrete GPU brand, encompassing the GTX and RTX product lines; the most common GPU family used by Livepeer Orchestrator operators.

    **Tags**: `technical:hardware`

    **External**: [NVIDIA GeForce](https://www.nvidia.com/en-us/geforce/)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="GTX (NVIDIA GTX)" icon="book-open">
    **Definition**: NVIDIA's previous-generation consumer GPU product line; capable of Livepeer video transcoding but lacks the Tensor cores of the RTX series needed for accelerated AI inference.

    **Also known as**: GeForce GTX

    **Tags**: `technical:hardware`

    **External**: [NVIDIA GeForce graphics cards](https://www.nvidia.com/en-us/geforce/graphics-cards/)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="RTX (NVIDIA RTX)" icon="book-open">
    **Definition**: NVIDIA's current consumer GPU product line featuring dedicated Tensor cores that accelerate AI/ML inference workloads; RTX GPUs are well-suited for Livepeer AI pipeline tasks.

    **Also known as**: GeForce RTX

    **Tags**: `technical:hardware`

    **External**: [NVIDIA GeForce graphics cards](https://www.nvidia.com/en-us/geforce/graphics-cards/)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="Self-Hosted" icon="book-open">
    **Definition**: A deployment model in which the operator runs their own infrastructure rather than relying on a managed cloud service; Livepeer Gateways and AI nodes can be self-hosted on any compatible hardware.

    **Tags**: `technical:deployment`

    **External**: [Wikipedia](https://en.wikipedia.org/wiki/Self-hosting_\(web_services\))

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>

  <Accordion title="SLA (Service Level Agreement)" icon="book-open">
    **Definition**: A formal commitment between a service provider and a customer defining expected performance levels, uptime guarantees, and remediation obligations.

    **Tags**: `technical:operations`

    **External**: [Wikipedia](https://en.wikipedia.org/wiki/Service-level_agreement)

    **Status**: current

    **Pages**: `gateways/run-a-gateway/requirements/setup`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Operational Terms

<AccordionGroup>
  <Accordion title="Demand Aggregation" icon="book-open">
    **Definition**: Consolidating requests from multiple users or applications for efficient routing to the Orchestrator network.

    **Context**: Gateways perform demand aggregation by receiving requests from many clients and batching or routing them to Orchestrators, improving utilisation and reducing per-request overhead for each end user.

    **Status**: current

    **Pages**: `gateways/architecture`, `gateways/economics`
  </Accordion>

  <Accordion title="Failover" icon="book-open">
    **Definition**: Automatic switching to a backup Orchestrator when the primary fails or becomes unresponsive during a session.

    **External**: [Failover (Wikipedia)](https://en.wikipedia.org/wiki/Failover)

    **Status**: current

    **Pages**: `gateways/routing`, `gateways/reliability`
  </Accordion>

  <Accordion title="Scaling" icon="book-open">
    **Definition**: Increasing Gateway capacity to handle more concurrent requests, either horizontally (deploying additional Gateway nodes) or vertically (adding resources to an existing node).

    **External**: [Scalability (Wikipedia)](https://en.wikipedia.org/wiki/Scalability)

    **Status**: current

    **Pages**: `gateways/architecture`, `gateways/operations`
  </Accordion>
</AccordionGroup>

<CustomDivider />

<CardGroup cols={3}>
  <Card title="Gateway Docs" icon="house" href="/v2/gateways">
    Full documentation for running and configuring a Livepeer Gateway
  </Card>

  <Card title="Full Glossary" icon="book" href="/v2/resources/glossary">
    All terms across every Livepeer tab
  </Card>

  <Card title="Gateway FAQ" icon="circle-question" href="/v2/gateways/resources/reference/faq">
    Answers to common Gateway setup and operation questions
  </Card>
</CardGroup>