> ## 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 examples assume an initialized `sdk` client and an authenticated [MKA1 CLI](/docs/cli/authentication).

## Inspect an accelerator

Use a name returned by the accelerator catalog.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  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);
  ```

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

  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));
  ```

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

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

  ```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"
  ```

  ```bash CLI theme={null}
  mka1 compute-catalog get-accelerator \
    --name nvidia-rtx-4090-24gb \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  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)
  ```

  ```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"
  ```

  ```bash CLI theme={null}
  mka1 compute-catalog list-compute-offers \
    --accelerator nvidia-rtx-4090-24gb \
    --gpu-count 1 \
    --limit 50 \
    --output-format json
  ```
</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);
  ```

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

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

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

  result = sdk.compute_catalog.list_compute_providers()
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-catalog list-compute-providers \
    --limit 50 \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeJobs.ListJobsAsync(limit: 20);
  var result = response.ComputeJobList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

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

  result = sdk.compute_jobs.list_jobs(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-jobs list-jobs \
    --limit 20 \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeServices.ListServicesAsync(limit: 20);
  var result = response.ComputeServiceList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

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

  result = sdk.compute_services.list_services(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-services list-services \
    --limit 20 \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  result = sdk.compute_jobs.list_job_instances(
      id="job_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-jobs list-job-instances \
    --id job_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  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)
  ```

  ```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"
  ```

  ```bash CLI theme={null}
  mka1 compute-services list-service-logs \
    --id service_REPLACE \
    --limit 50 \
    --order desc \
    --source user \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  result = sdk.compute_services.list_service_events(
      id="service_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-services list-service-events \
    --id service_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  result = sdk.compute_services.list_service_instances(
      id="service_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-services list-service-instances \
    --id service_REPLACE \
    --limit 50 \
    --order asc \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeSecrets.ListComputeSecretsAsync(limit: 20);
  var result = response.ComputeSecretList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

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

  result = sdk.compute_secrets.list_compute_secrets(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-secrets list \
    --limit 20 \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeSecrets.GetComputeSecretAsync("sec_REPLACE");
  var result = response.ComputeSecret
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Keys));
  ```

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

  result = sdk.compute_secrets.get_compute_secret(
      id="sec_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.keys)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-secrets get \
    --id sec_REPLACE \
    --output-format json
  ```
</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');
  ```

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

  var response = await sdk.ComputeSecrets.DeleteComputeSecretAsync("sec_REPLACE");
  Console.WriteLine("Request completed");
  ```

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

  result = sdk.compute_secrets.delete_compute_secret(
      id="sec_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print("Request completed")
  ```

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

  ```bash CLI theme={null}
  mka1 compute-secrets delete \
    --id sec_REPLACE \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  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)
  ```

  ```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"}'
  ```

  ```bash CLI theme={null}
  mka1 compute-volumes create-standalone-volume \
    --idempotency-key "$MKA1_REQUEST_ID" \
    --output-format json \
    --body @- <<'JSON'
  {
    "name": "training-data"
  }
  JSON
  ```
</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);
  ```

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

  var response = await sdk.ComputeVolumes.ListStandaloneVolumesAsync(limit: 20);
  var result = response.ComputeStandaloneVolumeList
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Data));
  ```

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

  result = sdk.compute_volumes.list_standalone_volumes(
      limit=20,
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-volumes list-standalone-volumes \
    --limit 20 \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeVolumes.GetStandaloneVolumeAsync("vol_REPLACE");
  var result = response.ComputeStandaloneVolume
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Status));
  ```

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

  result = sdk.compute_volumes.get_standalone_volume(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.status)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-volumes get-standalone-volume \
    --id vol_REPLACE \
    --output-format json
  ```
</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);
  ```

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

  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));
  ```

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

  result = sdk.compute_volumes.list_standalone_volume_attachments(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.data)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-volumes list-standalone-volume-attachments \
    --id vol_REPLACE \
    --limit 50 \
    --output-format json
  ```
</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);
  ```

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

  var response = await sdk.ComputeVolumes.DeleteStandaloneVolumeAsync("vol_REPLACE");
  var result = response.ComputeStandaloneVolume
      ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
  Console.WriteLine(JsonConvert.SerializeObject(result.Status));
  ```

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

  result = sdk.compute_volumes.delete_standalone_volume(
      id="vol_REPLACE",
  )
  if isinstance(result, models.ComputeErrorEnvelope):
      raise RuntimeError(result.error)
  print(result.status)
  ```

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

  ```bash CLI theme={null}
  mka1 compute-volumes delete-standalone-volume \
    --id vol_REPLACE \
    --output-format json
  ```
</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).