Get All Available Offers

Get All Available Offers - Overview

The Orix Series Offers API allows authenticated users to retrieve all available GPU instance offers on the Dataoorts Orix platform.

The endpoint returns GPU configurations along with their hourly costs, GPU count, GPU type, form factor, machine type, deployment region, hardware specifications, and total GPU availability.

Use this endpoint to compare available GPU configurations, estimate infrastructure costs, review hardware resources, and identify suitable offers for your instance provisioning workflows.

Response includes total number of offers, the pricing currency, and the details of each available configuration.

Endpoint

Property	Value
HTTP Method	`GET`
Endpoint	`/orix/offers`
Full URL	`https://cloud.dataoorts.com/api/v1/orix/offers`
Authentication	Bearer Token
Response Format	JSON

Authentication

This endpoint requires a valid Dataoorts Unify API key.

Include your API key in the Authorization header using the Bearer authentication scheme.

Authorization: Bearer YOUR_API_KEY
Accept: application/json

Generate or manage your API key through the Dataoorts Unify API.

Keep your API key confidential and never expose it in public repositories or client-side applications.

Request Parameters

This endpoint does not require any query parameters or a request body. Send a GET request with the required authentication header.

Request Examples

cURL - Use the following command to retrieve all available Orix GPU offers:

curl --request GET \
  --url "https://cloud.dataoorts.com/api/v1/orix/offers" \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Accept: application/json"

Replace YOUR_API_KEY with your actual Dataoorts Unify API key.

Python Example Implementation

The following example uses the requests library to retrieve available Orix GPU offers and display their pricing, hardware specifications, and regional availability.

Install the required dependency:

pip install requests

import os
import json
import requests


API_URL = "https://cloud.dataoorts.com/api/v1/orix/offers"


def get_orix_offers(api_key: str) -> dict:
    """
    Retrieve all available Orix GPU instance offers.

    Args:
        api_key: Your Dataoorts Unify API key.

    Returns:
        dict: The JSON response containing available offers.

    Raises:
        requests.exceptions.RequestException:
            If the HTTP request fails or returns an unsuccessful
            HTTP status code.
        ValueError:
            If the response cannot be decoded as JSON.
    """
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Accept": "application/json",
    }

    response = requests.get(
        API_URL,
        headers=headers,
        timeout=30,
    )

    response.raise_for_status()

    try:
        return response.json()
    except requests.exceptions.JSONDecodeError as exc:
        raise ValueError(
            "The API returned an invalid JSON response."
        ) from exc


if __name__ == "__main__":
    api_key = os.getenv("DATAOORTS_API_KEY")

    if not api_key:
        raise RuntimeError(
            "Set the DATAOORTS_API_KEY environment variable."
        )

    try:
        result = get_orix_offers(api_key)

        print("Status:", result.get("status"))
        print("Count:", result.get("count"))
        print("Currency:", result.get("currency"))
        print("Message:", result.get("message"))

        print("\nAvailable Orix GPU Offers:")

        for offer in result.get("offers", []):
            specs = offer.get("specs", {})
            network = specs.get("network", {})

            print("-" * 40)
            print("GPU Type:", offer.get("gpu_type"))
            print("GPU Count:", offer.get("gpu_count"))
            print("GPU Form Factor:", offer.get("gpu_form_factor"))
            print("Machine Type:", offer.get("machine_type"))
            print("Hourly Cost:", offer.get("hourly_cost"))
            print("Region:", offer.get("region"))
            print(
                "Total GPUs Available:",
                offer.get("total_gpus_available"),
            )
            print("vCPUs:", specs.get("vcpus"))
            print("RAM (GB):", specs.get("ram_gb"))
            print("Storage (GB):", specs.get("storage_gb"))
            print("VRAM (GB):", specs.get("vram_gb"))
            print("NVLink:", specs.get("nvlink"))
            print("Network:", network)
            print(
                "Full Offer Details:",
                json.dumps(offer, indent=2),
            )

    except requests.exceptions.RequestException as exc:
        print(f"API request failed: {exc}.")

    except ValueError as exc:
        print(f"Invalid API response: {exc}.")

Set your API key before running the script.

Linux / macOS

export DATAOORTS_API_KEY="YOUR_API_KEY"
python orix_offers.py

Windows PowerShell

$env:DATAOORTS_API_KEY="YOUR_API_KEY"
python orix_offers.py

The script prints the response status, total offer count, currency, and details of each available GPU configs.

Example Success Response

A successful request returns a JSON object containing the total number of offers, currency, a descriptive message, an array of GPU configurations, and the response status.

HTTP Status: 200 OK

