> ## 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 current utilization for all GPUs

> The latest utilization reading for every tracked GPU in one call, with the
7- and 30-day means behind it. Takes no parameters.

Use this for a cross-section across GPUs. For one GPU's series over time,
use `/api/gpu/{gpuName}/volume-metrics`.

`utilization_ratio` is the share of tracked capacity rented, between 0 and 1,
and is bounded to the last 48 hours: a GPU whose feed has stopped returns
`null` rather than a stale figure. `avg_7d` and `avg_30d` are explicitly
windowed and still populate in that case. A GPU with no readings at all in
the 30-day window is absent from `data` rather than present with nulls.

Pinned to `region: "global"`.


## Overview

The latest utilization reading for every tracked GPU in one call, with the 7- and
30-day means behind it. Takes no parameters.

Use this for a cross-section across GPUs. For one GPU's series over time, use
[Get market utilization](/docs/api-reference/analytics/get-market-utilization).

## Reading the response

`utilization_ratio` is the share of tracked capacity rented, between 0 and 1, and is
bounded to the last 48 hours — a GPU whose feed has stopped returns `null` rather than
a stale figure. `avg_7d` and `avg_30d` are explicitly windowed and still populate in
that case, so neither can be misread as current.

A GPU with no readings at all in the 30-day window is absent from `data` rather than
present with nulls.

Results are pinned to `region: "global"`.


## OpenAPI

````yaml openapi.yaml GET /api/gpu-utilization
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: Forward Curves
  - name: Token Volume
  - name: Model Frontier
  - name: Compute Buyers
  - name: Power Markets
  - name: Neo-Cloud Sites
  - name: Reference
paths:
  /api/gpu-utilization:
    get:
      tags:
        - Analytics
      summary: Get current utilization for all GPUs
      description: >
        The latest utilization reading for every tracked GPU in one call, with
        the

        7- and 30-day means behind it. Takes no parameters.


        Use this for a cross-section across GPUs. For one GPU's series over
        time,

        use `/api/gpu/{gpuName}/volume-metrics`.


        `utilization_ratio` is the share of tracked capacity rented, between 0
        and 1,

        and is bounded to the last 48 hours: a GPU whose feed has stopped
        returns

        `null` rather than a stale figure. `avg_7d` and `avg_30d` are explicitly

        windowed and still populate in that case. A GPU with no readings at all
        in

        the 30-day window is absent from `data` rather than present with nulls.


        Pinned to `region: "global"`.
      responses:
        '200':
          description: Latest utilization per GPU.
          content:
            application/json:
              example:
                success: true
                query:
                  region: global
                  gpu_types:
                    - H100 SXM
                    - H200
                    - A100 SXM4
                    - RTX 5090
                    - B200
                    - RTX PRO 6000 WS
                  window_days: 30
                data:
                  - gpu_name: H100 SXM
                    utilization_ratio: 0.7
                    recorded_at: '2026-08-31T12:00:00.000Z'
                    avg_7d: 0.68
                    avg_30d: 0.66
                    readings_found: 720
                  - gpu_name: H200
                    utilization_ratio: 0.81
                    recorded_at: '2026-08-31T12:00:00.000Z'
                    avg_7d: 0.79
                    avg_30d: 0.77
                    readings_found: 720
        '401':
          $ref: '#/components/responses/Unauthorized'
      x-codeSamples:
        - lang: bash
          label: cURL
          source: |
            curl "https://api.ornnai.com/api/gpu-utilization" \
              -H "Authorization: Bearer YOUR_API_KEY"
        - lang: python
          label: Python
          source: |
            import requests

            resp = requests.get(
                "https://api.ornnai.com/api/gpu-utilization",
                headers={"Authorization": "Bearer YOUR_API_KEY"},
            )
            data = resp.json()
        - lang: javascript
          label: JavaScript
          source: >
            const res = await
            fetch("https://api.ornnai.com/api/gpu-utilization", {
              headers: { Authorization: "Bearer YOUR_API_KEY" },
            });

            const data = await res.json();
        - lang: php
          label: PHP
          source: |
            <?php
            $ch = curl_init("https://api.ornnai.com/api/gpu-utilization");
            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\treq, _ := http.NewRequest(\"GET\", \"https://api.ornnai.com/api/gpu-utilization\", 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/gpu-utilization"))
                .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/gpu-utilization")

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

            req["Authorization"] = "Bearer YOUR_API_KEY"

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

            data = JSON.parse(res.body)
components:
  responses:
    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'
  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.

````