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

# Pricing Strategy

> Set competitive pricing for video and AI workloads on a Livepeer orchestrator. Covers pricePerUnit, per-pipeline AI pricing in aiModels.json, pricePerGateway, autoAdjustPrice, and market positioning methodology.

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

<Tip>
  Gateways filter Orchestrators by price before routing jobs. An Orchestrator priced above a Gateway's cap receives no work from that Gateway. An Orchestrator priced below the network floor earns less than its operating costs. Both extremes produce zero net income.
</Tip>

***

Livepeer pricing operates in two domains: **video transcoding** (a single global price per pixel) and **AI inference** (per-pipeline, per-model pricing in `aiModels.json`). Commercial relationships add a third layer: per-Gateway custom pricing via `-pricePerGateway`.

The correct price for each domain is derived from the same principle: find the range where active Gateways are accepting work, then position within that range based on hardware cost.

<CustomDivider />

## Video pricing

Video transcoding is priced in **wei per pixel**. One ETH equals 1,000,000,000,000,000,000 wei (1e18). The pixel count for a job is `width × height × output_renditions`.

The active network range changes as ETH price, Gateway caps, and redemption overhead move. Use the current Livepeer Explorer and your own routed volume as the reference point. Historical ranges are only context.

### Setting the price

Set `-pricePerUnit` at startup:

```bash icon="terminal" title="Video price startup flags" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
livepeer \
  -orchestrator \
  -transcoder \
  -pricePerUnit 1000 \
  -pixelsPerUnit 1 \
  ...
```

`-pixelsPerUnit` is the denominator. Leave it at `1` unless you prefer expressing price over a larger pixel batch for readability.

To price in USD, append the `USD` suffix. Go-livepeer converts the value to wei at runtime using a Chainlink ETH/USD price feed on Arbitrum:

```bash icon="terminal" title="Video price in USD" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
-pixelsPerUnit 1000000000000 \
-pricePerUnit 0.41USD
```

This example sets a price of \$0.41 per trillion pixels. Adjust `pixelsPerUnit` to keep `pricePerUnit` as a readable decimal. The `-pixelsPerUnit` flag supports exponential notation (`1e12`); `-pricePerUnit` does not.

### Surveying the market

