Get All Available Offers

This endpoint retrieves all currently available live Z-Series enterprise GPU offers in real time. It returns detailed accelerator types (gpu_type), NVIDIA microarchitectures (architecture), provider regions (region), hardware allocations per GPU (vCPUs, RAM, VRAM), available node inventory, and transparent per-GPU hourly pricing.

Get All Available Offers - Overview

The Z-Series GPU Offers API allows authenticated users to retrieve all currently available live Z-Series GPU Instance offers.

The endpoint returns the latest available GPU configurations in real time, including GPU models, architectures, regions, available nodes, hourly pricing per GPU, system RAM, CPU cores, and GPU VRAM specifications.

Use this endpoint to review available Z-Series GPU configurations and their pricing before creating an instance.

Endpoint

Property	Value
HTTP Method	GET
Endpoint	/zseries/offers
Full URL	https://cloud.dataoorts.com/api/v1/zseries/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.

HTTP

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 currently available Z-Series GPU offers:

Bash

curl --request GET \
  --url "https://cloud.dataoorts.com/api/v1/zseries/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 all live Z-Series GPU offers. It reads the API key from an environment variable, handles unsuccessful HTTP responses, and checks the response format before processing the returned data.

Install the required dependency:

Bash

pip install requests

Python

import os
import requests


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


