> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Manage resources

> <Badge color="blue" shape="pill">Early access</Badge>

Inspect GPU capacity, jobs, services, secrets, volumes, and usage with the MKA1 SDKs.


Use these examples alongside [Run a fine-tune job](/docs/compute-fine-tune-job), [Deploy a model server](/docs/compute-deployment), and [Reinforcement learning](/docs/compute-reinforcement-learning).
Those guides cover creating workloads; this page covers shared resource management.

The CLI examples assume an [authenticated MKA1 CLI](/docs/cli/authentication).

## Inspect an accelerator

Use a name returned by the accelerator catalog.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  import { SDK } from '@meetkai/mka1';

  const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

  const result = await sdk.computeCatalog.getAccelerator({
    "name": "nvidia-rtx-4090-24gb"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.name);
  ```

  ```python Python SDK theme={null}
  from meetkai_mka1 import models
  import os
  from meetkai_mka1 import SDK

  sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

  result = sdk.compute_catalog.get_accelerator(
      name="nvidia-rtx-4090-24gb",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.name)
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;
  using Newtonsoft.Json;
  using MeetKai.MKA1;

  var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

  var response = await sdk.ComputeCatalog.GetAcceleratorAsync(name: "nvidia-rtx-4090-24gb");
  var result = response.ComputeAccelerator
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Name));
  ```

  ```bash CLI theme={null}
  mka1 compute-catalog get-accelerator \
    --name nvidia-rtx-4090-24gb \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/catalog/accelerators/nvidia-rtx-4090-24gb" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect offers