Check [Livepeer Explorer](https://explorer.livepeer.org/orchestrators) for the current price distribution across the Active Set. Active Orchestrators are listed with their advertised price. A practical starting point is the lower half of currently active prices, then adjust upward only after you confirm that job volume still holds.

Use `livepeer_cli` to inspect connected Orchestrators and their current prices from your node's perspective.

### autoAdjustPrice

By default, go-livepeer automatically adjusts the price it advertises to Gateways based on the estimated cost of ticket redemption. When gas prices rise, the overhead for redeeming a winning ticket increases as a percentage of the ticket face value. The adjustment compensates for this:

| Overhead | Base price 1,000 wei | Advertised price |
| -------- | -------------------- | ---------------- |
| 1%       | 1,000 wei            | 1,010 wei        |
| 20%      | 1,000 wei            | 1,200 wei        |
| 50%      | 1,000 wei            | 1,500 wei        |

The adjustment is automatic and continuous. To disable it and advertise a fixed price regardless of gas conditions:

```bash icon="terminal" title="Disable autoAdjustPrice" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
-autoAdjustPrice=false
```

Disabling autoAdjustPrice is appropriate when you want a predictable advertised rate for commercial relationships, or when you are setting per-Gateway prices manually. For general network participation, keep the default on.

<CustomDivider />

## AI pricing

AI inference pricing is configured per pipeline and per model in `aiModels.json`. Each entry sets its own `price_per_unit` independently of the video transcoding price.

### Pricing units by pipeline

The unit of work varies by pipeline type:

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Pipeline</TableCell>
      <TableCell header>Pricing unit</TableCell>
      <TableCell header>Typical price\_per\_unit</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>`text-to-image`</TableCell>
      <TableCell>Per output pixel</TableCell>
      <TableCell>\~4,768,371 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`image-to-image`</TableCell>
      <TableCell>Per output pixel</TableCell>
      <TableCell>\~4,768,371 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`image-to-video`</TableCell>
      <TableCell>Per output pixel</TableCell>
      <TableCell>\~9,536,742 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`upscale`</TableCell>
      <TableCell>Per input pixel</TableCell>
      <TableCell>\~4,768,371 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`audio-to-text`</TableCell>
      <TableCell>Per millisecond of audio</TableCell>
      <TableCell>\~12,882,811 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`segment-anything-2`</TableCell>
      <TableCell>Per input pixel</TableCell>
      <TableCell>\~4,768,371 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`image-to-text`</TableCell>
      <TableCell>Per input pixel</TableCell>
      <TableCell>\~1,192,093 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`text-to-speech`</TableCell>
      <TableCell>Per character or per ms of audio</TableCell>
      <TableCell>\~5,960,465 wei</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`llm`</TableCell>
      <TableCell>Per custom unit (typically per 1M tokens)</TableCell>
      <TableCell>USD-denominated (see below)</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

### aiModels.json pricing fields

```json icon="code" title="aiModels.json pricing fields" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
{
  "pipeline": "text-to-image",
  "model_id": "SG161222/RealVisXL_V4.0_Lightning",
  "price_per_unit": 4768371,
  "pixels_per_unit": 1,
  "warm": true
}
```

The `price_per_unit` field accepts:

* **Integer** – value in wei
* **USD string** – scientific notation with `USD` suffix, e.g. `"0.5e-3USD"` (requires `"currency": "USD"`)

The `pixels_per_unit` field adjusts pricing granularity. Setting it to a larger value (e.g. `1000000`) lets you express `price_per_unit` as a more readable number over a batch of pixels.

### USD notation for AI pricing

USD-denominated AI pricing is particularly useful for LLM pipelines, where per-token economics are easier to reason about than wei values:

```json icon="code" title="LLM USD pricing example" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
{
  "pipeline": "llm",
  "model_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
  "price_per_unit": 0.18,
  "currency": "USD",
  "pixels_per_unit": 1000000,
  "url": "http://llm_runner:8000",
  "warm": true
}
```

For image pipelines, USD notation eliminates the need to convert from wei manually:

```json icon="code" title="Image pipeline USD pricing" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
{
  "pipeline": "text-to-image",
  "model_id": "SG161222/RealVisXL_V4.0_Lightning",
  "price_per_unit": "0.5e-3USD",
  "currency": "USD",
  "warm": true
}
```

`0.5e-3USD` is \$0.0005 per megapixel at the ETH/USD rate at runtime. The conversion uses the same Chainlink price feed as the `-pricePerUnit` USD mode for video.

### Checking competitive AI rates

Visit [tools.Livepeer.cloud/ai/network-capabilities](https://tools.livepeer.cloud/ai/network-capabilities) and filter by pipeline to see which price tiers are currently earning jobs. Orchestrators priced above Gateway caps receive no work for that pipeline. Start at or below the median for the pipeline you are entering, then adjust based on job volume.

<CustomDivider />

## Per-Gateway pricing

The `-pricePerGateway` flag sets a custom price for a specific Gateway address, overriding your global `-pricePerUnit` for jobs from that Gateway. This is the mechanism for commercial relationships where you negotiate a custom rate with a Gateway operator.

The current CLI reference documents the value as either a JSON payload or a path to a JSON file:

```json icon="code" title="pricePerGateway JSON" theme={"theme":{"light":"github-light","dark":"dark-plus"}}
{
  "gateways": [
    {
      "ethaddress": "0xGatewayAddress1",
      "priceperunit": 1000,
      "pixelsperunit": 1
    },
    {
      "ethaddress": "0xGatewayAddress2",
      "priceperunit": 1200,
      "pixelsperunit": 1
    }
  ]
}
```

Use `-pricePerGateway` when:

* A Gateway operator negotiates a dedicated rate in exchange for consistent job volume
* You are running a combined Orchestrator and Gateway on the same operator stack
* You want to offer a preferential rate to a specific partner while keeping a higher public rate

<CustomDivider />

## Pricing flag reference

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Flag</TableCell>
      <TableCell header>Scope</TableCell>
      <TableCell header>Default</TableCell>
      <TableCell header>Notes</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>`-pricePerUnit`</TableCell>
      <TableCell>Video</TableCell>
      <TableCell>Required</TableCell>
      <TableCell>Wei per pixel, or USD string (e.g. `0.41USD`)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`-pixelsPerUnit`</TableCell>
      <TableCell>Video</TableCell>
      <TableCell>`1`</TableCell>
      <TableCell>Pixels per pricing unit; adjust for readability</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`-autoAdjustPrice`</TableCell>
      <TableCell>Video</TableCell>
      <TableCell>`true`</TableCell>
      <TableCell>Adjusts advertised price for ticket redemption overhead; set `false` for fixed price</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`-pricePerGateway`</TableCell>
      <TableCell>Video</TableCell>
      <TableCell>None</TableCell>
      <TableCell>Custom price for a specific Gateway address</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`-priceFeedAddr`</TableCell>
      <TableCell>Both (USD mode)</TableCell>
      <TableCell>Arbitrum ETH/USD feed</TableCell>
      <TableCell>Chainlink oracle address for custom currency or non-mainnet deployments</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`price_per_unit` (aiModels.json)</TableCell>
      <TableCell>AI</TableCell>
      <TableCell>Required per entry</TableCell>
      <TableCell>Integer (wei) or USD string per pipeline entry</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`pixels_per_unit` (aiModels.json)</TableCell>
      <TableCell>AI</TableCell>
      <TableCell>`1`</TableCell>
      <TableCell>Pricing granularity per pipeline entry</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>`currency` (aiModels.json)</TableCell>
      <TableCell>AI</TableCell>
      <TableCell>None (wei)</TableCell>
      <TableCell>Set to `"USD"` when using USD notation in `price_per_unit`</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider />

## Related pages

<CardGroup cols={2}>
  <Card title="Gateway Pricing Strategy" icon="sliders" href="/v2/gateways/guides/payments-and-pricing/pricing-strategy" arrow horizontal>
    The buy-side mirror: how Gateways set price caps and filter Orchestrators.
  </Card>

  <Card title="Gateway Relationships" icon="handshake" href="/v2/orchestrators/guides/advanced-operations/gateway-relationships" arrow horizontal>
    How Gateways evaluate and select Orchestrators, including price as a filter criterion.
  </Card>

  <Card title="Earning Model" icon="coins" href="/v2/orchestrators/guides/staking-and-rewards/earning-model" arrow horizontal>
    How pricing decisions translate into fee earnings alongside LPT inflation rewards.
  </Card>

  <Card title="AI Inference Operations" icon="microchip" href="/v2/orchestrators/guides/ai-and-job-workloads/ai-inference-operations" arrow horizontal>
    Full aiModels.json reference and pipeline configuration.
  </Card>
</CardGroup>