def get_zseries_live_offers(api_key: str) -> dict | None:
    """
    Retrieve all currently available live Z-Series GPU offers.

    Args:
        api_key: Your Dataoorts Unify API key.

    Returns:
        The JSON response containing available GPU offers,
        or None if the API returns a non-JSON response.

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

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

    response.raise_for_status()

    content_type = response.headers.get("Content-Type", "")

    if "application/json" not in content_type.lower():
        print("Non-JSON response received:")
        print(response.text[:500])
        return None

    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_zseries_live_offers(api_key)

        if result is not None:
            print("Status:", result.get("status"))
            print("Message:", result.get("message"))
            print("Currency:", result.get("currency"))
            print("Total Offers:", result.get("count"))

            print("\nAvailable Z-Series GPU Offers")

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

                print("-" * 40)
                print("GPU Type:", offer.get("gpu_type"))
                print("Architecture:", offer.get("architecture"))
                print("Region:", offer.get("region"))
                print("Available Nodes:", offer.get("available_nodes"))
                print(
                    "Price per GPU Hour:",
                    offer.get("price_per_gpu_hour"),
                )
                print("RAM (GB):", specs.get("ram_gb"))
                print("vCPUs:", specs.get("vcpus"))
                print("VRAM (GB):", specs.get("vram_gb"))

    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 in your ENV before running the script.

Linux / macOS

Bash

export DATAOORTS_API_KEY="YOUR_API_KEY"
python zseries_offers.py

Windows PowerShell

PowerShell

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

The script displays the total number of offers and currency first, followed by each GPU configuration, architecture, region, available nodes, price per GPU hour, and hardware specifications.

Example Success Response

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

JSON

{
  "count": 3,
  "currency": "USD",
  "message": "Live Z-Series GPU offers retrieved successfully.",
  "offers": [
    {
      "architecture": "Ada",
      "available_nodes": 8,
      "gpu_type": "L4",
      "price_per_gpu_hour": 0.48,
      "region": "INDIA",
      "specs_per_gpu": {
        "ram_gb": 124,
        "vcpus": 28,
        "vram_gb": "24"
      }
    },
    {
      "architecture": "Blackwell",
      "available_nodes": 8,
      "gpu_type": "RTX-PRO6000",
      "price_per_gpu_hour": 2.08,
      "region": "USA",
      "specs_per_gpu": {
        "ram_gb": 160,
        "vcpus": 28,
        "vram_gb": "96"
      }
    },
    {
      "architecture": "Hopper",
      "available_nodes": 8,
      "gpu_type": "H100",
      "price_per_gpu_hour": 2.96,
      "region": "FINLAND",
      "specs_per_gpu": {
        "ram_gb": 200,
        "vcpus": 24,
        "vram_gb": "80"
      }
    }
  ],
  "status": "success"
}

The values above illustrate the response structure. The available configurations, node availability, regions, and prices may differ in subsequent API responses. The fields returned inside each offer may also vary depending on the latest marketplace inventory.

Response Fields

Field	Type	Description
status	String	Indicates the result of the API request. A successful response returns success; an unsuccessful response may return error.
count	Integer	Number of available GPU offers returned.
currency	String	Currency used for pricing. The example response returns USD.
offers	Array of objects	List of currently available Z-Series GPU offers.
message	String	A descriptive message about the result of the request.

Offer Fields

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

Field	Type	Description
offers[].gpu_type	String	GPU model associated with the offer, such as L4, RTX-PRO6000, or H100.
offers[].architecture	String	GPU architecture associated with the offer, such as Ada, Blackwell, or Hopper.
offers[].region	String	Provider region associated with the offer, such as INDIA, USA, or FINLAND.
offers[].available_nodes	Integer	Number of available GPUs reported for the offer.
offers[].price_per_gpu_hour	Float	Hourly price per GPU, expressed in the currency specified by currency.
offers[].specs_per_gpu	Object	Contains system RAM, vCPU, and GPU VRAM specifications reported for the offer.

Hardware Specification Fields

The specs_per_gpu object provides the hardware specifications reported for each offer.

Field	Type	Description
offers[].specs_per_gpu.ram_gb	Int	System RAM allocated per GPU, in GB.
offers[].specs_per_gpu.vcpus	Int	Number of vCPUs allocated per GPU.
offers[].specs_per_gpu.vram_gb	Str	GPU VRAM per GPU, in GB. Supplied example returns this value as a string, such as "24", "96"

Understanding Z-Series GPU Offers

GPU Configuration

The gpu_type and architecture fields identify the GPU model and its architecture.

The example response includes three offers:

• L4 with the Ada architecture.
• RTX-PRO6000 with the Blackwell architecture.
• H100 with the Hopper architecture.

Use these fields to review the available GPU options before selecting a configuration.

Available Nodes

The available_nodes field indicates the number of GPU nodes reported as available for each offer.

In the example response, all three offers report eight available nodes. Availability changes dynamically as GPU capacity is allocated or released.

Hourly Pricing

The price_per_gpu_hour field reports the hourly price per GPU. The response's currency field indicates the currency used for pricing.

Hardware Specifications

The specs_per_gpu object provides the RAM, vCPU, and VRAM values reported for each GPU offer. Use these fields to compare available configurations and review the resources allocated per GPU.

Live Offer Availability

This endpoint returns live Z-Series GPU offers available at the time of the request. If no GPU offers are currently available, the API returns an empty offers array with count set to 0.

Important Notes

1. Live Offers: This endpoint returns GPU offers available at the time of the request. Availability and pricing may change dynamically.

2. Authentication: A valid Dataoorts Unify API key is required to retrieve offers.

3. Pricing Currency: All prices are returned in USD in the supplied response.

4. Per-GPU Pricing: The price_per_gpu_hour field represents the hourly price per GPU, not necessarily the total hourly cost of a multi-GPU configuration.

5. Available Nodes: The available_nodes field indicates the number of GPUs currently available for immediate provisioning, according to the supplied endpoint notes.

6. Hardware Specifications: Use ram_gb, vcpus, and vram_gb to review specs reported for each offer.

7. Variable Offer Fields: The fields inside an offer may vary depending on the latest marketplace inventory. Handle optional or missing fields in your application.

8. Empty Results: If no GPU offers are available, API returns an empty offers array with count equal to 0.

9. API Key Security: Keep your API key confidential and store it in the DATAOORTS_API_KEY environment variable rather than hardcoding it in your application.

Error Handling

API may return unsuccessful HTTP status code & JSON error response when a request cannot be completed.

Application should handle authentication failure, missing tokens, server errors, & unexpected response formats.

In Python, response.raise_for_status() raises an exception for unsuccessful HTTP status codes. The example also checks response content type & handles JSON decoding errors before processing the offer data.

Missing API Key

HTTP Status: 401 Unauthorized

JSON

{
  "status": "error",
  "message": "Authorization header with 'Bearer <TOKEN>' is required."
}

Include the Authorization header with a valid Bearer token.

Missing Token

HTTP Status: 401 Unauthorized

JSON

{
  "status": "error",
  "message": "API Token is missing or empty."
}

Ensure that the API token is present and non-empty.

Invalid API Key

HTTP Status: 403 Forbidden

JSON

{
  "status": "error",
  "message": "Unauthorized: Invalid API key."
}

Verify that your Dataoorts API key is valid and included in the request header.

Internal Server Error

HTTP Status: 500 Internal Server Error

JSON

{
  "status": "error",
  "message": "Internal Server Error, Please Contact Support."
}

If the error persists, contact the Dataoorts support team for assistance.

General Error Handling

Scenario	Recommended Handling
API key is missing	Include the Authorization header with a valid Bearer token.
Token is empty	Set a non-empty DATAOORTS_API_KEY environment variable.
API key is invalid	Verify the API key through the Dataoorts platform.
HTTP request fails	Catch requests.exceptions.RequestException and inspect the error details.
Response is not JSON	Inspect the returned response text without attempting to parse it as JSON.
Response contains invalid JSON	Handle JSON decoding error before accessing response fields.
No offers are returned	Check count and offers; an empty list with a count of 0 indicates no offers were returned.

Get Help and Support

For assistance with Z-Series GPU offers or API integration, Contact support team at [email protected].