aziontech · egermano · May 21, 2026 · Aug 28, 2025 · Feb 10, 2026 · Feb 10, 2026
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)
@@ -0,0 +1,180 @@
+---
+title: Delete key-value pairs
+description: >-
+ To remove a key-value pair from KV Store, call the delete() method on your 
+ KV instance.
+meta_tags: 'kv store, api, functions, delete, remove, storage'
+namespace: documentation_runtime_kv_store_delete
+permalink: /documentation/runtime/api-reference/kv-store/delete/
+menu_namespace: runtimeMenu
+---
+
+To remove a key-value pair from KV Store, call the `delete()` method on your 
+KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+## Example
+
+An example of deleting a key-value pair from within a Function:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ try {
+ await kv.delete("user-session");
+
+ return new Response("Key deleted successfully", { status: 200 });
+ } catch (e) {
+ return new Response(e.message, { status: 500 });
+ }
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+---
+
+## Reference
+
+### `delete()` method
+
+To remove a key-value pair, call the `delete()` method on your KV instance:
+
+```javascript
+await kv.delete(key);
+```
+
+#### Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `key` | `string` | The key of the KV pair to delete. |
+
+#### Response
+
+| Response | Type | Description |
+|----------|------|-------------|
+| `response` | `Promise<void>` | A Promise that resolves when the deletion is complete. |
+
+The `delete()` method returns a Promise that you should `await` to verify 
+successful deletion.
+
+---
+
+## Guidance
+
+### Deleting non-existent keys
+
+Deleting a key that doesn't exist will not throw an error. The operation 
+completes successfully regardless of whether the key existed:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ // This will succeed even if the key doesn't exist
+ await kv.delete("non-existent-key");
+
+ return new Response("Delete operation completed", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Eventual consistency
+
+Like all KV Store operations, deletions are eventually consistent. After 
+deleting a key:
+
+- The deletion is immediately visible in the same global network location.
+- Other locations may still see the old value for up to 60 seconds (or the 
+ duration of any `cacheTtl` that was set when reading the key).
+
+### Conditional deletion
+
+You may want to check if a key exists before deleting it, or perform 
+additional logic:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+ const key = "user-session";
+
+ // Check if key exists before deleting
+ const value = await kv.get(key, "text");
+
+ if (value === null) {
+ return new Response("Key not found", { status: 404 });
+ }
+
+ // Perform deletion
+ await kv.delete(key);
+
+ return new Response("Key deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting multiple keys
+
+To delete multiple keys, you can use `Promise.all()`:
+
+```javascript
+async function handleRequest(request) {
+ const kv = new Azion.KV();
+
+ const keysToDelete = ["key1", "key2", "key3"];
+
+ await Promise.all(keysToDelete.map(key => kv.delete(key)));
+
+ return new Response("All keys deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+### Deleting namespaces
+
+To delete an entire namespace (not just a key), use the static 
+`Azion.KV.delete()` method:
+
+```javascript
+async function handleRequest(request) {
+ const namespaceName = "my-namespace";
+
+ // Delete the entire namespace
+ await Azion.KV.delete(namespaceName);
+
+ return new Response("Namespace deleted", { status: 200 });
+}
+
+addEventListener("fetch", (event) => {
+ event.respondWith(handleRequest(event.request));
+});
+```
+
+:::caution
+Deleting a namespace removes all key-value pairs within it. This operation 
+cannot be undone.
+:::
+
+---
+
+## Related
+
+- [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/)
+- [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/)
+- [KV Store API overview](/en/documentation/runtime/api-reference/kv-store/)
@@ -0,0 +1,86 @@
+---
+title: KV Store API
+description: >-
+ The KV Store API provides methods to store, retrieve, and delete key-value 
+ pairs from within your Functions.
+meta_tags: 'kv store, api, functions, key-value, storage'
+namespace: documentation_runtime_kv_store_api
+permalink: /documentation/runtime/api-reference/kv-store/
+menu_namespace: runtimeMenu
+---
+
+The KV Store API allows your Functions to interact with Azion's distributed 
+key-value storage directly from the runtime. This enables low-latency data 
+persistence and retrieval without external API calls.
+
+## Initializing the KV client
+
+You can initialize the KV client using the constructor or the `open` method:
+
+```javascript
+// Using the default namespace
+const kv = new Azion.KV();
+
+// Using a specific namespace
+const kv = new Azion.KV("my-namespace");
+
+// Using the open method (async)
+const kv = await Azion.KV.open("my-namespace");
+```
+
+## Available methods
+
+The `Azion.KV` class provides the following methods for data operations:
+
+| Method | Description | Reference |
+|--------|-------------|-----------|
+| `put(key, value, options?)` | Store a key-value pair | [Write key-value pairs](/en/documentation/runtime/api-reference/kv-store/write/) |
+| `get(key, type?, options?)` | Retrieve a value by key | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `getWithMetadata(key, type?, options?)` | Retrieve a value with its metadata | [Read key-value pairs](/en/documentation/runtime/api-reference/kv-store/read/) |
+| `delete(key)` | Delete a key-value pair | [Delete key-value pairs](/en/documentation/runtime/api-reference/kv-store/delete/) |
+
+## Namespace management
+
+| Method | Description |
+|--------|-------------|
+| `new Azion.KV()` | Creates a KV instance using the default namespace |
+| `new Azion.KV(name)` | Creates a KV instance for the specified namespace |
+| `Azion.KV.open(name)` | Opens a namespace asynchronously |
+| `Azion.KV.delete(name)` | Deletes a namespace |
+
+:::note
+Namespaces must be created via the [Azion API](https://api.azion.com/) or Console before they can be used in Functions. You cannot create namespaces from within Functions.
+:::
+
+## Supported value types
+
+KV Store supports the following value types:
+
+| Type | Description |
+|------|-------------|
+| `string` | Text data (UTF-8 encoded) |
+| `object` | JSON-serializable objects (automatically stringified) |
+| `ArrayBuffer` | Binary data |
+| `ReadableStream` | Streaming data for large values |
+
+## Limits
+
+| Limit | Value |
+|-------|-------|
+| Key size | Up to 512 bytes (UTF-8) |
+| Value size | Up to 25 MB per item |
+| Metadata size | Up to 1024 bytes (JSON-serialized) |
+| Per-key write rate | Up to 1 write per second to the same key |
+| Minimum `expirationTtl` | 60 seconds |
+| Minimum `cacheTtl` | 60 seconds |
+
+## Eventual consistency
+
+KV Store uses eventual consistency. Writes are immediately visible to other 
+requests in the same global network location, but can take up to 60 seconds 
+(or the value of the `cacheTtl` parameter) to be visible in other locations.
+
+## Related documentation
+
+- [KV Store reference](/en/documentation/products/store/kv-store/)
+- [How to manage KV Store with Functions](/en/documentation/products/guides/kv-store/manage-with-functions/)