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

# Pipeline Configuration

> Post-setup tuning for Livepeer gateway pipelines - video transcoding profiles (JSON encoding ladder, presets, recipes) and AI inference tuning (retry timeouts, model selection, warm vs cold behaviour).

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 BorderedBox = ({children, variant = "default", padding = "var(--lp-spacing-4)", borderRadius = "var(--lp-spacing-px-8)", margin = "", accentBar = "", style = {}, className = "", ...rest}) => {
  const variants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    accent: {
      border: "1px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    muted: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "transparent"
    }
  };
  const accentBarColors = {
    accent: "var(--lp-color-accent)",
    positive: "var(--green-9)"
  };
  return <div data-docs-bordered-box="" data-accent-bar={accentBarColors[accentBar] ? "" : undefined} className={className} style={{
    ...variants[variant],
    padding: padding,
    borderRadius: borderRadius,
    ...margin ? {
      margin
    } : {},
    ...accentBarColors[accentBar] ? {
      position: "relative",
      '--accent-bar-color': accentBarColors[accentBar]
    } : {},
    ...style
  }} {...rest}>
      {children}
    </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>;
};

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

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

<CenteredContainer preset="readable80">
  post-setup tuning mechanisms for video and AI pipelines.

  * Video tuning centres on the transcoding profile (output renditions).
  * AI tuning centres on retry behaviour, model selection, and inference parameters.

  <br />

  *Quick Reference*

  <Tabs>
    <Tab title="Video tuning" icon="video">
      <StyledTable headers={["Flag", "What it controls"]}>
        <TableRow>
          <TableCell>`-transcodingOptions`</TableCell>
          <TableCell>Encoding ladder (output renditions, bitrate, codec, GOP)</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-maxPricePerUnit`</TableCell>
          <TableCell>Per-pixel price cap for Orchestrator selection</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-maxSessions`</TableCell>
          <TableCell>Concurrent stream limit (default: 10)</TableCell>
        </TableRow>
      </StyledTable>
    </Tab>

    <Tab title="AI tuning" icon="brain">
      <StyledTable headers={["Flag", "What it controls"]}>
        <TableRow>
          <TableCell>`-httpIngest`</TableCell>
          <TableCell>Enables AI pipeline endpoints on the HTTP port (required)</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-aiProcessingRetryTimeout`</TableCell>
          <TableCell>Failover speed when an Orchestrator is slow or unresponsive</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-maxPricePerCapability`</TableCell>
          <TableCell>Per-pipeline, per-model price cap</TableCell>
        </TableRow>
      </StyledTable>
    </Tab>
  </Tabs>
</CenteredContainer>

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

## Configuration Details

