Get All Available offers

Get All Instance Offers - Overview

The Get All Instance Offers endpoint retrieves all available Atlas Series GPU instance offers from Dataoorts. The response includes the available GPU configurations, GPU models, GPU counts, hourly pricing, deployment type, operating system image, and storage capacity.

Use this endpoint to review available Atlas Series configurations and their pricing before creating an pod.

Endpoint

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

Full URL:

GET https://cloud.dataoorts.com/api/v1/atlas/offers

Authentication

This endpoint requires a valid Dataoorts API key. Include the API key in the Authorization header using the Bearer authentication scheme.

Authorization: Bearer YOUR_API_KEY

You can obtain your API key from the Dataoorts Unify API.

Request Parameters

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

Parameter	Type	Required	Description
Authorization	Header	Yes	Bearer token containing your Dataoorts API key.

Request Examples

cURL - Use the following command to retrieve all Altas pods configs

curl -X GET "https://cloud.dataoorts.com/api/v1/atlas/offers" \
  -H "Authorization: Bearer YOUR_API_KEY"

Python Example Implementation

The following Python example retrieves all available Atlas Series GPU offers, uses an environment variable for authentication, and handles HTTP and JSON parsing errors.

import os
import json
import requests
from typing import Any

BASE_URL = "https://cloud.dataoorts.com"
API_KEY = os.getenv("DATAOORTS_API_KEY")


def get_atlas_offers() -> dict[str, Any]:
    """
    Retrieve all available Atlas Series GPU instance offers.

    Returns:
        The parsed JSON response containing Atlas GPU offers.

    Raises:
        ValueError: If the API key is not configured or the
                    response contains invalid JSON.
        requests.RequestException: If the HTTP request fails.
    """
    if not API_KEY:
        raise ValueError(
            "DATAOORTS_API_KEY environment variable is not set."
        )

    url = f"{BASE_URL}/api/v1/atlas/offers"
    headers = {
        "Authorization": f"Bearer {API_KEY}"
    }

    try:
        response = requests.get(
            url,
            headers=headers,
            timeout=60,
        )
        response.raise_for_status()

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

        print(json.dumps(data, indent=2))
        return data

    except requests.RequestException as exc:
        print(f"Failed to retrieve Atlas GPU offers: {exc}.")
        raise


if __name__ == "__main__":
    get_atlas_offers()

Set your API key as an environment variable before running the script.

Linux or macOS:

export DATAOORTS_API_KEY="YOUR_API_KEY"

Windows PowerShell:

$env:DATAOORTS_API_KEY="YOUR_API_KEY"

Example Success Response

The following example illustrates a successful response containing four Atlas Series GPU offers.

{
  "count": 4,
  "currency": "USD",
  "message": "Live Atlas GPU offers retrieved for you successfully.",
  "offers": [
    {
      "config_id": "1xB200-180GB",
      "display_name": "1xB200-180GB",
      "gpu_count": 1,
      "hourly_price": 2.49,
      "specs": {
        "deployment_type": "Pod",
        "gpu_model": "B200",
        "os_image": "Ubuntu-Torch",
        "storage_gb": 10240
      }
    },
    {
      "config_id": "2xB200-180GB",
      "display_name": "2xB200-180GB",
      "gpu_count": 2,
      "hourly_price": 4.98,
      "specs": {
        "deployment_type": "Pod",
        "gpu_model": "B200",
        "os_image": "Ubuntu-Torch",
        "storage_gb": 19456
      }
    },
    {
      "config_id": "4xB200-180GB",
      "display_name": "4xB200-180GB",
      "gpu_count": 4,
      "hourly_price": 9.96,
      "specs": {
        "deployment_type": "Pod",
        "gpu_model": "B200",
        "os_image": "Ubuntu-Torch",
        "storage_gb": 38912
      }
    },
    {
      "config_id": "8xB200-180GB",
      "display_name": "8xB200-180GB",
      "gpu_count": 8,
      "hourly_price": 19.92,
      "specs": {
        "deployment_type": "Pod",
        "gpu_model": "B200",
        "os_image": "Ubuntu-Torch",
        "storage_gb": 76800
      }
    }
  ],
  "status": "success"
}

The number of offers & their pricing may differ from this example depending on the data returned by the API.

Response Fields

Top-Level Response Fields

Field	Type	Description
`count`	Integer	Number of offers included in the response.
`currency`	String	Currency used for the listed prices, such as `USD`.
`message`	String	Message describing the result of the request.
`offers`	Array	Collection of available Atlas Series GPU instance offers.
`status`	String	Indicates the result of API request. The example returns `success`.

Offer Fields

Each object in the offers array represents a GPU instance configuration.

Field	Type	Description
`config_id`	String	Identifier of the GPU configuration.
`display_name`	String	Display name of the configuration.
`gpu_count`	Integer	Number of GPUs included in the configuration.
`hourly_price`	Float	Hourly price for the config, expressed in the response currency.
`specs`	Object	Hardware, deployment, and operating system details for the config.

Specification Fields

The specs object provides additional information about each GPU configuration.

Field	Type	Description
`deployment_type`	String	Deployment type for the offer, such as `Pod`.
`gpu_model`	String	GPU model included in the configuration, such as `B200`.
`os_image`	String	Pod Image associated with the offer, such as `Ubuntu-Torch`.
`storage_gb`	Integer	NVMe Storage capacity specified for the configuration, in GiB.

Understanding Atlas GPU Offers

GPU Configuration

The config_id and display_name fields identify each configuration. In the example response, the available configurations include one, two, four, and eight B200 GPUs.

Hourly Pricing

The hourly_price field provides the listed hourly price for each configuration. The response's currency field indicates the currency used for these prices.

Hardware and Deployment Specifications

Use the specs object to review the GPU model, deployment type, operating system image, and storage capacity associated with an offer.

Important Notes

This endpoint retrieves Atlas Series GPU offers; it does not create or launch pod.
Authentication through the Bearer API token is required.
No query parameters or request body are required.
The count field indicates how many offers are returned in the response.
The listed hourly prices are expressed in the currency specified by currency.
Use the returned configuration identifiers and specifications when reviewing offers. Do not assume that the sample configurations or prices will always remain unchanged.
Keep your API key private. Store it in an environment variable rather than hardcoding it in your code base.

Error Handling

Your application should handle unsuccessful HTTP responses and unexpected response formats.

Scenario	Recommended Handling
API key is missing	Set the`API_KEY` environment variable before running the request.
Authentication fails	Verify that the API Key Token is valid and included in the `Authorization` header.
HTTP request fails	Catch `requests.RequestException` and inspect the returned error details.
Response contains invalid JSON	Handle the JSON parsing error before accessing response fields.
No offers are returned	Check the `count` and `offers` fields in the response before processing the results.

The Python example uses response.raise_for_status() to detect unsuccessful HTTP status codes and validates the JSON response before returning the data.

Get Help and Support

For assistance with the Atlas Series API, Contact our support team at [email protected].