> ## 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 Operators Guide

> Connect Applications with Video & AI services by running your own Gateway! This page gives an overview of the steps to run a Gateway node.

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 Quote = ({children, className = "", style = {}, ...rest}) => {
  const quoteStyle = {
    fontSize: "1rem",
    textAlign: 'center',
    opacity: 1,
    fontStyle: 'italic',
    color: 'var(--lp-color-accent)',
    border: '1px solid var(--lp-color-border-default)',
    borderRadius: "8px",
    padding: "var(--lp-spacing-4)",
    margin: '1rem 0',
    ...style
  };
  return <blockquote className={className} style={quoteStyle} {...rest}>{children}</blockquote>;
};

export const CustomCardTitle = ({icon, title, variant = "card", iconSize, style = {}, className = "", ...rest}) => {
  const variants = {
    card: {
      display: 'flex',
      alignItems: 'center',
      gap: "var(--lp-spacing-2)",
      marginBottom: "var(--lp-spacing-3)",
      color: 'var(--lp-color-text-primary)',
      fontSize: '1rem',
      fontWeight: 600
    },
    accordion: {
      display: 'inline-flex',
      alignItems: 'center',
      gap: "var(--lp-spacing-2)"
    },
    tab: {
      display: 'inline-flex',
      alignItems: 'center',
      gap: '0.4rem',
      fontSize: '0.875rem'
    }
  };
  const sizes = {
    card: 20,
    accordion: 18,
    tab: 14
  };
  const size = iconSize || sizes[variant] || 20;
  const baseStyle = variants[variant] || variants.card;
  return variant === 'card' ? <div className={className} style={{
    ...baseStyle,
    ...style
  }} {...rest}>
      {typeof icon === 'string' ? <Icon icon={icon} size={size} color="var(--lp-color-accent)" /> : icon}
      {title}
    </div> : <span className={className} style={{
    ...baseStyle,
    ...style
  }} {...rest}>
      {typeof icon === 'string' ? <Icon icon={icon} size={size} color="var(--lp-color-accent)" /> : icon}
      {title}
    </span>;
};

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

export const 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 FlexContainer = ({children, direction = "row", gap = "var(--lp-spacing-4)", align = "flex-start", justify = "flex-start", wrap = false, marginTop = "", marginBottom = "", margin = "", padding = "", style = {}, className = "", ...rest}) => {
  return <div className={className} style={{
    display: "flex",
    flexDirection: direction,
    gap: gap,
    alignItems: align,
    justifyContent: justify,
    flexWrap: wrap ? "wrap" : "nowrap",
    ...margin ? {
      margin
    } : {},
    ...padding ? {
      padding
    } : {},
    ...marginTop ? {
      marginTop
    } : {},
    ...marginBottom ? {
      marginBottom
    } : {},
    ...style
  }} {...rest}>
      {children}
    </div>;
};

export const StyledStep = ({title, icon, titleSize = 'h3', iconColor = null, titleColor = null, children, className = '', style = {}, ...rest}) => {
  const styledTitle = titleColor ? <span style={{
    color: titleColor
  }}>{title}</span> : title;
  return <Step title={styledTitle} icon={icon} iconColor={iconColor || undefined} titleSize={titleSize} className={className} style={style} {...rest}>
      {children}
    </Step>;
};

export const StyledSteps = ({children, iconColor, titleColor, lineColor, iconSize = '24px', className = '', style = {}, ...rest}) => {
  const resolvedIconColor = iconColor || 'var(--accent-dark, #18794E)';
  const resolvedTitleColor = titleColor || 'var(--lp-color-accent)';
  const resolvedLineColor = lineColor || 'var(--lp-color-accent)';
  return <div className={['docs-styled-steps', className].filter(Boolean).join(' ')} style={style} {...rest}>
      <style>{`
        .docs-styled-steps .steps > div > div.absolute > div {
          background-color: ${resolvedIconColor};
        }
        .docs-styled-steps .steps > div > div.w-full > p {
          color: ${resolvedTitleColor};
        }
        .docs-styled-steps .steps > div > div.absolute.w-px {
          background-color: ${resolvedLineColor};
        }
        .docs-styled-steps .steps > div:last-child > div.absolute.w-px::after {
          content: '';
          position: absolute;
          bottom: 0;
          left: 50%;
          transform: translateX(-50%);
          width: 6px;
          height: 6px;
          background-color: ${resolvedLineColor};
          transform: translateX(-50%) rotate(45deg);
        }
      `}</style>
      <div>
        <Steps>{children}</Steps>
      </div>
    </div>;
};

