> ## Documentation Index
> Fetch the complete documentation index at: https://data.ornn.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get the Effective Utilization Index

> How much of the tracked GPU fleet is actually working over a trailing window - the demand side of the market the price index prices. Returns the window's capacity-weighted occupancy, the effective utilization rate (`eur`), the price per **useful** GPU-hour (`effectivePrice`), revenue per available GPU-hour (`revPag`), an index level rebased to `baseDate`, and the demand/supply decomposition of the move across the window.
Occupancy is capacity-weighted: numerator and denominator are summed before dividing, so a 4-GPU listing does not move the market rate as hard as a 4,000-GPU one. Always read `basis` - with heartbeat intensity live it reports `occupancy_x_intensity`; if the telemetry feed is unreachable it degrades to `occupancy_only` and `eur` equals `occupancy`. Also read `coverage`: a scrape gap is missing information, not idle GPUs.
The window defaults to the trailing 30 days and is capped at 400 days. See the Effective Utilization Index concept page for the full methodology and its known limitations.


## Overview

How much of the tracked GPU fleet is actually working over a trailing window, and
what compute costs per **useful** GPU-hour once idle capacity is priced in.

Read `basis` before comparing series: while heartbeat intensity is unwired it
reports `occupancy_only` and `eur` equals `occupancy`. Read `coverage` too — a
scrape gap is missing information, not idle GPUs.

See the [Effective Utilization Index](/docs/utilization-index) concept page for the
construction, the demand/supply decomposition, and the known limitations.


## OpenAPI

````yaml openapi.yaml GET /api/utilization-index
openapi: 3.1.0
info:
  title: Ornn Data API
  version: 1.0.0
  description: >
    Read-only REST API for GPU and memory market data. The price index is the
    going rate of compute in USD per GPU-hour, a weighted average of all
    verified compute transactions across the market.
servers:
  - url: https://api.ornnai.com
security:
  - bearerAuth: []
tags:
  - name: Current Prices
  - name: Historical Prices
  - name: Analytics
  - name: Memory
  - name: Token Prices
  - name: Workload Cost
  - name: LLM Coding
  - name: Neo-Cloud Sites
  - name: Reference
