> ## 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 Business Model

> How gateways earn money, what they pay, the payment flow between applications, gateways, and orchestrators, and the four operator models.

export const CenteredContainer = ({children, maxWidth = "800px", padding = "0", preset = "default", width = "", minWidth = "", marginRight = "", marginBottom = "", textAlign = "", style = {}, className = "", ...rest}) => {
  const presets = {
    default: {},
    fitContent: {
      width: "fit-content",
      minWidth: "fit-content"
    },
    readable70: {
      width: "70%",
      minWidth: "fit-content"
    },
    readable80: {
      width: "80%",
      minWidth: "fit-content"
    },
    readable90: {
      width: "90%"
    },
    wide900: {
      maxWidth: "900px"
    }
  };
  const presetStyle = presets[preset] || presets.default;
  return <div className={className} style={{
    maxWidth: presetStyle.maxWidth || maxWidth,
    margin: "0 auto",
    padding: padding,
    ...presetStyle.width ? {
      width: presetStyle.width
    } : {},
    ...presetStyle.minWidth ? {
      minWidth: presetStyle.minWidth
    } : {},
    ...width ? {
      width
    } : {},
    ...minWidth ? {
      minWidth
    } : {},
    ...marginRight ? {
      marginRight
    } : {},
    ...marginBottom ? {
      marginBottom
    } : {},
    ...textAlign ? {
      textAlign
    } : {},
    ...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 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>;
};

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>;
};

<CenteredContainer maxWidth="960px">
  <Tip>Gateways are application service routers that earn at the business layer. You control customer pricing while the protocol sets the network-side cost of routed work.</Tip>
</CenteredContainer>

<CustomDivider />

## Payments Flow

Gateways are **consumers** of compute services. They pay Orchestrators to do work on behalf of their application customers.

```mermaid theme={"theme":{"light":"github-light","dark":"dark-plus"}}
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#18794E', 'primaryTextColor': '#fff', 'primaryBorderColor': '#3CB540', 'lineColor': '#3CB540', 'mainBkg': '#18794E', 'nodeBorder': '#3CB540', 'clusterBkg': 'transparent', 'clusterBorder': '#3CB540', 'titleColor': '#3CB540', 'edgeLabelBackground': 'transparent', 'textColor': '#3CB540', 'nodeTextColor': '#fff'}}}%%
flowchart LR
    A["End users /<br/>Applications"] -->|"Pay gateway's rate<br/>(business layer)"| B["Gateway"]
    B -->|"Pay network rate<br/>(ETH payment tickets)"| C["Orchestrator"]
    C -->|"Pay workers"| D["Transcoder /<br/>AI Runner"]
    C -->|"Redeem tickets"| E["Arbitrum<br/>(on-chain)"]

    B -.->|"Keep margin"| F["Gateway revenue"]

    classDef default fill:#1a1a1a,color:#fff,stroke:#2d9a67,stroke-width:2px
```

The payment chain:

1. **End users pay the Gateway** at the operator's application-layer rate
2. **The Gateway pays Orchestrators** via probabilistic micropayment tickets (ETH on Arbitrum)
3. **Orchestrators pay their workers** (transcoders, AI runners) and redeem winning tickets on-chain
4. **The Gateway keeps the difference** between what customers pay and what Orchestrators charge

<CustomDivider />

## Gateway Earnings

Gateway earnings come from business-layer margins. Gateways buy network services instead of earning protocol rewards.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Participant</TableCell>
      <TableCell header>Earns at protocol level?</TableCell>
      <TableCell header>How</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Orchestrator**</TableCell>
      <TableCell>Yes</TableCell>
      <TableCell>LPT rewards (staking) + ETH fees (payment tickets from Gateways)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Transcoder / AI Worker**</TableCell>
      <TableCell>Yes</TableCell>
      <TableCell>Paid by Orchestrators for GPU compute work</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Redeemer**</TableCell>
      <TableCell>Yes</TableCell>
      <TableCell>Fees for redeeming winning payment tickets on-chain</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Gateway**</TableCell>
      <TableCell>**No**</TableCell>
      <TableCell>Pays for services (earns at business layer only)</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider />

## Gateway Costs

Gateway costs are determined by the work you route and the Orchestrator prices on the network.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Cost type</TableCell>
      <TableCell header>Pricing unit</TableCell>
      <TableCell header>Description</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Video transcoding**</TableCell>
      <TableCell>Wei per pixel per segment</TableCell>
      <TableCell>Width x height x frames of output video</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**AI inference**</TableCell>
      <TableCell>Wei per pixel or per millisecond</TableCell>
      <TableCell>Varies by pipeline (image = per pixel, audio = per ms)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Real-time AI**</TableCell>
      <TableCell>Interval-based</TableCell>
      <TableCell>Payments during the duration of a live stream</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

### Currency

Gateways pay Orchestrators in **ETH** on Arbitrum. LPT remains the staking, governance, and reward token for Orchestrators and Delegators.

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Currency</TableCell>
      <TableCell header>Purpose</TableCell>
      <TableCell header>Used by</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**ETH / Wei**</TableCell>
      <TableCell>Service payments (transcoding, AI)</TableCell>
      <TableCell>Gateways pay Orchestrators</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**LPT**</TableCell>
      <TableCell>Staking, governance, rewards</TableCell>
      <TableCell>Orchestrators, Delegators</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

ETH handles service payments while LPT handles protocol governance and staking. This keeps service costs denominated in a stable currency while LPT serves its governance function.

<CustomDivider />

## Gateway Operator Models

Four operator models show how Gateways earn at the **business layer**:

<AccordionGroup>
  <Accordion title="Self-hosted gateway (cost savings)" icon="server">
    Running your own Gateway removes a third-party routing fee. If you are already building an application on Livepeer, self-hosting keeps that margin inside your stack.

    **Who:** App developers scaling past hosted APIs (Daydream, Livepeer.Cloud)

    **Revenue model:** Cost reduction. You keep the margin that a third-party Gateway would otherwise charge.
  </Accordion>

  <Accordion title="Service provider (arbitrage)" icon="store">
    Charge end users more than you pay Orchestrators. The difference is your margin. This is the classic Gateway business model.

    **Who:** Livepeer.Cloud SPE, LLM SPE, Streamplace

    **Revenue model:** Per-request, per-minute, or subscription pricing to customers. Pay Orchestrators at network rates.
  </Accordion>

  <Accordion title="Platform builder (NaaP)" icon="building">
    Build a full platform on top of the Gateway layer - API key management, multi-tenancy, billing, SLA monitoring, Orchestrator tiering.

    **Who:** NaaP (Network as a Platform), enterprise integrators

    **Revenue model:** SaaS pricing with usage-based billing. The Gateway is the infrastructure layer of a larger product.
  </Accordion>

  <Accordion title="Content provider (SLA control)" icon="video">
    Run a Gateway to ensure SLA guarantees on your Orchestrators. Control Orchestrator selection, failover, and pricing for your specific content.

    **Who:** Streaming platforms, media companies, live event producers

    **Revenue model:** The Gateway supports the core business through stronger SLA control and workload routing.
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Pricing and Fees

As a Gateway operator, you set pricing at two levels:

### Protocol-level costs (what you pay)

You control your maximum cost per job using CLI flags:

```bash icon="terminal" title="gateway cost limits" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
# Maximum you'll pay per pixel for transcoding
-maxPricePerUnit=1000

# Maximum you'll pay per AI capability/model
-maxPricePerCapability='{"capabilities_prices": [{"pipeline": "text-to-image", "model_id": "stabilityai/sd-turbo", "price_per_unit": 1000}]}'
```

These flags set an upper bound. The Gateway will only route to Orchestrators whose prices are at or below your maximum. Lower maximums mean fewer available Orchestrators; higher maximums mean more options but higher costs.

### Business Layer Pricing

Your fees to end users are set entirely at the application layer, outside the Livepeer Protocol. Common approaches:

1. **Per-request pricing** - charge per API call to your Gateway
2. **Usage-based pricing** - charge per minute of video or per AI generation
3. **Subscription models** - monthly fees for access to your Gateway services

```go icon="terminal" title="application pricing example" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
// Your application code (not in Livepeer protocol)
func calculateUserPrice(requestType string, pixels int64) float64 {
    basePrice := getYourBusinessPrice(requestType)
    yourCost := getOrchestratorCost(pixels)
    profitMargin := 0.20 // 20% margin

    return basePrice + yourCost*profitMargin
}
```

### Price Discovery

Use the CLI to discover current Orchestrator market rates:

```bash icon="terminal" title="livepeer_cli price discovery" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
livepeer_cli
# Select "Set broadcast config" to see current market rates
# Then set your max prices accordingly
```

Your margin = what customers pay you - what you pay Orchestrators.

<CustomDivider />

## Production Gateways

**[Streamplace](/v2/solutions/streamplace/overview)** operates a Gateway providing video processing services to content creators. Creators pay Streamplace; Streamplace pays Orchestrators. The margin is Streamplace's revenue.

**[Daydream](/v2/solutions/Daydream/overview)** operates a Gateway providing AI video processing. Builders and creators pay Daydream; Daydream pays Orchestrators. The margin is Daydream's revenue.

Both demonstrate the arbitrage model: the Gateway sits between application demand and network supply, adding value through routing quality, developer experience, and service reliability.

<CustomDivider />

## Related Pages

<CardGroup cols={2}>
  <Card title="Gateway Role" icon="user-gear" href="/v2/gateways/concepts/role" arrow horizontal>
    What Gateways are and how the role has evolved.
  </Card>

  <Card title="Gateway Capabilities" icon="gears" href="/v2/gateways/concepts/capabilities" arrow horizontal>
    Workload types, Orchestrator selection, and session management.
  </Card>

  <Card title="Payment System" icon="credit-card" href="/v2/gateways/guides/payments-and-pricing/payment-guide" arrow horizontal>
    How Probabilistic Micropayments work.
  </Card>

  <Card title="Orchestrator Incentives" icon="coins" href="/v2/orchestrators/concepts/incentive-model" arrow horizontal>
    How the supply side (Orchestrators) earns - for comparison.
  </Card>
</CardGroup>