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

# Find your build path

> Choose your build track on Livepeer: AI inference, real-time video AI, video streaming, custom containers, or OSS contribution.

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 preset="readable90">
  <Tip>Livepeer has four distinct build paths. Each uses different tools, authentication, and infrastructure. Choosing the wrong path early costs time; read the decision table first.</Tip>
</CenteredContainer>

<CustomDivider />

Livepeer supports AI inference, real-time AI video, video transcoding, custom containerised models, and protocol-level contribution. These paths share infrastructure but have different APIs, SDKs, and architectural requirements.

<CustomDivider />

## Choose a build track

<AccordionGroup>
  <Accordion title="Call AI inference from my application" icon="bolt">
    **Path: AI Gateway API**

    Send REST requests to a Livepeer Gateway and receive processed outputs. No GPU required. The Gateway handles routing to network Orchestrators.

    Nine batch pipelines are available: text-to-image, image-to-image, image-to-video, image-to-text, audio-to-text, text-to-speech, upscale, segment-anything-2, and LLM.

    ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
    curl -X POST https://dream-gateway.livepeer.cloud/text-to-image \
      -H "Content-Type: application/json" \
      -d '{"prompt": "a glowing neural network in a dark room", "model_id": "SG161222/RealVisXL_V4.0_Lightning"}'
    ```

    The community Gateway at `dream-gateway.livepeer.cloud` accepts unauthenticated requests for development. Production applications use a self-hosted Gateway or a Gateway provider with an API key.

    <LinkArrow href="/v2/developers/build/ai-and-agents/ai-jobs-direct-quickstart" label="AI quickstart: first call in 10 minutes" />
  </Accordion>

  <Accordion title="Build real-time AI video (live webcam or stream effects)" icon="video">
    **Path: ComfyStream**

    ComfyStream applies ComfyUI workflows to live video streams at up to 25 FPS on an NVIDIA RTX 4090. Build your pipeline as a ComfyUI workflow JSON file; ComfyStream handles WebRTC transport and frame processing.

    Requirements: NVIDIA GPU (RTX 3090 or better), ComfyUI, Python 3.12, CUDA 12.5+.

    Supported models: StreamDiffusion, ControlNet, IPAdapter, FaceID, LoRA, Whisper (audio), Gemma (video understanding), SuperResolution.

    <LinkArrow href="/v2/developers/build/ai-and-agents/realtime-ai/comfystream/comfystream-quickstart" label="ComfyStream quickstart" />
  </Accordion>

  <Accordion title="Deploy a custom AI model or container" icon="box">
    **Path: BYOC (Bring Your Own Container)**

    Package your model in Docker, implement PyTrickle's `FrameProcessor` interface, and register the container as a worker on the Livepeer Network. Your container receives and publishes live video frames over the trickle streaming protocol.

    Requirements: Docker on Linux with NVIDIA GPU, Python model code (PyTorch recommended).

    BYOC reached production-grade in Phase 4 (January 2026). Embody SPE and Streamplace run production BYOC workloads on the network.

    <LinkArrow href="/v2/developers/build/compute/byoc/overview" label="BYOC guide" />
  </Accordion>

  <Accordion title="Integrate video transcoding or streaming" icon="film">
    **Path: Video API**

    The Livepeer REST API and SDKs manage the full lifecycle of livestreams and VOD assets: create streams, get ingest URLs, transcode assets, manage playback, and set access control.

    SDKs: `npm install livepeer` / `pip install livepeer` / `go get github.com/livepeer/livepeer-go`

    <LinkArrow href="/v2/developers/build/video/overview" label="Video quickstart" />
  </Accordion>

  <Accordion title="Contribute to the Livepeer protocol codebase" icon="code">
    **Path: OSS contribution**

    Four primary repositories: go-livepeer (protocol node, Go), ai-runner (AI inference runtime, Python), ComfyStream (real-time AI video, Python), protocol (Solidity contracts).

    Requirements: Go 1.21+ for go-livepeer; Python 3.12 for ComfyStream and PyTrickle; local testnet for integration testing.

    <LinkArrow href="/v2/developers/resources/contributing" label="Contributor quickstart" />
  </Accordion>

  <Accordion title="Evaluate Livepeer for my use case" icon="magnifying-glass">
    **Path: Evaluation**

    Use the infrastructure stack concept page for the access layers, then the AI pipelines page to match your use case to a path.

    Key distinctions:

    * Batch vs real-time AI: different APIs, latency targets, and infrastructure requirements
    * Managed Gateway vs self-hosted: managed is simpler; self-hosted controls cost at scale
    * Standard pipelines vs custom model: BYOC for custom architectures; Gateway API for the nine supported pipeline types

    <LinkArrow href="/v2/developers/concepts/infra-stack" label="Infrastructure stack" /> then <LinkArrow href="/v2/developers/build/ai-and-agents/ai-pipelines" label="AI pipelines" newline={false} />
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Build path reference

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Intent</TableCell>
      <TableCell header>Path</TableCell>
      <TableCell header>SDK / tool</TableCell>
      <TableCell header>Auth</TableCell>
      <TableCell header>GPU required</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>**Batch AI inference**</TableCell>
      <TableCell>AI Gateway API</TableCell>
      <TableCell>`livepeer` npm/pip, `@livepeer/ai`, REST</TableCell>
      <TableCell>API key (Gateway provider) or unauthenticated (community Gateway)</TableCell>
      <TableCell>No</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Real-time AI video**</TableCell>
      <TableCell>ComfyStream</TableCell>
      <TableCell>ComfyUI + ComfyStream node</TableCell>
      <TableCell>Gateway URL + API key</TableCell>
      <TableCell>Yes (NVIDIA)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Custom AI model**</TableCell>
      <TableCell>BYOC</TableCell>
      <TableCell>PyTrickle, Docker, `@muxionlabs/byoc-sdk`</TableCell>
      <TableCell>Orchestrator registration</TableCell>
      <TableCell>Yes (NVIDIA)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Video streaming / transcoding**</TableCell>
      <TableCell>Video API</TableCell>
      <TableCell>`livepeer` npm/pip/go, `@livepeer/react`</TableCell>
      <TableCell>API key (bearer token)</TableCell>
      <TableCell>No</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Protocol contribution**</TableCell>
      <TableCell>OSS / go-livepeer</TableCell>
      <TableCell>Go, Python, local testnet</TableCell>
      <TableCell>N/A</TableCell>
      <TableCell>Optional</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>**Self-hosted Gateway**</TableCell>
      <TableCell>Gateways tab</TableCell>
      <TableCell>go-livepeer, ETH deposit on Arbitrum One</TableCell>
      <TableCell>On-chain or off-chain payment mode</TableCell>
      <TableCell>No</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

Most developers start with the AI Gateway API path. It requires no GPU, no deposit, and produces a working inference call in under ten minutes. Move to ComfyStream or BYOC when you need real-time processing or a model architecture outside the nine standard pipelines.

<CustomDivider />

## Related pages

<CardGroup cols={3}>
  <Card title="Concepts" icon="lightbulb" href="/v2/developers/concepts/infra-stack">
    The developer stack, AI pipelines, video infrastructure, and the OSS codebase.
  </Card>

  <Card title="AI quickstart" icon="fast-forward" href="/v2/developers/build/ai-and-agents/ai-jobs-direct-quickstart">
    First AI inference call in 10 minutes. No GPU required.
  </Card>

  <Card title="AI pipelines" icon="robot" href="/v2/developers/build/ai-and-agents/ai-pipelines">
    All nine batch pipeline types with request schemas and curl examples.
  </Card>
</CardGroup>