{
  "count": 3,
  "currency": "USD",
  "message": "Live Orix GPU offers retrieved successfully.",
  "offers": [
    {
      "gpu_count": 8,
      "gpu_form_factor": "SXM5",
      "gpu_type": "H200",
      "hourly_cost": 33.516,
      "machine_type": "Virtual-Machine",
      "region": "US-SOUTHEAST-2",
      "specs": {
        "network": {
          "connection_type": "Ethernet",
          "variant": "RoCEv2"
        },
        "ram_gb": 2048,
        "storage_gb": 14307,
        "vcpus": 224
      },
      "total_gpus_available": 24
    },
    {
      "gpu_count": 16,
      "gpu_form_factor": "SXM5",
      "gpu_type": "H200",
      "hourly_cost": 67.032,
      "machine_type": "Virtual-Machine",
      "region": "US-SOUTHEAST-2",
      "specs": {
        "network": {
          "connection_type": "Ethernet",
          "variant": "RoCEv2"
        },
        "ram_gb": 2048,
        "storage_gb": 14307,
        "vcpus": 224
      },
      "total_gpus_available": 24
    },
    {
      "gpu_count": 24,
      "gpu_form_factor": "SXM5",
      "gpu_type": "H200",
      "hourly_cost": 100.548,
      "machine_type": "Virtual-Machine",
      "region": "US-SOUTHEAST-2",
      "specs": {
        "network": {
          "connection_type": "Ethernet",
          "variant": "RoCEv2"
        },
        "ram_gb": 2048,
        "storage_gb": 14307,
        "vcpus": 224
      },
      "total_gpus_available": 24
    }
  ],
  "status": "success"
}

The response above reflects the provided example. The number of offers, hourly costs, and available GPU configurations may differ in subsequent API responses.

Response Fields

Field	Type	Description
`status`	String	Indicates the result of the API request. A successful response API returns the `success`status.
`count`	Integer	The total number of offers returned by the API.
`currency`	String	The currency used for the listed hourly costs, such as `USD`.
`message`	String	A descriptive message about the result of the request.
`offers`	Array of objects	Contains the available Orix GPU instance configurations.

Offer Fields

Each object in the offers array represents an available GPU configuration.

Field	Type	Description
`gpu_type`	String	The GPU model associated with the offer, such as `H200`.
`gpu_count`	Integer	The number of GPUs included in the configuration.
`gpu_form_factor`	String	The GPU form factor reported for the offer, such as `SXM5`.
`hourly_cost`	Float	The hourly cost of config in currency specified by `currency`.
`machine_type`	String	The machine category, such as `Virtual-Machine`.
`region`	String	The deployment region associated with the offer.
`total_gpus_available`	Integer	The total GPU availability value reported for the offer.
`specs`	Object	Contains hardware & network specs associated with config.

Hardware Specification Fields

The specs object provides additional details about each GPU configuration.

Field	Type	Description
`specs.vcpus`	Integer	Number of virtual CPU cores reported for the configuration.
`specs.ram_gb`	Number	System RAM capacity in GB.
`specs.storage_gb`	Number	NVMe Storage capacity in GB.
`specs.vram_gb`	Number	GPU video memory capacity in GB, as reported by the offer.
`specs.nvlink`	Boolean	Indicates whether NVLink is reported as enabled for the config.
`specs.network`	Object	Contains network connection info associated with the offer.

Network Fields

The specs.network object describes the network configuration returned by the API.

Field	Type	Description
`specs.network.connection_type`	String	The network connection type, such as `Ethernet`.
`specs.network.variant`	String	Network variant reprted for config such as `RoCEv2`.

Understanding Orix GPU Offers

Each offer combines GPU config details, hourly pricing, regional information, and hardware specifications.

For example, an offer with gpu_type set to H200 and gpu_count set to 8 represents a configuration containing eight H200 GPUs. The hourly_cost field reports the corresponding hourly price, while region identifies the associated deployment region.

Use the returned configuration details to compare offers and identify an appropriate setup for your workload.

Important Notes

1. Pricing Currency: The hourly_cost values are expressed in the currency specified by the top-level currency field by default its USD.

2. GPU Availability: Use total_gpus_available as the availability value reported by the API. Confirm the current offer before creating an instance.

3. Region Selection: Review the region field when selecting a GPU configuration for deployment.

4. Hardware Specifications: Use the specs object to compare CPU, RAM, storage, VRAM, NVLink, and network configuration details.

5. Dynamic Offers: The returned offers and prices may change. Retrieve the latest data before making provisioning decisions.

6. Offer Listing Only: This endpoint retrieves GPU offer information. It does not launch an instance.

Error Handling

If request fails, API may return unsuccessful HTTP status code and JSON response containing an error message.

Your application should handle authentication failures, network errors, request timeouts, server errors, and unexpected response formats. The exact error codes and messages depend on the API response.

In Python, response.raise_for_status() raises an exception for unsuccessful HTTP status codes. Do not assume that every response contains the same fields as a successful response.

Get Help and Support

For assistance with Orix GPU offers or API integration, Contact our support team at [email protected].