> 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 a fileset from the platform.
Returns metadata about the deleted fileset.
For local storage backends, this also deletes the underlying files.

Reference: https://docs.nvidia.com/nemo-platform/nemo-platform/v0.3.0/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`, `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.
- `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": {
    "read_chunk_size": 1048576,
    "type": "local",
    "path": "string",
    "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
      }
    }
  },
  "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()
```