export const ScrollableDiagram = ({children, title = '', maxHeight = '500px', minWidth = '100%', showControls = false, className = '', style = {}, ...rest}) => {
  const buildDiagramKey = (currentTitle = '', currentClassName = '') => {
    const source = `${currentTitle}|${currentClassName}|scrollable-diagram`;
    let hash = 0;
    for (let index = 0; index < source.length; index += 1) {
      hash = hash * 31 + source.charCodeAt(index) >>> 0;
    }
    return `docs-diagram-${hash.toString(36)}`;
  };
  const diagramKey = buildDiagramKey(title, className);
  const zoomName = `${diagramKey}-zoom`;
  const zoomLevels = [{
    label: '75%',
    value: 0.75
  }, {
    label: '100%',
    value: 1
  }, {
    label: '125%',
    value: 1.25
  }, {
    label: '150%',
    value: 1.5
  }];
  const containerStyle = {
    overflow: 'auto',
    maxHeight,
    border: '1px solid var(--lp-color-border-default)',
    borderRadius: "8px",
    padding: "var(--lp-spacing-4)",
    background: 'var(--lp-color-bg-card)',
    position: 'relative'
  };
  return <div className={className} style={{
    position: 'relative',
    marginBottom: "var(--lp-spacing-4)",
    ...style
  }} {...rest}>
      {title && <p style={{
    textAlign: 'center',
    fontStyle: 'italic',
    color: 'var(--lp-color-text-secondary)',
    marginBottom: "var(--lp-spacing-2)",
    fontSize: '0.875rem'
  }}>
          {title}
        </p>}

      {showControls ? <style>{`
          [data-docs-diagram-key="${diagramKey}"] [data-docs-diagram-content] {
            transform: scale(1);
            transform-origin: top left;
            width: max-content;
          }
          ${zoomLevels.map(zoomLevel => `
          #${diagramKey}-${zoomLevel.label.replace('%', '')}:checked ~ [data-docs-diagram-shell] [data-docs-diagram-content] {
            transform: scale(${zoomLevel.value});
          }
          #${diagramKey}-${zoomLevel.label.replace('%', '')}:checked ~ [data-docs-diagram-controls] label[for="${diagramKey}-${zoomLevel.label.replace('%', '')}"] {
            background: var(--lp-color-accent);
            color: var(--lp-color-on-accent);
            border-color: var(--lp-color-accent);
          }`).join('\n')}
        `}</style> : null}

      {showControls ? zoomLevels.map(zoomLevel => {
    const inputId = `${diagramKey}-${zoomLevel.label.replace('%', '')}`;
    return <input key={inputId} id={inputId} type="radio" name={zoomName} defaultChecked={zoomLevel.value === 1} style={{
      position: 'absolute',
      opacity: 0,
      pointerEvents: 'none'
    }} />;
  }) : null}

      <div data-docs-diagram-key={diagramKey} data-docs-diagram-shell style={containerStyle}>
        <div data-docs-diagram-content style={{
    minWidth,
    transformOrigin: 'top left',
    width: 'max-content'
  }}>
          {children}
        </div>
      </div>

      {showControls ? <div data-docs-diagram-controls style={{
    display: 'flex',
    justifyContent: 'flex-end',
    alignItems: 'center',
    gap: "var(--lp-spacing-2)",
    marginTop: "var(--lp-spacing-2)",
    flexWrap: 'wrap'
  }}>
          <span style={{
    fontSize: "0.75rem",
    color: 'var(--lp-color-text-muted)',
    marginRight: 'auto'
  }}>
            Scroll to pan
          </span>
          {zoomLevels.map(zoomLevel => {
    const inputId = `${diagramKey}-${zoomLevel.label.replace('%', '')}`;
    return <label key={inputId} htmlFor={inputId} style={{
      background: 'transparent',
      color: 'var(--lp-color-text-secondary)',
      border: '1px solid var(--lp-color-border-default)',
      borderRadius: "4px",
      padding: '4px 10px',
      cursor: 'pointer',
      fontSize: "0.75rem",
      fontWeight: '600'
    }}>
                {zoomLevel.label}
              </label>;
  })}
        </div> : null}
    </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>;
};

