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

# Video Transcoding Quickstart

> Run go-livepeer as a transcoding orchestrator: create your wallet, configure your node, register, and verify.

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 CustomCodeBlock = ({filename, icon, language, highlight, codeString = "", placeholderValue = "", wrap = true, lines = true, preNote = "", postNote = "", output = ""}) => {
  if (!codeString || codeString.trim() === "") {
    return null;
  }
  const renderedCode = codeString.replace(/\{PLACEHOLDER\}/g, placeholderValue);
  return <>
      {preNote && <div style={{
    marginBottom: "var(--lp-spacing-2)",
    fontSize: "0.875rem",
    color: "var(--lp-color-text-muted)"
  }}>
          {preNote}
        </div>}
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight} wrap={wrap} line={lines}>
        {renderedCode}
      </CodeBlock>
      {postNote && <div style={{
    marginTop: "var(--lp-spacing-2)",
    fontSize: "0.875rem",
    color: "var(--lp-color-text-muted)",
    fontStyle: "italic"
  }}>
          {postNote}
        </div>}
      {output?.codeString && <>
          <Expandable title={<span style={{
    fontStyle: "italic",
    fontWeight: "bold"
  }}>
                Expected Output
              </span>}>
            <CodeBlock filename={output.filename || "Output Example"} icon={output.icon || "terminal"} language={output.language || "bash"} highlight={output.highlight} wrap={output.wrap || false} line={output.lines || false}>
              {output.codeString}
            </CodeBlock>
          </Expandable>
          <br />
        </>}
    </>;
};

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

This is the canonical quickstart for running a transcoding Orchestrator.

## Step 1: Create and fund your ETH account

You need an Arbitrum One ETH account for on-chain Livepeer operation.

<Steps>
  <Step title="Create a keystore">
    Use `go-livepeer` to initialize a keystore path:

    ```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
    ./livepeer -network arbitrum-one-mainnet -ethKeystorePath ~/.lpData/keystore
    ```

    Store your keystore and passphrase securely.

    <Warning>
      Never commit keystore files or passphrase files to version control.
    </Warning>
  </Step>

  <Step title="Fund your account on Arbitrum One">
    Add ETH to your account for gas and ticket payments.

    * Minimum recommended to start: `0.1 ETH`
    * Bridge option: [Arbitrum Bridge](https://bridge.arbitrum.io/)
    * Exchange options: [Arbitrum exchanges](/v2/gateways/resources/compendium/arbitrum-exchanges)
  </Step>
</Steps>

## Step 2: Prerequisites

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Requirement</TableCell>
      <TableCell header>Notes</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow hover>
      <TableCell>Docker Engine installed</TableCell>

      <TableCell>
        <a href="https://docs.docker.com/engine/install/">Install Docker</a>
      </TableCell>
    </TableRow>

    <TableRow hover>
      <TableCell>Docker Compose v2</TableCell>
      <TableCell>Verify with `docker compose version`</TableCell>
    </TableRow>

    <TableRow hover>
      <TableCell>ETH account funded</TableCell>
      <TableCell>Complete Step 1</TableCell>
    </TableRow>

    <TableRow hover>
      <TableCell>Open ports</TableCell>
      <TableCell>`8935` (Orchestrator), `7935` (metrics optional)</TableCell>
    </TableRow>

    <TableRow hover>
      <TableCell>NVIDIA drivers</TableCell>
      <TableCell>Required only if enabling GPU transcoding</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

## Step 3: Configure and run

Use this compose template as a baseline and replace placeholders.

<CustomCodeBlock
  filename="docker-compose.yml"
  language="yaml"
  icon="docker"
  codeString={`services:
orchestrator:
image: livepeer/go-livepeer:master
restart: unless-stopped
ports:
  - "8935:8935"
  - "7935:7935"
volumes:
  - ~/.lpData/keystore:/keystore:ro
  - ~/.lpData/password:/password:ro
command:
  - "-network=arbitrum-one-mainnet"
  - "-orchestrator"
  - "-transcoder"
  - "-ethUrl=<YOUR_ARB_RPC_URL>"
  - "-ethKeystorePath=/keystore"
  - "-ethPassword=/password/eth-secret.txt"
  - "-serviceAddr=<YOUR_PUBLIC_HOST>:8935"
  - "-pricePerUnit=1000"
  - "-pixelsPerUnit=1000000000000"
  - "-maxSessions=10"
  - "-monitor=true"
  - "-v=6"`}
/>

<Note>
  If you are running CPU-only transcoding, remove GPU-specific runtime settings.
</Note>

Start the node:

<CustomCodeBlock language="bash" icon="terminal" codeString={`docker compose up -d\ndocker compose logs --tail=100`} />

## Step 4: Register

<StyledSteps>
  <StyledStep title="Open the Livepeer CLI">
    <CustomCodeBlock language="bash" icon="terminal" codeString={`livepeer_cli`} />
  </StyledStep>

  <StyledStep title="Activate orchestrator settings">
    Use `Invoke multistep wizard` in CLI, or run flags directly:

    <CustomCodeBlock
      language="bash"
      icon="terminal"
      codeString={`./livepeer \\
-network arbitrum-one-mainnet \\
-blockRewardCut 5.0 \\
-feeShare 10.0 \\
-pricePerUnit 1000 \\
-pixelsPerUnit 1000000000000 \\
-serviceURI https://your-orchestrator.example.com:8935`}
    />
  </StyledStep>
</StyledSteps>

## Step 5: Verify your node

<CustomCodeBlock language="bash" icon="terminal" codeString={`curl http://localhost:7935/status\nlivepeer_cli -cmd status`} />

Your Orchestrator should appear in the [Livepeer Explorer](https://explorer.livepeer.org/orchestrators).

## Testing end-to-end with a Gateway

Once both services are running, verify an end-to-end transcoding session.

<StyledSteps>
  <StyledStep title="Point a gateway at your orchestrator">
    Configure Gateway routing to your Orchestrator service URI:

    ```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
    -orchAddr=https://your-orchestrator.example.com:8935
    ```
  </StyledStep>

  <StyledStep title="Send a test stream through the gateway">
    Use the Gateway quickstart ingest flow.
  </StyledStep>

  <StyledStep title="Confirm transcoding session logs">
    Check Orchestrator logs for active session creation and completion.
  </StyledStep>
</StyledSteps>

<Card title="Gateway Quickstart" icon="torii-gate" href="/v2/gateways/quickstart/gateway-setup" arrow>
  Use this to run Gateway-side setup and stream validation.
</Card>

## Related pages

<CardGroup cols={2}>
  <Card title="Orchestrator Job Types" icon="layer-group" href="/v2/orchestrators/guides/ai-and-job-workloads/workload-options" arrow>
    Compare transcoding, realtime AI, and batch AI paths.
  </Card>

  <Card title="Install go-livepeer" icon="download" href="/v2/orchestrators/setup/install-go-livepeer" arrow>
    Full install options and advanced flags.
  </Card>

  <Card title="Connect to Arbitrum" icon="plug" href="/v2/orchestrators/setup/install-go-livepeer" arrow>
    RPC selection and network connection guidance.
  </Card>

  <Card title="CLI flags reference" icon="terminal" href="/v2/orchestrators/resources/reference/technical/cli-flags" arrow>
    Full Orchestrator flag reference.
  </Card>
</CardGroup>