Get All Available Offers

This endpoint retrieves all available GPU pod and secure instance offers within the Yotta Series ecosystem. Offered in partnership with Yotta Labs, it provides real-time pricing (hourly_cost), display names, accelerator models (gpu_type), accelerator counts (gpu_count), and hardware specifications—including deployment type (Secure Pod), network configuration, and transparent per-gigabyte storage rates.

Get All Available Offers - Overview

The Yotta Series Offers API allows authenticated users to retrieve all available Yotta Series GPU pod offers. These instances are offered in partnership with Yotta and are listed according to the available configurations.

The endpoint returns the available GPU configurations, display names, GPU types, GPU counts, hourly costs, deployment types, network connection details, and storage pricing information.

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

Endpoint

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

Authentication

This endpoint requires a valid 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 available Yotta Series GPU Pods offers:

Bash

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

Replace YOUR_API_KEY with your actual Unify API key.

Python Example Implementation

The following example uses the requests library to retrieve all available Yotta Series GPU offers and display the returned offer configurations, GPU information, hourly costs, and specifications.

Install the required dependency:

Bash

pip install requests

Python

import os
import requests


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


def get_yotta_offers(api_key: str) -> dict:
    """
    Retrieve all available Yotta Series GPU offers.

    Args:
        api_key: Your Dataoorts Unify API key.

    Returns:
        dict: The JSON response containing available GPU offers.

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

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

    response.raise_for_status()

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

    if "application/json" not in content_type.lower():
        raise ValueError(
            "The API returned a non-JSON response: "
            f"{response.text[:500]}"
        )

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

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

        print("\nAvailable Yotta GPU Offers")

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

            print("-" * 40)
            print("Display Name:", offer.get("display_name"))
            print("GPU Type:", offer.get("gpu_type"))
            print("GPU Count:", offer.get("gpu_count"))
            print("Hourly Cost:", offer.get("hourly_cost"))
            print("Deployment Type:", specs.get("deployment_type"))
            print("Network:", specs.get("network"))
            print("Storage Cost:", specs.get("storage_cost"))

    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

Bash

export DATAOORTS_API_KEY="YOUR_API_KEY"
python yotta_offers.py

Windows PowerShell

PowerShell

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

The script displays the offer count and currency first, followed by each available GPU configuration, GPU type, GPU count, hourly cost, deployment type, network details, and storage pricing.

Example Success Response

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

JSON

{
  "count": 12,
  "currency": "USD",
  "message": "Live Yotta Pod offers retrieved for you successfully.",
  "offers": [
    {
      "display_name": "1x NVIDIA_H200_141G",
      "gpu_count": 1,
      "gpu_type": "NVIDIA_H200_141G",
      "hourly_cost": 2.19,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "2x NVIDIA_H200_141G",
      "gpu_count": 2,
      "gpu_type": "NVIDIA_H200_141G",
      "hourly_cost": 4.38,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "4x NVIDIA_H200_141G",
      "gpu_count": 4,
      "gpu_type": "NVIDIA_H200_141G",
      "hourly_cost": 8.76,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "8x NVIDIA_H200_141G",
      "gpu_count": 8,
      "gpu_type": "NVIDIA_H200_141G",
      "hourly_cost": 17.52,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "1x NVIDIA_RTX_PRO_6000_96G",
      "gpu_count": 1,
      "gpu_type": "NVIDIA_RTX_PRO_6000_96G",
      "hourly_cost": 1.44,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "2x NVIDIA_RTX_PRO_6000_96G",
      "gpu_count": 2,
      "gpu_type": "NVIDIA_RTX_PRO_6000_96G",
      "hourly_cost": 2.88,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "4x NVIDIA_RTX_PRO_6000_96G",
      "gpu_count": 4,
      "gpu_type": "NVIDIA_RTX_PRO_6000_96G",
      "hourly_cost": 5.76,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "8x NVIDIA_RTX_PRO_6000_96G",
      "gpu_count": 8,
      "gpu_type": "NVIDIA_RTX_PRO_6000_96G",
      "hourly_cost": 11.52,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "1x NVIDIA_A100_80G",
      "gpu_count": 1,
      "gpu_type": "NVIDIA_A100_80G",
      "hourly_cost": 0.99,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "2x NVIDIA_A100_80G",
      "gpu_count": 2,
      "gpu_type": "NVIDIA_A100_80G",
      "hourly_cost": 1.98,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "4x NVIDIA_A100_80G",
      "gpu_count": 4,
      "gpu_type": "NVIDIA_A100_80G",
      "hourly_cost": 3.96,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    },
    {
      "display_name": "8x NVIDIA_A100_80G",
      "gpu_count": 8,
      "gpu_type": "NVIDIA_A100_80G",
      "hourly_cost": 7.92,
      "specs": {
        "deployment_type": "Secure Pod",
        "network": "SSH (Port 22)",
        "storage_cost": "$0.0002 / GiB / Hour"
      }
    }
  ],
  "status": "success"
}

The values above illustrate the response structure. The number of offers, GPU configurations, and pricing may differ in subsequent API responses.

Response Fields

Field	Type	Description
status	String	Indicates the result of the API request. A successful response returns success.
message	String	A descriptive message about the result of the request.
count	Integer	Number of offers included in the response.
currency	String	Currency used for the listed hourly costs, such as USD.
offers	Array of objects	Contains the available Yotta Series GPU instance offers returned by the API.

Offer Fields

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

Field	Type	Description
display_name	String	Display name of the GPU configuration, such as 1x NVIDIA_H200_141G.
gpu_type	String	GPU model associated with the offer, such as NVIDIA_H200_141G, NVIDIA_RTX_PRO_6000_96G, or NVIDIA_A100_80G.
gpu_count	Integer	Number of GPUs included in the configuration.
hourly_cost	Float	Hourly cost reported for the GPU configuration.
specs	Object	Contains deployment, network, & storage pricing details for the offer.

Specification Fields

The specs object provides additional information about the deployment configuration, network access, and storage pricing.

Field	Type	Description
specs.deployment_type	String	Deployment type associated with offer, such as Secure Pod.
specs.network	String	Network connection information returned for the offer, such as SSH (Port 22).
specs.storage_cost	String	Storage pricing information returned for the offer, such as $0.0002 / GiB / Hour.

Understanding Yotta GPU Offers

GPU Configurations

The display_name, gpu_type, and gpu_count fields identify the available GPU configurations.

The example response includes configurations for NVIDIA H200 141G, NVIDIA RTX PRO 6000 96G, and NVIDIA A100 80G GPUs. Each model is listed with configurations containing one, two, four, and eight GPUs.

Hourly Cost

The hourly_cost field reports the hourly cost associated with the GPU configuration. The response's currency field identifies the currency used for these costs.

Deployment and Network Details

The deployment_type field identifies the deployment type associated with an offer. In the example response, all offers use Secure Pod.

The network field provides the returned network connection details. The example specifies SSH (Port 22).

NVMe Storage Cost

The storage_cost field provides the storage pricing information returned for the offer. In the supplied response, the value is $0.0002 / GiB / Hour.

Review this field alongside hourly_cost when evaluating the pricing information for an offer.

Important Notes

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

2. Request Parameters: This endpoint does not require query parameters or a request body.

3. GPU Configurations: Use the returned display_name, gpu_type, and gpu_count fields to identify the available configurations.

4. Pricing Information: The hourly_cost field reports the hourly GPU configuration cost, while storage_cost provides the storage pricing information returned by the API.

5. Network Details: The example response specifies SSH (Port 22) for the network field. Refer to the returned offer details when reviewing connection information.

6. Current Offers: The endpoint returns the available offers at the time of the request. Do not assume the example configurations or prices will always remain unchanged.

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

If the request fails, the API may return an unsuccessful HTTP status code or a response that does not match the expected JSON format.

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. Example also checks the response content type and handles JSON decoding errors before processing the offer data.

Scenario	Recommended Handling
API key is missing	Set the DATAOORTS_API_KEY environment variable.
Authentication fails	Verify that the API key is valid and included in the Authorization header.
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 the JSON decoding error before accessing response fields.
No offers are returned	Check count and offers fields before processing the results.

Get Help and Support

For assistance with Yotta Series offers or API integration, Contact the support team at [email protected].