export const GotoLink = ({label, relativePath, text = '', icon = 'arrow-turn-down-right', className = '', style = {}, ...rest}) => {
  return <span className={className} style={{
    display: 'inline-flex',
    alignItems: 'center',
    ...style
  }} {...rest}>
      <span style={{
    marginRight: 8
  }}>{text}</span>
      <Icon icon={icon} aria-hidden="true" />
      <a href={relativePath} style={{
    marginLeft: 6
  }}>
        {label}
      </a>
    </span>;
};

<CenteredContainer maxWidth="fit-content" margin="0 auto 2rem auto">
  <Card title={<CustomCardTitle icon="github" title="Go-Livepeer" style={{margin: "0 0.5rem -0.2rem 0"}} />} href="https://github.com/livepeer/go-livepeer" />
</CenteredContainer>

<Quote>
  Gateways are essential infrastructure in the Livepeer Network. They
  provide the service coordination layer (routing & verification) that connects applications
  to the decentralised GPU compute layer (DePIN). The requirements,
  setup steps, and best practices for running a Gateway node.
</Quote>

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

## Deployment

A **deployment** is the complete configuration of a Livepeer Gateway, defined by three independent choices: operational mode, setup type, and node type.

This guide will walk through deployment of a Gateway using `go-livepeer` and cover both on-chain and off-chain modes using Docker, Windows & Linux OS environments with node configurations for video, AI, and dual workloads.

<AccordionGroup>
  <Accordion title={<span> Setup Type: <Icon icon="github" size={18} /> <LinkArrow label="go-livepeer" href="https://github.com/livepeer/go-livepeer" newline={false} /> </span>}>
    ## Setup Type: `go-livepeer`

    The setup type determines what software you run and how you install it.
    The reference setup type is running the `go-livepeer` Gateway software, whichcan be installed via source binary or Docker and is the recommended setup for most users as it provides the most features, stability, and compatibility with the Livepeer Network.

    For alternative setup types see the [Gateway Setup Options](../guides/deployment-details/setup-options) page, which covers using the Livepeer SDK, running a Gateway with a GWID, and using hosted Gateway services.
  </Accordion>

  <Accordion title={<span> Operating System: <Icon icon="docker" size={18} /> Docker, <Icon icon="linux" size={18} /> Linux, <Icon icon="windows" size={18} /> Windows </span>}>
    ## Operating System: Docker, Linux, Windows

    You can run a Livepeer Gateway on either Linux or Windows, but Linux is recommended for production deployments due to better performance, stability, and compatibility with GPU drivers and containerization tools. Windows is suitable for development and testing.

    <StyledTable variant="bordered">
      <thead>
        <TableRow header>
          <TableCell header>Operating System</TableCell>
          <TableCell header>Pros</TableCell>
          <TableCell header>Cons</TableCell>
        </TableRow>
      </thead>

      <tbody>
        <TableRow>
          <TableCell>**Linux**</TableCell>
          <TableCell>- Better performance and stability<br />- Native support for NVIDIA drivers and Docker<br />- More widely used in production environments</TableCell>
          <TableCell>- Steeper learning curve for users familiar with Windows<br />- Requires command-line interaction for setup and management</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>**Windows**</TableCell>
          <TableCell>- Easier setup for users familiar with Windows<br />- Suitable for development and testing</TableCell>
          <TableCell>- Potential performance issues with GPU workloads<br />- Limited support for containerization tools like Docker<br />- Not recommended for production deployments</TableCell>
        </TableRow>
      </tbody>
    </StyledTable>
  </Accordion>

  <Accordion title={<span> Operational Modes: <Icon icon="link" size={18} /> <strong>On-chain</strong>, <Icon icon="floppy-disk" size={18} /> <strong>Off-chain</strong> </span>}>
    ## Operational Modes

    The operational mode determines how your Gateway integrates with the Livepeer Protocol.
    You can run a Gateway both independently: <Icon icon="floppy-disk" size={18} /> <strong>Off-chain</strong> or connected to the blockchain-based Livepeer Network: <Icon icon="link" size={18} /> <strong>On-chain</strong>.

    <Icon icon="floppy-disk" size={18} /> Off-chain

    * Run a Gateway that operates independently of the blockchain. This is ideal for testing, development, and private deployments. Off-chain Gateways do not interact with the blockchain for Orchestrator discovery or payment settlement - they rely on manual configuration and external payment mechanisms.

    <Icon icon="link" size={18} /> On-chain

    * Run a Gateway that is fully connected to the blockchain-based Livepeer Network (on Arbitrum). On-chain Gateways interact with the blockchain for Orchestrator discovery, payment settlement, and ETH management.
  </Accordion>

  <Accordion title={<span> Node Types: <Badge color="blue"> Video </Badge> <Badge color="purple"> AI </Badge> <Badge color="green"> Dual </Badge> </span>}>
    ## Node Types

    The node type determines the workloads your Gateway can route.
    You can run a Gateway in the following node configurations:

    * <Badge color="blue"> Video Only </Badge> -> traditional transcoding services
    * <Badge color="purple"> AI Only </Badge> -> AI inference services
    * <Badge color="green"> Dual: AI & Video </Badge> -> both video transcoding and AI
      inference services
  </Accordion>