paths:
  /api/utilization-index:
    get:
      tags:
        - Analytics
      summary: Get the Effective Utilization Index
      description: >
        How much of the tracked GPU fleet is actually working over a trailing
        window - the demand side of the market the price index prices. Returns
        the window's capacity-weighted occupancy, the effective utilization rate
        (`eur`), the price per **useful** GPU-hour (`effectivePrice`), revenue
        per available GPU-hour (`revPag`), an index level rebased to `baseDate`,
        and the demand/supply decomposition of the move across the window.

        Occupancy is capacity-weighted: numerator and denominator are summed
        before dividing, so a 4-GPU listing does not move the market rate as
        hard as a 4,000-GPU one. Always read `basis` - with heartbeat intensity
        live it reports `occupancy_x_intensity`; if the telemetry feed is
        unreachable it degrades to `occupancy_only` and `eur` equals
        `occupancy`. Also read `coverage`: a scrape gap is missing information,
        not idle GPUs.

        The window defaults to the trailing 30 days and is capped at 400 days.
        See the Effective Utilization Index concept page for the full
        methodology and its known limitations.
      parameters:
        - name: gpuType
          in: query
          description: >-
            Restrict to a single GPU model. Defaults to every public model,
            aggregated.
          schema:
            type: string
            enum:
              - H100 SXM
              - H200
              - A100 SXM4
              - B200
              - RTX 5090
              - RTX PRO 6000 WS
        - name: region
          in: query
          description: >-
            Occupancy region. Defaults to `global`. Note that price is
            market-wide, so a narrower region yields an approximate effective
            price.
          schema:
            type: string
            example: global
        - name: startDate
          in: query
          description: >-
            Inclusive start of the window in YYYY-MM-DD. Defaults to 29 days
            before `endDate`.
          schema:
            type: string
            example: '2026-07-14'
        - name: endDate
          in: query
          description: Inclusive end of the window in YYYY-MM-DD. Defaults to today.
          schema:
            type: string
            example: '2026-08-12'
        - name: baseDate
          in: query
          description: >-
            Rebase anchor for the index level. Defaults to 2026-01-01. Check
            `baseAvailable` in the response - when false the series rebased on
            its own first day.
          schema:
            type: string
            example: '2026-01-01'
      responses:
        '200':
          description: The Effective Utilization Index over the requested window.
          content:
            application/json:
              example:
                success: true
                region: global
                gpuTypes:
                  - H100 SXM
                baseDate: '2026-01-01'
                baseAvailable: true
                intensitySource: unavailable
                count: 30
                window:
                  startDate: '2026-07-14'
                  endDate: '2026-08-12'
                  days: 30
                summary:
                  occupancy: 0.3846
                  intensity: null
                  eur: 0.3846
                  basis: occupancy_only
                  index: 104.2
                  price: 2.49
                  effectivePrice: 6.4742
                  revPag: 0.9576
                  priceCoverage: 1
                  latest:
                    date: '2026-08-12'
                    occupancy: 0.4012
                    eur: 0.4012
                    index: 108.7
                    effectivePrice: 6.2064
                  peakOccupancy: 0.4611
                  troughOccupancy: 0.3102
                  volatility: 0.0374
                  capacityMean: 12480.5
                  headroomMean: 7681.2
                  demandEffect: 0.0412
                  supplyEffect: -0.0097
                  occupancyChange: 0.0315
                  decompositionBasis: like_for_like
                  compositionBreaks: 0
                  coverage: 0.9847
                  readings: 709
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          $ref: '#/components/responses/NotFound'
      x-codeSamples:
        - lang: bash
          label: cURL
          source: >
            curl
            "https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM" \
              -H "Authorization: Bearer YOUR_API_KEY"
        - lang: python
          label: Python
          source: |
            import requests

            payload = requests.get(
                "https://api.ornnai.com/api/utilization-index",
                params={"gpuType": "H100 SXM"},
                headers={"Authorization": "Bearer YOUR_API_KEY"},
            ).json()
            s = payload["summary"]
            print(s["occupancy"], s["effectivePrice"], s["basis"])
        - lang: javascript
          label: JavaScript
          source: |
            const res = await fetch(
              "https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM",
              { headers: { Authorization: "Bearer YOUR_API_KEY" } },
            );
            const { summary } = await res.json();
        - lang: php
          label: PHP
          source: >
            <?php

            $ch =
            curl_init("https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM");

            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => ["Authorization: Bearer YOUR_API_KEY"],
            ]);

            $data = json_decode(curl_exec($ch), true);
        - lang: go
          label: Go
          source: "package main\n\nimport (\n\t\"io\"\n\t\"net/http\"\n)\n\nfunc main() {\n\tendpoint := \"https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM\"\n\treq, _ := http.NewRequest(\"GET\", endpoint, nil)\n\treq.Header.Set(\"Authorization\", \"Bearer YOUR_API_KEY\")\n\tresp, _ := http.DefaultClient.Do(req)\n\tdefer resp.Body.Close()\n\tbody, _ := io.ReadAll(resp.Body)\n\t_ = body\n}\n"
        - lang: java
          label: Java
          source: >
            import java.net.URI;

            import java.net.http.HttpClient;

            import java.net.http.HttpRequest;

            import java.net.http.HttpResponse;


            HttpClient client = HttpClient.newHttpClient();

            HttpRequest request = HttpRequest.newBuilder(
                    URI.create("https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM"))
                .header("Authorization", "Bearer YOUR_API_KEY")
                .build();
            HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        - lang: ruby
          label: Ruby
          source: >
            require "net/http"

            require "json"


            uri =
            URI("https://api.ornnai.com/api/utilization-index?gpuType=H100%20SXM")

            req = Net::HTTP::Get.new(uri)

            req["Authorization"] = "Bearer YOUR_API_KEY"

            res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) {
            |http| http.request(req) }

            data = JSON.parse(res.body)
components:
  responses:
    BadRequest:
      description: A required parameter is missing or invalid.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Unauthorized:
      description: Missing, invalid, or revoked API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: Unauthorized
            message: 'API key required. Use Authorization: Bearer YOUR_API_KEY'
    NotFound:
      description: No data found for the given parameters.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error: No data available
            message: No daily index data found for H100 SXM
  schemas:
    Error:
      type: object
      properties:
        error:
          type: string
          example: Bad request
        message:
          type: string
          example: >-
            Invalid GPU type. Allowed: H100 SXM, H200, A100 SXM4, RTX 5090,
            B200, RTX PRO 6000 WS
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: API key passed as a Bearer token. Create one in the dashboard.

````