Availability is an observation, not a reservation. Detailed offer and provider discovery can be unavailable on deployments that hide provider information; use the public quote operation in that case.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeCatalog.listComputeOffers({
    "accelerator": "nvidia-rtx-4090-24gb",
    "gpuCount": 1
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_catalog.list_compute_offers(
      accelerator="nvidia-rtx-4090-24gb",
      gpu_count=1,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = new ListComputeOffersRequest
  {
      Accelerator = "nvidia-rtx-4090-24gb",
      GpuCount = 1,
      Limit = 50,
  };

  var response = await sdk.ComputeCatalog.ListComputeOffersAsync(request);
  var result = response.ComputeOfferList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-catalog list-compute-offers \
    --accelerator nvidia-rtx-4090-24gb \
    --gpu-count 1 \
    --limit 50 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/catalog/offers?accelerator=nvidia-rtx-4090-24gb&gpu_count=1" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect providers

Provider entries describe the configured backend; they do not promise capacity for a particular job.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeCatalog.listComputeProviders({});
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_catalog.list_compute_providers()
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeCatalog.ListComputeProvidersAsync();
  var result = response.ComputeProviderHealthList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-catalog list-compute-providers \
    --limit 50 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/catalog/providers" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## List jobs

Read the first page. For subsequent pages, pass the returned `next_cursor` as `cursor` until it is null. The SDK does not automatically traverse these lists.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeJobs.listJobs({
    "limit": 20
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_jobs.list_jobs(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeJobs.ListJobsAsync(limit: 20);
  var result = response.ComputeJobList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-jobs list-jobs \
    --limit 20 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/jobs?limit=20" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## List services

Use the same cursor pattern for services.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeServices.listServices({
    "limit": 20
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_services.list_services(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeServices.ListServicesAsync(limit: 20);
  var result = response.ComputeServiceList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-services list-services \
    --limit 20 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/services?limit=20" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect job instances

Instance observations describe the hardware associated with a job; use them alongside lifecycle events when diagnosing provisioning.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeJobs.listJobInstances({
    "id": "job_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_jobs.list_job_instances(
      id="job_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = JsonConvert.DeserializeObject<ListJobInstancesRequest> ("""
  {
    "id": "job_REPLACE"
  }
  """)!;

  var response = await sdk.ComputeJobs.ListJobInstancesAsync(request);
  var result = response.ComputeInstanceList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-jobs list-job-instances \
    --id job_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/jobs/job_REPLACE/instances" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Read service logs

Use `source=user` for application output or `source=system` for allocation and bootstrap output. Pass `next_cursor` as `cursor` to read more.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeServices.listServiceLogs({
    "source": "user",
    "order": "desc",
    "limit": 50,
    "id": "service_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_services.list_service_logs(
      source="user",
      order="desc",
      limit=50,
      id="service_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = JsonConvert.DeserializeObject<ListServiceLogsRequest> ("""
  {
    "source": "user",
    "order": "desc",
    "limit": 50,
    "id": "service_REPLACE"
  }
  """)!;

  var response = await sdk.ComputeServices.ListServiceLogsAsync(request);
  var result = response.ComputeLogList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-services list-service-logs \
    --id service_REPLACE \
    --limit 50 \
    --order desc \
    --source user \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/logs?source=user&order=desc&limit=50" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Read service events

Events describe lifecycle transitions. They are distinct from your server logs.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeServices.listServiceEvents({
    "id": "service_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_services.list_service_events(
      id="service_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = JsonConvert.DeserializeObject<ListServiceEventsRequest> ("""
  {
    "id": "service_REPLACE"
  }
  """)!;

  var response = await sdk.ComputeServices.ListServiceEventsAsync(request);
  var result = response.ComputeEventList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-services list-service-events \
    --id service_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/events" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect service instances

Inspect the observed instances for this service.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeServices.listServiceInstances({
    "id": "service_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_services.list_service_instances(
      id="service_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = JsonConvert.DeserializeObject<ListServiceInstancesRequest> ("""
  {
    "id": "service_REPLACE"
  }
  """)!;

  var response = await sdk.ComputeServices.ListServiceInstancesAsync(request);
  var result = response.ComputeInstanceList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-services list-service-instances \
    --id service_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/instances" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## List secrets

Only names, IDs, and key names are readable; stored values are not returned.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeSecrets.listComputeSecrets({
    "limit": 20
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_secrets.list_compute_secrets(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeSecrets.ListComputeSecretsAsync(limit: 20);
  var result = response.ComputeSecretList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-secrets list \
    --limit 20 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/secrets?limit=20" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect a secret

Use the returned key names when configuring `container.secret_env`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeSecrets.getComputeSecret({
    "id": "sec_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.keys);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_secrets.get_compute_secret(
      id="sec_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.keys)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeSecrets.GetComputeSecretAsync("sec_REPLACE");
  var result = response.ComputeSecret
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Keys));
  ```

  ```bash CLI theme={null}
  mka1 compute-secrets get \
    --id sec_REPLACE \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/secrets/sec_REPLACE" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Delete a secret

Delete a secret only when it is no longer needed for new workloads or provisioning. This removes the stored credential; it does not terminate existing jobs or services.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeSecrets.deleteComputeSecret({
    "id": "sec_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log('Request completed');
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_secrets.delete_compute_secret(
      id="sec_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print("Request completed")
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeSecrets.DeleteComputeSecretAsync("sec_REPLACE");
  Console.WriteLine("Request completed");
  ```

  ```bash CLI theme={null}
  mka1 compute-secrets delete \
    --id sec_REPLACE \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/secrets/sec_REPLACE" \
    --request DELETE \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Create a shared volume

Standalone volumes provide persistent shared storage on compatible placements. Confirm your deployment supports this capability before using it; a volume is not portable to every GPU provider. Creating and retaining storage can accrue charges independently of jobs.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  // Keep this value unchanged when retrying this request.
  const idempotencyKey = process.env.MKA1_REQUEST_ID;
  if (!idempotencyKey) throw new Error('Set MKA1_REQUEST_ID');

  const result = await sdk.computeVolumes.createStandaloneVolume({
    "idempotencyKey": idempotencyKey,
    "computeStandaloneVolumeCreate": {
      "name": "training-data"
    }
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.id);
  ```

  ```python Python SDK theme={null}
  idempotency_key = os.environ["MKA1_REQUEST_ID"]  # Reuse for retries.

  result = sdk.compute_volumes.create_standalone_volume(
      idempotency_key=idempotency_key,
      name="training-data",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.id)
  ```

  ```csharp C# SDK theme={null}
  var idempotencyKey = System.Environment.GetEnvironmentVariable("MKA1_REQUEST_ID")
      ?? throw new InvalidOperationException("Set MKA1_REQUEST_ID");

  // Deserialize the wire-format payload into the SDK request model.
  var body = JsonConvert.DeserializeObject<MeetKai.MKA1.Types.Components.ComputeStandaloneVolumeCreate> ("""
  {
    "name": "training-data"
  }
  """)!;

  var response = await sdk.ComputeVolumes.CreateStandaloneVolumeAsync(idempotencyKey, body);
  var result = response.ComputeStandaloneVolume
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Id));
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes create-standalone-volume \
    --idempotency-key "$MKA1_REQUEST_ID" \
    --output-format json \
    --body @- <<'JSON'
  {
    "name": "training-data"
  }
  JSON
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/volumes" \
    --request POST \
    --header "Authorization: Bearer $MKA1_API_KEY" \
    --header "Idempotency-Key: $MKA1_REQUEST_ID" \
    --header 'Content-Type: application/json' \
    --data '{"name": "training-data"}'
  ```
</CodeGroup>

## List volumes

Volumes are scoped to your organization.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeVolumes.listStandaloneVolumes({
    "limit": 20
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_volumes.list_standalone_volumes(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeVolumes.ListStandaloneVolumesAsync(limit: 20);
  var result = response.ComputeStandaloneVolumeList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes list-standalone-volumes \
    --limit 20 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/volumes?limit=20" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect a volume

Check volume state before launching a workload that depends on it.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeVolumes.getStandaloneVolume({
    "id": "vol_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.status);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_volumes.get_standalone_volume(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.status)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeVolumes.GetStandaloneVolumeAsync("vol_REPLACE");
  var result = response.ComputeStandaloneVolume
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Status));
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes get-standalone-volume \
    --id vol_REPLACE \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Inspect volume attachments

Attachments show the workloads that reference a volume.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeVolumes.listStandaloneVolumeAttachments({
    "id": "vol_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.data);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_volumes.list_standalone_volume_attachments(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

  ```csharp C# SDK theme={null}
  var request = JsonConvert.DeserializeObject<ListStandaloneVolumeAttachmentsRequest> ("""
  {
    "id": "vol_REPLACE"
  }
  """)!;

  var response = await sdk.ComputeVolumes.ListStandaloneVolumeAttachmentsAsync(request);
  var result = response.ComputeStandaloneVolumeAttachmentList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes list-standalone-volume-attachments \
    --id vol_REPLACE \
    --limit 50 \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE/attachments" \
    --request GET \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Delete a volume

This permanently deletes its data. Terminate attached workloads and wait for their attachments to become terminal first; deletion is refused while non-terminal attachments exist.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.computeVolumes.deleteStandaloneVolume({
    "id": "vol_REPLACE"
  });
  if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
  console.log(result.status);
  ```

  ```python Python SDK theme={null}
  result = sdk.compute_volumes.delete_standalone_volume(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.status)
  ```

  ```csharp C# SDK theme={null}
  var response = await sdk.ComputeVolumes.DeleteStandaloneVolumeAsync("vol_REPLACE");
  var result = response.ComputeStandaloneVolume
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Status));
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes delete-standalone-volume \
    --id vol_REPLACE \
    --output-format json
  ```

  ```bash Bash theme={null}
  curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE" \
    --request DELETE \
    --header "Authorization: Bearer $MKA1_API_KEY"
  ```
</CodeGroup>

## Mount a volume in a workload

Add the following field to the complete job or service creation body from the workload guides, using a placement compatible with the volume:

```json Volume mount field theme={null}
{
  "volumes": [
    {"volume_id": "vol_REPLACE", "mount_path": "/workspace/data"}
  ]
}
```

This is a request fragment, not a complete create request.
The TypeScript SDK uses `volumeId` and `mountPath`; Python uses `volume_id` and `mount_path`.
C# uses `ComputeStandaloneVolumeMount` with `VolumeId` and `MountPath`.
Your container must read and write under the mount path to use persistent storage.
For workflows on external GPU capacity without compatible volume support, publish artifacts to [repositories](/docs/repositories).

## Usage and administration

Use the [job usage](/docs/compute-fine-tune-job#track-spend) or [service usage](/docs/compute-deployment#track-spend) examples; select `volume` as the resource type to inspect volume usage where supported.
Tenant enablement and pricing administration require elevated permissions. Their complete schemas are in the Compute Tenants and Compute Pricing groups of the [API reference](/api-reference/introduction).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.