</AccordionGroup>

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

## Gateway Operator Journey

<Columns cols={2}>
  <FlexContainer justify="center">
    <Mermaid
      chart={`%%{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 TB
  subgraph check["Check"]
      A["Check network & hardware requirements"]
  end

  subgraph install["Install"]
      B["Install go-livepeer on your OS"]
  end

  subgraph configure["Configure"]
      C1["Configure AI, transcoding, or both"]
      C2["Configure pricing, funding, & regions"]
  end

  subgraph test["Test"]
      D["Test & troubleshoot"]
  end

  subgraph connect["Connect"]
      E1["Connect with orchestrators"]
      E2["Route jobs"]
  end

  subgraph monitor["Monitor"]
      F["Monitor & optimise"]
  end

  A --> B
  B --> C1
  C1 --> C2
  C2 --> D
  D --> E1
  E1 --> E2
  E2 --> F

  classDef default fill:#1a1a1a,color:#fff,stroke:#2d9a67,stroke-width:2px`}
    />
  </FlexContainer>

  <FlexContainer justify="center" marginTop="-2.5rem">
    <StyledSteps>
      <StyledStep title="Check Requirements">
        Check hardware, network, and software requirements. <br />

        <GotoLink label="Requirements" relativePath="./prepare" />
      </StyledStep>

      <StyledStep title="Install Gateway">
        Install the Livepeer Gateway software. <br />

        <GotoLink label="Installation Guide" relativePath="./install" />
      </StyledStep>

      <StyledStep title="Configure Gateway">
        Configure transcoding options, models, pipelines & pricing <br />

        <GotoLink label="Configuration Guide" relativePath="./configure" />
      </StyledStep>

      <StyledStep title="Test Gatway">
        Price & publish offerings to the Marketplace. <br />

        <GotoLink label="Testing Guide" relativePath="./test" />
      </StyledStep>

      <StyledStep title="Connect Gatway">
        Connect with Orchestrators, price & route offerings in the Marketplace. <br />

        <GotoLink label="Connect to the Livepeer Network" relativePath="./connect" />
      </StyledStep>

      <StyledStep title="Monitor & Optimise">
        Monitor performance, optimise routing & service quality. <br />

        <GotoLink label="Monitor & Optimise your Gateway" relativePath="./monitor" />
      </StyledStep>
    </StyledSteps>
  </FlexContainer>
