> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo-platform/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo-platform/_mcp/server.

# Delete Fileset

DELETE /apis/files/v2/workspaces/{workspace}/filesets/{name}

Delete Fileset.

Permanently deletes an unreferenced fileset from the platform.
Referencing model or adapter entities must be relinked or deleted first.
Returns metadata about the deleted fileset.
For local storage backends, this also deletes the underlying files.

Reference: https://docs.nvidia.com/nemo-platform/documentation/reference/api-reference/files/delete-fileset-apis-files-v-2-workspaces-workspace-filesets-name-delete

## Request

### Path parameters

- `workspace` (string, required)
- `name` (string, required)

## Response

### 200

Successful Response

- `id` (string, required)
- `name` (string, required)
- `workspace` (string, required)
- `description` (string, required)
- `purpose` (enum, required)
  - Allowed values: `dataset`, `environment`, `generic`, `model`
- `storage` (object or object or object or object, required)
  - LocalStorageConfig
    - `path` (string, required)
    - `read_chunk_size` (integer, optional, default: 1048576) — Chunk size in bytes for reading/streaming files. Larger chunks reduce async overhead but increase memory per concurrent download. Default: 1MB.
    - `type` ("local", optional, default: local)
    - `write_buffer_size` (integer, optional, default: 16777216) — How many bytes to buffer before flushing to disk
  - NGCStorageConfig
    - `org` (string, required) — NGC organization name
    - `team` (string, required) — NGC team name
    - `target` (string, required) — NGC asset name (model or resource)
    - `api_key_secret` (string, required) — NGC API key secret name
    - `read_chunk_size` (integer, optional, default: 1048576) — Chunk size in bytes for reading/streaming files. Larger chunks reduce async overhead but increase memory per concurrent download. Default: 1MB.
    - `type` ("ngc", optional, default: ngc)
    - `target_type` (enum, optional, default: resource) — Type of NGC asset: 'resource' or 'model'
      - Allowed values: `resource`, `model`
    - `version` (string, optional) — NGC asset version. If not provided, defaults to latest version
    - `original_version` (string, optional) — The original version requested by the user before resolution (e.g., 'latest' or None). The 'version' field contains the resolved version ID.
    - `host` (string, optional, default: https://api.ngc.nvidia.com) — NGC API host URL
  - HuggingfaceStorageConfig
    - `repo_id` (string, required) — Huggingface repository ID (e.g., 'meta-llama/Llama-2-7b')
    - `read_chunk_size` (integer, optional, default: 1048576) — Chunk size in bytes for reading/streaming files. Larger chunks reduce async overhead but increase memory per concurrent download. Default: 1MB.
    - `type` ("huggingface", optional, default: huggingface)
    - `repo_type` (enum, optional, default: model) — Type of Huggingface repository: 'model', 'dataset', or 'space'
      - Allowed values: `model`, `dataset`, `space`
    - `revision` (string, optional, default: main) — Branch, tag, or commit SHA. Defaults to 'main'
    - `original_revision` (string, optional) — The original revision requested by the user before resolution (e.g., 'main'). The 'revision' field contains the resolved commit SHA.
    - `token_secret` (string, optional) — Huggingface API `token` secret name for private repositories
    - `endpoint` (string, optional, default: https://huggingface.co) — Huggingface Hub endpoint URL. Use for self-hosted instances.
  - S3StorageConfig
    - `bucket` (string, required) — S3 bucket name
    - `read_chunk_size` (integer, optional, default: 1048576) — Chunk size in bytes for reading/streaming files. Larger chunks reduce async overhead but increase memory per concurrent download. Default: 1MB.
    - `type` ("s3", optional, default: s3)
    - `prefix` (string, optional, default: ) — Optional prefix (folder path) within the bucket. All operations will be relative to this prefix.
    - `region` (string, optional) — AWS region. If not specified, uses SDK default (env vars, instance metadata, etc.)
    - `endpoint_url` (string, optional) — Custom endpoint URL for S3-compatible storage (e.g., MinIO, Garage, RustFS). If not specified, uses AWS S3.
    - `use_sdk_auth` (boolean, optional, default: false) — Use AWS SDK credential chain for authentication (env vars like AWS_ACCESS_KEY_ID, IAM roles, instance profiles, etc.). This option is only available for the platform's default storage backend. User-provided S3 storage must use explicit credentials via access_key_id_secret and secret_access_key_secret.
    - `access_key_id_secret` (string, optional) — Secret reference for AWS access key ID. Requires use_sdk_auth=False.
    - `secret_access_key_secret` (string, optional) — Secret reference for AWS secret access key. Requires use_sdk_auth=False.
    - `signature_version` (enum, optional, default: s3v4) — AWS signature version for request signing. Use 's3' for legacy systems that only support signature v2.
      - Allowed values: `s3v4`, `s3`
- `metadata` (object, required) — Tagged metadata container - the key indicates the type. Example: metadata = FilesetMetadata( dataset=DatasetMetadataContent( schema=\{"columns": \["id", "name"]}, ) )
  - `dataset` (object, optional) — Content for dataset-type filesets.
    - `schema` (map from string to any or string, optional) — Default row schema for files in this fileset, either inline JSON Schema or a schema_defs key.
    - `schema_defs` (map from string to map from string to any, optional) — Reusable JSON Schema definitions keyed by name for deduplicating per-file dataset schemas.
    - `schemas_by_path` (map from string to map from string to any or string, optional) — Optional per-file row schemas keyed by relative path within the fileset. Each value may be inline JSON Schema or a schema_defs key.
  - `model` (object, optional) — Content for model-type filesets. Contains tool calling configuration that is merged into the ModelSpec during checkpoint analysis.
    - `tool_calling` (object, optional) — Content for tool-calling configuration on model filesets. Stores chat template and tool calling settings that are merged into the ModelSpec during checkpoint analysis.
      - `chat_template` (string, optional) — Jinja2 chat template for the model.
      - `tool_call_parser` (string, optional) — Name of the tool call parser (e.g., 'openai', 'hermes', 'pythonic', 'llama3_json', 'mistral').
      - `tool_call_plugin` (string, optional) — Reference to a fileset containing a custom tool call plugin Python file. Expected format: '\{workspace}/\{fileset\_name}'.
      - `auto_tool_choice` (boolean, optional) — Whether to enable automatic tool choice.
  - `environment` (object, optional) — Content for environment-type filesets (GRPO Gym packages).
    - `format` (string, required) — Environment package format (native-v1, wheels-v1, adapter-wheels-v1).
    - `name` (string, required)
    - `adapter_agent` (string, optional)
    - `hub_id` (string, optional)
    - `vf_env_id` (string, optional)
    - `config_paths` (list of string, optional)
- `custom_fields` (map from string to any, required)
- `project` (string, required)
- `created_at` (string, required)
- `updated_at` (string, required)

## Examples

**Response**

```json
{
  "id": "string",
  "name": "string",
  "workspace": "string",
  "description": "string",
  "purpose": "dataset",
  "storage": {
    "path": "string",
    "read_chunk_size": 1048576,
    "type": "local",
    "write_buffer_size": 16777216
  },
  "metadata": {
    "dataset": {
      "schema": {},
      "schema_defs": {},
      "schemas_by_path": {}
    },
    "model": {
      "tool_calling": {
        "chat_template": "string",
        "tool_call_parser": "string",
        "tool_call_plugin": "string",
        "auto_tool_choice": true
      }
    },
    "environment": {
      "format": "string",
      "name": "string",
      "adapter_agent": "string",
      "hub_id": "string",
      "vf_env_id": "string",
      "config_paths": [
        "string"
      ]
    }
  },
  "custom_fields": {},
  "project": "string",
  "created_at": "string",
  "updated_at": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name"

response = requests.delete(url)

print(response.json())
```

```javascript
const url = 'https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.delete("https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('DELETE', 'https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name');

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name");
var request = new RestRequest(Method.DELETE);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/apis/files/v2/workspaces/workspace/filesets/name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```