Struct RunpodClient 

pub struct RunpodClient { /* private fields */ }

Main client struct for interacting with RunPod.

Implementations

impl RunpodClient

pub fn new(api_key: impl Into<String>) -> Self

Construct a new RunpodClient with your API key.

pub async fn list_gpu_types_graphql( &self, ) -> Result<GPUTypesListResponseData, Error>

List GPU Types (only available in GraphQL).

pub async fn get_gpu_type_graphql( &self, gpu_type_id: &str, ) -> Result<GPUTypeResponseData, Error>

Get GPU Type by ID (only available in GraphQL).

pub async fn delete_pod(&self, pod_id: &str) -> Result<(), Error>

Delete a Pod by ID.

pub async fn list_datacenters_with_gpu_availability( &self, ) -> Result<DatacentersResponseData, Error>

List all datacenters with GPU availability. If you only need to filter on a single GPU type ID, you can pass it in as a string. Otherwise, see the “GpuAvailabilityInput” example above. List all datacenters with all GPU availability.

pub async fn fetch_my_pods(&self) -> Result<GraphQLResponse<Value>, Error>

Executes the “myPods” GraphQL query against RunPod’s API.

Returns a GraphQLResponse<serde_json::Value>, allowing you to parse the results as desired. If you want typed responses, replace serde_json::Value with your own deserialized struct that matches the query’s return shape.

pub async fn fetch_all_datacenters( &self, input: Option<GpuAvailabilityInput>, ) -> Result<GraphQLResponse<Value>, Error>

Exactly replicates the request:

operationName: “getAllDatacenters” query: query getAllDatacenters($input: GpuAvailabilityInput) { dataCenters { id name location storageSupport gpuAvailability(input: $input) { stockStatus gpuTypeId gpuTypeDisplayName displayName __typename } __typename } } variables: { “input”: { “gpuCount”: 1, “minDisk”: 0, “minMemoryInGb”: 8, “minVcpuCount”: 2, “secureCloud”: true, “includeAiApi”: false } }

Returns the raw JSON-serialized GraphQL response as a serde_json::Value.

pub async fn get_pod_host_id( &self, container_id: &str, ) -> Result<Option<String>, Box<dyn Error + Send + Sync>>

Fetches the podHostId for a given container (pod) ID by scanning the results of fetch_my_pods(). Returns Ok(Some(pod_host_id)) if found, Ok(None) otherwise.

pub async fn fetch_my_pod( &self, pod_id: &str, ) -> Result<GraphQLResponse<Value>, Error>

Fetch a single RunPod Pod by ID using pod(input: PodFilter), returning all fields shown in your example schema snippet, inlined (no separate fragments needed).

pub fn parse_datacenters_response( &self, raw: GraphQLResponse<Value>, ) -> Result<GraphQLResponse<DataCentersRoot>, Error>

pub async fn get_all_datacenters_query( &self, input: Option<GpuAvailabilityInput>, ) -> Result<GetAllDatacentersResponse, Error>

Fetch all data centers with optional GPU availability filtering.

This uses the query:

query getAllDatacenters($input: GpuAvailabilityInput) {
  dataCenters {
    id
    name
    location
    storageSupport
    gpuAvailability(input: $input) {
      stockStatus
      gpuTypeId
      gpuTypeDisplayName
      displayName
      __typename
    }
    __typename
  }
}

The GpuAvailabilityInput struct below is just an example.
Adjust the fields to match exactly what your RunPod GraphQL schema expects.

pub async fn fetch_my_pods_with_ports( &self, ) -> Result<GraphQLResponse<PodsWithPortsData>, Error>

pub async fn create_on_demand_pod( &self, req: CreateOnDemandPodRequest, ) -> Result<PodCreateResponseData, Error>

Create an on-demand (reserved) Pod using the REST API.

pub async fn create_spot_pod( &self, req: CreateSpotPodRequest, ) -> Result<PodCreateResponseData, Error>

Create a spot/interruptible Pod using the REST API.

pub async fn start_pod( &self, pod_id: &str, ) -> Result<PodStartResponseData, Error>

Start (Resume) a Pod. REST does not differentiate on-demand vs. spot.

pub async fn stop_pod(&self, pod_id: &str) -> Result<PodStopResponseData, Error>

Stop a Pod.

pub async fn list_pods(&self) -> Result<PodsListResponseData, Error>

List all Pods.

pub async fn get_container_logs( &self, container_id: &str, ) -> Result<String, Error>

pub async fn find_datacenters_with_desired_gpu( &self, desired_gpu_type_id: &str, desired_count: i32, ) -> Result<Vec<DataCenterItem>, Box<dyn Error>>

pub async fn get_pod(&self, pod_id: &str) -> Result<PodInfoResponseData, Error>

Get a Pod by ID.

pub async fn create_network_volume( &self, req: NetworkVolumeCreateInput, ) -> Result<NetworkVolume, Error>

Create a new Network Volume.

pub async fn ensure_volume_in_datacenter( &self, volume_name: &str, data_center_id: &str, desired_size: i32, ) -> Result<NetworkVolume, Error>

Ensures that a volume of a given name and size exists in the specified datacenter.

• If the volume already exists, checks if it’s smaller than desired_size.
• If smaller, it updates (resizes) it.
• If no volume exists, creates a new one.

Returns the final (existing or newly-created) NetworkVolume.

pub async fn list_network_volumes(&self) -> Result<Vec<NetworkVolume>, Error>

List all Network Volumes.

pub async fn get_network_volume( &self, network_volume_id: &str, ) -> Result<NetworkVolume, Error>

Get a specific Network Volume by ID.

pub async fn find_volume_by_name_in_datacenter( &self, volume_name: &str, data_center_id: &str, ) -> Result<Option<NetworkVolume>, Error>

Attempts to find a volume by name within a specific datacenter.

Returns Ok(Some(NetworkVolume)) if found, or Ok(None) if no match.

pub async fn update_network_volume( &self, network_volume_id: &str, req: NetworkVolumeUpdateInput, ) -> Result<NetworkVolume, Error>

Update (rename or resize) a Network Volume.
For resizing, you must specify a size greater than the current size.

pub async fn delete_network_volume( &self, network_volume_id: &str, ) -> Result<(), Error>

Delete a Network Volume by ID.

pub async fn list_endpoints(&self) -> Result<Endpoints, Error>

List all Endpoints.

pub async fn get_endpoint(&self, endpoint_id: &str) -> Result<Endpoint, Error>

Get a specific Endpoint by ID.

pub async fn create_endpoint( &self, req: EndpointCreateInput, ) -> Result<Endpoint, Error>

Create a new Endpoint.

pub async fn update_endpoint( &self, endpoint_id: &str, req: EndpointUpdateInput, ) -> Result<Endpoint, Error>

Update (patch) an existing Endpoint by ID.

pub async fn delete_endpoint(&self, endpoint_id: &str) -> Result<(), Error>

Delete an Endpoint by ID.

Trait Implementations

impl Clone for RunpodClient

fn clone(&self) -> RunpodClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.