<BorderedBox variant="accent">
  <Tabs>
    <Tab title="Video" icon="video">
      ## Video Transcoding Tuning

      Pass a profile to the Gateway via the `-transcodingOptions` flag, either as a comma-separated list of built-in presets or as a path to a JSON file.

      ### Built-in Presets

      The simplest option. Presets follow the pattern `P<height>p<fps>fps<aspect>`:

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      -transcodingOptions P240p30fps16x9,P360p30fps16x9,P720p30fps16x9
      ```

      Use built-in presets for development or when the defaults match your use case. For production, a JSON profile gives you control over bitrate, codec, and GOP size.

      ### JSON Format

      Create a `transcodingOptions.json` file and reference it with `-transcodingOptions /path/to/transcodingOptions.json`.

      ```json icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      [
      {
          "name": "1080p",
          "width": 1920,
          "height": 1080,
          "bitrate": 6500000,
          "fps": 0,
          "profile": "h264constrainedhigh",
          "gop": "1"
      },
      {
          "name": "720p",
          "width": 1280,
          "height": 720,
          "bitrate": 3000000,
          "fps": 0,
          "profile": "h264constrainedhigh",
          "gop": "1"
      },
      {
          "name": "480p",
          "width": 854,
          "height": 480,
          "bitrate": 1600000,
          "fps": 0,
          "profile": "h264constrainedhigh",
          "gop": "1"
      },
      {
          "name": "240p",
          "width": 426,
          "height": 240,
          "bitrate": 600000,
          "fps": 0,
          "profile": "h264constrainedhigh",
          "gop": "1"
      }
      ]
      ```

      **Field reference:**

      <StyledTable headers={["Field", "Required", "Notes"]}>
        <TableRow>
          <TableCell>`width`</TableCell>
          <TableCell>Yes</TableCell>
          <TableCell>Output width in pixels</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`height`</TableCell>
          <TableCell>Yes</TableCell>
          <TableCell>Output height in pixels</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`bitrate`</TableCell>
          <TableCell>Yes</TableCell>
          <TableCell>Output bitrate in bits per second</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`name`</TableCell>
          <TableCell>No</TableCell>
          <TableCell>Human-readable label, used in HLS manifest</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`fps`</TableCell>
          <TableCell>No</TableCell>
          <TableCell>Target frames per second; `0` preserves source FPS</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`profile`</TableCell>
          <TableCell>No</TableCell>
          <TableCell>H.264 profile: `h264constrainedhigh`, `h264high`, `h264main`, `h264baseline`</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`gop`</TableCell>
          <TableCell>No</TableCell>
          <TableCell>GOP size in seconds or `"intra"` for keyframe-only; lower values reduce latency</TableCell>
        </TableRow>
      </StyledTable>

      ### Per-platform Setup

      <AccordionGroup>
        <Accordion title="Docker" icon="docker">
          Mount the JSON file as a volume and reference it via a path inside the container:

          ```yaml icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          # docker-compose.yml
          services:
          gateway:
              image: livepeer/go-livepeer:master
              volumes:
              - ./transcodingOptions.json:/config/transcodingOptions.json
              - gateway-data:/root/.lpData
              command: |
              -gateway
              -transcodingOptions /config/transcodingOptions.json
              -rtmpAddr 0.0.0.0:1935
              -httpAddr 0.0.0.0:8935
              -orchAddr https://orch1.example.com:8935
          ```

          Alternatively, write directly to the Gateway's data volume:

          ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          nano /var/lib/docker/volumes/gateway-lpData/_data/transcodingOptions.json
          ```

          And reference it at the container path:

          ```icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          -transcodingOptions /root/.lpData/transcodingOptions.json
          ```
        </Accordion>

        <Accordion title="Linux (systemd)" icon="linux">
          Create the profile file in your chosen config directory:

          ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          sudo nano /usr/local/bin/lptConfig/transcodingOptions.json
          ```

          Reference it in your systemd service file (`/etc/systemd/system/livepeer.service`):

          ```ini icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          ExecStart=/usr/local/bin/livepeer \
          -gateway \
          -transcodingOptions /usr/local/bin/lptConfig/transcodingOptions.json \
          -rtmpAddr 0.0.0.0:1935 \
          -httpAddr 0.0.0.0:8935
          ```

          Reload systemd after any service file change:

          ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          sudo systemctl daemon-reload && sudo systemctl restart livepeer
          ```
        </Accordion>

        <Accordion title="Windows" icon="windows">
          Create the profile file in the `.lpData` directory:

          ```icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          C:\Users\%USERNAME%\.lpData\transcodingOptions.json
          ```

          Reference it in your startup `.bat` file:

          ```bat icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          livepeer.exe ^
          -gateway ^
          -transcodingOptions C:\Users\%USERNAME%\.lpData\transcodingOptions.json ^
          -rtmpAddr 0.0.0.0:1935 ^
          -httpAddr 0.0.0.0:8935
          ```
        </Accordion>
      </AccordionGroup>

      ### Profile Recipes

      <AccordionGroup>
        <Accordion title="Standard adaptive bitrate ladder (recommended)" icon="layer-group">
          Four renditions covering mobile to desktop. Viewers' players switch automatically based on available bandwidth.

          ```json icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          [
          { "name": "720p",  "width": 1280, "height": 720,  "bitrate": 3000000, "fps": 0, "profile": "h264constrainedhigh", "gop": "1" },
          { "name": "480p",  "width": 854,  "height": 480,  "bitrate": 1600000, "fps": 0, "profile": "h264constrainedhigh", "gop": "1" },
          { "name": "360p",  "width": 640,  "height": 360,  "bitrate": 800000,  "fps": 0, "profile": "h264constrainedhigh", "gop": "1" },
          { "name": "240p",  "width": 426,  "height": 240,  "bitrate": 400000,  "fps": 0, "profile": "h264constrainedhigh", "gop": "1" }
          ]
          ```
        </Accordion>

        <Accordion title="Low-latency single rendition" icon="bolt">
          For use cases where you need a single output with minimal end-to-end latency (for example, feeding a monitoring pipeline or an AI processing step).

          ```json icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          [
          { "name": "480p-lowlat", "width": 854, "height": 480, "bitrate": 1200000, "fps": 0, "profile": "h264baseline", "gop": "0.5" }
          ]
          ```

          `h264baseline` is more compatible with edge players. `"gop": "0.5"` halves the default GOP, reducing segment duration and latency.
        </Accordion>

        <Accordion title="High-quality archive (1080p)" icon="archive">
          Single high-quality rendition for recording or post-production.

          ```json icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
          [
          { "name": "1080p-hq", "width": 1920, "height": 1080, "bitrate": 8000000, "fps": 0, "profile": "h264high", "gop": "2" }
          ]
          ```

          Higher bitrate and larger GOP (less overhead, better compression). Not suitable for live playback - use with `-objectStore` for archival.
        </Accordion>
      </AccordionGroup>
    </Tab>

    <Tab title="AI" icon="user-robot">
      ## AI Tuning

      AI tuning focuses on retry behaviour, model selection, and inference parameters.

      <Note>
        For AI routing architecture and Orchestrator discovery, see <LinkArrow href="/v2/gateways/guides/node-pipelines/ai-pipelines" label="AI Pipelines" newline={false} />. The tuning parameters you adjust after your AI Gateway is running.
      </Note>

      ### Retry Timeouts

      The `-aiProcessingRetryTimeout` flag controls how long the Gateway waits before retrying a failed AI request with another Orchestrator. The value accepts Go duration format (`30s`, `1m`, `2m30s`).

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      -aiProcessingRetryTimeout 30s
      ```

      The right value depends on your workload:

      <StyledTable headers={["Workload", "Recommended", "Rationale"]}>
        <TableRow>
          <TableCell>Lightning / LCM models</TableCell>
          <TableCell>`15s`</TableCell>
          <TableCell>Fast inference (4-8 steps), warm models respond in seconds</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>Standard diffusion (SDXL)</TableCell>
          <TableCell>`30s`</TableCell>
          <TableCell>20-50 inference steps, moderate GPU time</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>Audio / LLM pipelines</TableCell>
          <TableCell>`45s`</TableCell>
          <TableCell>Variable processing time depending on input length</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>BYOC / large models</TableCell>
          <TableCell>`60s` or higher</TableCell>
          <TableCell>Custom containers may have cold-start delays or heavy compute</TableCell>
        </TableRow>
      </StyledTable>

      Setting this too low causes the Gateway to retry before the Orchestrator has loaded the model, producing multiple failed attempts. Setting it too high delays failover when an Orchestrator is genuinely unresponsive.

      ### Model Selection

      The model you request in each API call directly affects latency, quality, and cost.

      **Warm vs cold models:**

      Orchestrators load models into GPU memory. A warm model responds in milliseconds. A cold model must load from disk first, adding seconds to minutes of latency. During the current beta, Orchestrators support one warm model per GPU.
      Check [tools.Livepeer.cloud/ai/network-capabilities](https://tools.livepeer.cloud/ai/network-capabilities) before selecting a model. For latency-sensitive applications, confirm your chosen model is warm on at least one connected Orchestrator.

      **Inference parameters by model family:**

      <StyledTable headers={["Model Family", "Steps", "Guidance Scale", "Notes"]}>
        <TableRow>
          <TableCell>Lightning / Turbo</TableCell>
          <TableCell>4-8</TableCell>
          <TableCell>1.0-2.0</TableCell>
          <TableCell>Optimised for speed. Too many steps degrades quality.</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>LCM (Latent Consistency)</TableCell>
          <TableCell>4-8</TableCell>
          <TableCell>1.0-2.0</TableCell>
          <TableCell>Similar to Lightning. Fast, low step count.</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>Standard SDXL</TableCell>
          <TableCell>20-50</TableCell>
          <TableCell>7.0-9.0</TableCell>
          <TableCell>Higher quality, slower. Too few steps produces noisy output.</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>SD 1.5 / 2.x</TableCell>
          <TableCell>20-30</TableCell>
          <TableCell>7.0-9.0</TableCell>
          <TableCell>Older generation. Lower VRAM requirements.</TableCell>
        </TableRow>
      </StyledTable>

      Using the wrong step count for a model family produces either slow responses (too many steps on a Lightning model) or degraded image quality (too few steps on a standard model).
    </Tab>
  </Tabs>
</BorderedBox>

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

## Key Differences

AI Gateways do not use RTMP, do not need `-transcodingOptions`, and require `-httpIngest` to enable AI endpoints on the HTTP port. The `-httpIngest` flag is a boolean toggle with no value - it activates AI pipeline endpoints (`/text-to-image`, `/llm`, etc.) on whatever port `-httpAddr` is set to.

<StyledTable headers={["Aspect", "Video Gateway", "AI Gateway"]}>
  <TableRow>
    <TableCell>Ingest</TableCell>
    <TableCell>RTMP (`-rtmpAddr`) + HTTP</TableCell>
    <TableCell>HTTP only (`-httpIngest` required)</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Profile config</TableCell>
    <TableCell>`-transcodingOptions` (encoding ladder)</TableCell>
    <TableCell>No profile - model selected per request</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Session limits</TableCell>
    <TableCell>`-maxSessions` (concurrent streams)</TableCell>
    <TableCell>No session limit flag</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Retry control</TableCell>
    <TableCell>Automatic (per segment)</TableCell>
    <TableCell>`-aiProcessingRetryTimeout` (per request)</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Pricing flag</TableCell>
    <TableCell>`-maxPricePerUnit` (per pixel)</TableCell>
    <TableCell>`-maxPricePerCapability` (per pipeline/model)</TableCell>
  </TableRow>
</StyledTable>

For the full side-by-side comparison, see <LinkArrow href="/v2/gateways/guides/node-pipelines/ai-pipelines#ai-vs-video-comparison" label="AI vs Video Comparison" newline={false} />.

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

## Configuration Verification

<BorderedBox variant="accent">
  <Tabs>
    <Tab title="Video" icon="video">
      **Check startup log for profile loading:**

      ```icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      I0501 11:07:47.609839  1 mediaserver.go:201] Transcode Job Type: [{480p0 ...} {720p0 ...}]
      ```

      **Send a test stream and check the HLS manifest:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      ffprobe http://localhost:8935/<stream-key>.m3u8
      ```

      **Update transcoding options at runtime:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      curl -X POST http://localhost:5935/setTranscodingOptions \
      -d "transcodingOptions=P240p30fps16x9,P720p30fps16x9"
      ```
    </Tab>

    <Tab title="AI" icon="brain">
      **Check the health endpoint:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      curl -s http://localhost:8935/health
      ```

      **Send a test inference request:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      curl -X POST http://localhost:8935/text-to-image \
      -H "Content-Type: application/json" \
      -d '{
          "model_id": "SG161222/RealVisXL_V4.0_Lightning",
          "prompt": "a test image",
          "width": 512,
          "height": 512,
          "num_inference_steps": 4,
          "guidance_scale": 1.5
      }'
      ```

      A JSON response with an `images` array confirms routing is working.

      **Check connected Orchestrators and their capabilities:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      curl http://localhost:5935/getOrchestrators
      ```
    </Tab>

    <Tab title="General" icon="terminal">
      **Check effective configuration via livepeer\_cli:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      livepeer_cli -host 127.0.0.1 -http 5935
      ```

      Option 1 ("Get node status") shows your current deposit, reserve, connected Orchestrators, and active sessions.

      **Check Gateway status:**

      ```bash icon="terminal" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      curl http://localhost:5935/status
      ```
    </Tab>
  </Tabs>
</BorderedBox>

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

## Related Pages

<CardGroup cols={2}>
  <Card title="AI Pipelines" icon="brain" href="/v2/gateways/guides/node-pipelines/ai-pipelines">
    AI routing architecture, Orchestrator discovery, and capability matching.
  </Card>

  <Card title="Video Pipelines" icon="video" href="/v2/gateways/guides/node-pipelines/video-pipelines">
    Video transcoding pipeline flow, RTMP/HTTP ingest, and Orchestrator selection.
  </Card>

  <Card title="Pricing Strategy" icon="tag" href="/v2/gateways/guides/payments-and-pricing/pricing-strategy">
    Price caps for video and AI, competitive positioning, and ETH volatility handling.
  </Card>

  <Card title="Dual Configuration" icon="clone" href="/v2/gateways/setup/configure">
    Architecture, port setup, and session management for dual Gateways.
  </Card>

  <Card title="Scaling" icon="arrow-up-right-dots" href="/v2/gateways/guides/advanced-operations/scaling">
    Resource contention signals, GPU memory pressure, and when to split workloads.
  </Card>

  <Card title="Configuration Flags" icon="list" href="/v2/gateways/resources/reference/technical/configuration-flags">
    Complete flag reference for all go-livepeer Gateway flags.
  </Card>
</CardGroup>