</Columns>

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

## Gateway Architecture

<ScrollableDiagram title="Dual Gateway Architecture: Video & AI Pipelines" maxHeight="600px">
  ```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
      subgraph INPUT["Input Sources"]
          CAM["Camera / RTMP / WebRTC"]
          VID["Video File"]
          AIIN["AI Prompt / Model Request"]
      end

      GATEWAY["Gateway Node<br/>• Ingest (RTMP/HTTP/WebRTC)<br/>• Segment video<br/>• Queue + order jobs<br/>• AI pipeline routing<br/>• Orchestrator selection<br/>• Verification & receipts"]

      CAM -->|"Live stream"| GATEWAY
      VID -->|"VOD upload"| GATEWAY
      AIIN -->|"AI job request"| GATEWAY

      subgraph JOBS["Workflows"]
          VJ["Video Transcoding Job"]
          AIJ["AI Inference Job<br/>(Daydream / ComfyStream / BYOC)"]
      end

      GATEWAY --> VJ
      GATEWAY --> AIJ

      subgraph ORCH["Orchestrator Network (GPU Operators)"]
          O1["Orchestrator A<br/>GPU Pool"]
          O2["Orchestrator B<br/>GPU Pool"]
          O3["Orchestrator C<br/>GPU Pool"]
      end

      VJ -->|"Transcode segments"| O1
      VJ --> O2
      AIJ -->|"Run model / inference"| O1
      AIJ --> O3

      subgraph OUTPUTS["Outputs"]
          HLS["Adaptive Bitrate Video (HLS/LL-HLS)"]
          AIOUT["AI Frames / Stylized Video"]
      end

      O1 --> GATEWAY
      O2 --> GATEWAY
      O3 --> GATEWAY

      GATEWAY --> HLS
      GATEWAY --> AIOUT

      ETH[("Arbitrum Blockchain<br/>Payments • Tickets • Rewards")]
      GATEWAY --> ETH
      O1 --> ETH
      O2 --> ETH
      O3 --> ETH

      classDef default fill:#1a1a1a,color:#fff,stroke:#2d9a67,stroke-width:2px
      style INPUT fill:#0d0d0d,stroke:#2d9a67,stroke-width:1px
      style JOBS fill:#0d0d0d,stroke:#2d9a67,stroke-width:1px
      style ORCH fill:#0d0d0d,stroke:#2d9a67,stroke-width:1px
      style OUTPUTS fill:#0d0d0d,stroke:#2d9a67,stroke-width:1px

  ```
</ScrollableDiagram>

## Related Pages

<Columns cols={2}>
  <Card title={<CustomCardTitle icon="cogs" title="Setup Options" />} href="/v2/gateways/guides/deployment-details/setup-options" horizontal arrow>
    Alternative setup options for running a Gateway using the Livepeer SDK, GWID, or hosted services.

    <GotoLink label="Explore Gateway Setup Options" relativePath="../guides/deployment-details/setup-options" />
  </Card>

  <Card title={<CustomCardTitle icon="file-code" title="Gateway Tutorials" />} href="/v2/gateways/guides/tutorials/tutorials-resources" horizontal arrow>
    Looking for hands-on walkthroughs to run your first Gateway and test it end to end?

    <GotoLink label="Browse Gateway Tutorials" relativePath="../guides/tutorials/tutorials-resources" />
  </Card>

  <Card title={<CustomCardTitle icon="hand-holding-dollar" title="Gateway Economics" />} href="/v2/gateways/concepts/business-model" horizontal arrow>
    Looking for information on how Gateways earn fees for services?

    <GotoLink label="Read the 'Gateway Economics' section" relativePath="../concepts/business-model" />
  </Card>

  <Card title={<CustomCardTitle icon="chart-line" title="AI Pipelines" />} href="/v2/gateways/guides/node-pipelines/ai-pipelines" horizontal arrow>
    Want to learn more about running AI workloads on Livepeer Gateways?

    <GotoLink label="Learn about AI Pipelines" relativePath="../guides/node-pipelines/ai-pipelines" />
  </Card>
</Columns>