Web Platform APIs

Deno implements a large portion of web standard APIs, making it easier to write code that works across browsers and server environments.

Fetch API

Deno supports the full Fetch API for making HTTP requests.

Basic Requests

// Simple GET request
const response = await fetch("https://api.example.com/data");
const data = await response.json();
console.log(data);

// Check response status
if (response.ok) {
  console.log("Success!");
} else {
  console.error(`Error: ${response.status} ${response.statusText}`);
}

Request & Response Objects

Working with Request/Response

// Create a Request object
const request = new Request("https://api.example.com/data", {
  method: "POST",
  headers: {
    "Authorization": "Bearer token123",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ key: "value" }),
});

// Use the Request object
const response = await fetch(request);

// Access response properties
console.log(response.status); // 200
console.log(response.headers.get("content-type"));
console.log(response.url);

// Read response body in different formats
const json = await response.json();
// const text = await response.text();
// const blob = await response.blob();
// const buffer = await response.arrayBuffer();

Headers API

Headers Manipulation

// Create headers
const headers = new Headers();
headers.append("Content-Type", "application/json");
headers.append("X-Custom-Header", "value");

// Set header (replaces existing)
headers.set("Authorization", "Bearer token");

// Get header value
const contentType = headers.get("content-type");

// Check if header exists
if (headers.has("authorization")) {
  console.log("Authorized");
}

// Delete header
headers.delete("x-custom-header");

// Iterate headers
for (const [key, value] of headers) {
  console.log(`${key}: ${value}`);
}

Abort Requests

Abort Controller

// Create an AbortController
const controller = new AbortController();
const { signal } = controller;

// Start request with abort signal
const fetchPromise = fetch("https://api.example.com/slow-endpoint", {
  signal,
});

// Abort after 5 seconds
setTimeout(() => controller.abort(), 5000);

try {
  const response = await fetchPromise;
  console.log(await response.json());
} catch (error) {
  if (error.name === "AbortError") {
    console.log("Request was aborted");
  }
}

WebSocket API

Deno provides full WebSocket support for real-time bidirectional communication.

WebSocket Client

// Connect to a WebSocket server
const ws = new WebSocket("wss://echo.websocket.org");

// Connection opened
ws.addEventListener("open", (event) => {
  console.log("Connected to WebSocket server");
  ws.send("Hello, Server!");
});

// Listen for messages
ws.addEventListener("message", (event) => {
  console.log(`Received: ${event.data}`);
});

// Handle errors
ws.addEventListener("error", (error) => {
  console.error("WebSocket error:", error);
});

// Connection closed
ws.addEventListener("close", (event) => {
  console.log(`Connection closed: ${event.code} ${event.reason}`);
});

// Send different data types
ws.send("text message");
ws.send(new Uint8Array([1, 2, 3, 4]));
ws.send(new Blob(["blob data"]));

// Close connection
ws.close(1000, "Normal closure");

WebSocket Server

WebSocket Server with Deno.serve

Deno.serve({ port: 8080 }, (req) => {
  // Upgrade HTTP request to WebSocket
  if (req.headers.get("upgrade") === "websocket") {
    const { socket, response } = Deno.upgradeWebSocket(req);
    
    socket.onopen = () => {
      console.log("Client connected");
    };
    
    socket.onmessage = (event) => {
      console.log(`Received: ${event.data}`);
      // Echo back to client
      socket.send(`Echo: ${event.data}`);
    };
    
    socket.onclose = () => {
      console.log("Client disconnected");
    };
    
    socket.onerror = (error) => {
      console.error("WebSocket error:", error);
    };
    
    return response;
  }
  
  return new Response("Expected WebSocket connection", { status: 400 });
});

Streams API

Deno fully supports the Streams API for processing data incrementally.

ReadableStream

// Create a readable stream
const stream = new ReadableStream({
  start(controller) {
    controller.enqueue("chunk 1");
    controller.enqueue("chunk 2");
    controller.close();
  },
});

// Read from stream
const reader = stream.getReader();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(value);
}

// Using for-await-of
for await (const chunk of response.body) {
  console.log(chunk); // Uint8Array chunks
}

WritableStream

// Create a writable stream
const stream = new WritableStream({
  write(chunk) {
    console.log(`Writing: ${chunk}`);
  },
  close() {
    console.log("Stream closed");
  },
  abort(reason) {
    console.error(`Stream aborted: ${reason}`);
  },
});

const writer = stream.getWriter();
await writer.write("Hello");
await writer.write("World");
await writer.close();

TransformStream

// Create a transform stream
const upperCaseTransform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toString().toUpperCase());
  },
});

// Pipe streams together
const response = await fetch("https://example.com/data.txt");
const transformedStream = response.body
  .pipeThrough(new TextDecoderStream())
  .pipeThrough(upperCaseTransform)
  .pipeThrough(new TextEncoderStream());

// Write to file
const file = await Deno.open("./output.txt", { write: true, create: true });
await transformedStream.pipeTo(file.writable);

Timers

Deno implements standard timer functions.

Timers

// setTimeout - execute once after delay
const timeoutId = setTimeout(() => {
  console.log("Executed after 1 second");
}, 1000);

// clearTimeout - cancel timeout
clearTimeout(timeoutId);

// setInterval - execute repeatedly
let count = 0;
const intervalId = setInterval(() => {
  console.log(`Count: ${++count}`);
  if (count >= 5) {
    clearInterval(intervalId);
  }
}, 1000);

// queueMicrotask - schedule microtask
queueMicrotask(() => {
  console.log("Microtask executed");
});

URL & URLSearchParams

URL APIs

// Parse and manipulate URLs
const url = new URL("https://example.com:8080/path?key=value#fragment");

console.log(url.protocol); // "https:"
console.log(url.hostname); // "example.com"
console.log(url.port); // "8080"
console.log(url.pathname); // "/path"
console.log(url.search); // "?key=value"
console.log(url.hash); // "#fragment"

// Modify URL
url.pathname = "/new-path";
url.searchParams.set("newKey", "newValue");

// URLSearchParams
const params = new URLSearchParams("key1=value1&key2=value2");
params.append("key3", "value3");
params.set("key1", "updated");
params.delete("key2");

// Iterate parameters
for (const [key, value] of params) {
  console.log(`${key}: ${value}`);
}

console.log(params.toString()); // "key1=updated&key3=value3"

Encoding & Decoding

TextEncoder & TextDecoder

Text Encoding

// Encode text to Uint8Array
const encoder = new TextEncoder();
const encoded = encoder.encode("Hello, 世界!");
console.log(encoded); // Uint8Array

// Decode Uint8Array to text
const decoder = new TextDecoder("utf-8");
const decoded = decoder.decode(encoded);
console.log(decoded); // "Hello, 世界!"

// Streaming decode
const streamDecoder = new TextDecoder();
const chunk1 = streamDecoder.decode(new Uint8Array([72, 101]), { stream: true });
const chunk2 = streamDecoder.decode(new Uint8Array([108, 108, 111]));
console.log(chunk1 + chunk2); // "Hello"

Base64

Base64 Encoding

// Encode to base64
const text = "Hello, Deno!";
const encoded = btoa(text);
console.log(encoded); // "SGVsbG8sIERlbm8h"

// Decode from base64
const decoded = atob(encoded);
console.log(decoded); // "Hello, Deno!"

Crypto API

Deno supports the Web Crypto API for cryptographic operations.

Random Values

Crypto Random

// Generate random values
const array = new Uint8Array(16);
crypto.getRandomValues(array);
console.log(array);

// Generate UUID
const uuid = crypto.randomUUID();
console.log(uuid); // "550e8400-e29b-41d4-a716-446655440000"

SubtleCrypto

SubtleCrypto API

// Generate key pair
const { privateKey, publicKey } = await crypto.subtle.generateKey(
  {
    name: "RSASSA-PKCS1-v1_5",
    modulusLength: 2048,
    publicExponent: new Uint8Array([1, 0, 1]),
    hash: "SHA-256",
  },
  true,
  ["sign", "verify"]
);

// Sign data
const encoder = new TextEncoder();
const data = encoder.encode("Message to sign");
const signature = await crypto.subtle.sign(
  "RSASSA-PKCS1-v1_5",
  privateKey,
  data
);

// Verify signature
const isValid = await crypto.subtle.verify(
  "RSASSA-PKCS1-v1_5",
  publicKey,
  signature,
  data
);
console.log(isValid); // true

// Hash data
const hashBuffer = await crypto.subtle.digest("SHA-256", data);
const hashArray = Array.from(new Uint8Array(hashBuffer));
const hashHex = hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
console.log(hashHex);

File & Blob APIs

File and Blob

// Create a Blob
const blob = new Blob(["Hello, ", "World!"], { type: "text/plain" });
console.log(blob.size); // 13
console.log(blob.type); // "text/plain"

// Read Blob as text
const text = await blob.text();
console.log(text); // "Hello, World!"

// Read Blob as ArrayBuffer
const buffer = await blob.arrayBuffer();

// Slice Blob
const sliced = blob.slice(0, 5, "text/plain");

// Create File (extends Blob)
const file = new File(["content"], "example.txt", {
  type: "text/plain",
  lastModified: Date.now(),
});
console.log(file.name); // "example.txt"
console.log(file.lastModified);

FormData

FormData API

// Create FormData
const formData = new FormData();
formData.append("username", "alice");
formData.append("email", "[email protected]");
formData.append("file", new File(["content"], "file.txt"));

// Send FormData
const response = await fetch("https://api.example.com/upload", {
  method: "POST",
  body: formData,
});

// Iterate FormData
for (const [key, value] of formData) {
  console.log(`${key}: ${value}`);
}

Events & EventTarget

Events

// Create custom EventTarget
class MyEmitter extends EventTarget {
  emitCustom(detail: any) {
    this.dispatchEvent(new CustomEvent("custom", { detail }));
  }
}

const emitter = new MyEmitter();

// Add event listener
emitter.addEventListener("custom", (event) => {
  console.log("Custom event:", event.detail);
});

// Dispatch event
emitter.emitCustom({ message: "Hello!" });

// Remove event listener
const handler = (e) => console.log(e);
emitter.addEventListener("custom", handler);
emitter.removeEventListener("custom", handler);

AbortController & AbortSignal

AbortController

// Create AbortController
const controller = new AbortController();
const { signal } = controller;

// Use with fetch
fetch("https://api.example.com/data", { signal })
  .then(response => response.json())
  .catch(error => {
    if (error.name === "AbortError") {
      console.log("Fetch aborted");
    }
  });

// Abort the operation
controller.abort();

// Create already-aborted signal
const abortedSignal = AbortSignal.abort();

// Create signal that aborts after timeout
const timeoutSignal = AbortSignal.timeout(5000);

BroadcastChannel

// Create a broadcast channel
const channel = new BroadcastChannel("my-channel");

// Listen for messages
channel.addEventListener("message", (event) => {
  console.log(`Received: ${event.data}`);
});

// Send message to all subscribers
channel.postMessage({ type: "update", data: "Hello!" });

// Close channel
channel.close();

Performance API

Performance Timing

// High-resolution timestamps
const start = performance.now();

// ... do some work ...

const end = performance.now();
console.log(`Operation took ${end - start}ms`);

// Performance marks and measures
performance.mark("start-task");

// ... task execution ...

performance.mark("end-task");
performance.measure("task-duration", "start-task", "end-task");

const measures = performance.getEntriesByType("measure");
console.log(measures[0].duration);

Console API

Console Methods

// Basic logging
console.log("Information");
console.error("Error message");
console.warn("Warning message");
console.info("Info message");
console.debug("Debug message");

// Formatted output
console.table([{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }]);

// Grouping
console.group("Group");
console.log("Item 1");
console.log("Item 2");
console.groupEnd();

// Timing
console.time("operation");
// ... operation ...
console.timeEnd("operation"); // operation: 123.45ms

// Assertions
console.assert(true, "This won't print");
console.assert(false, "This will print");

Structured Clone

// Deep clone objects
const original = {
  name: "Alice",
  nested: { value: 42 },
  date: new Date(),
  map: new Map([["key", "value"]]),
};

const cloned = structuredClone(original);
console.log(cloned.nested !== original.nested); // true (deep clone)

All these web platform APIs work the same way in Deno as they do in browsers, making your code portable between environments.

Deno Runtime APIs

Explore Deno-specific runtime APIs

HTTP Server

Learn more about building HTTP servers

Overview

Deno Namespace

Extensions

Web Platform APIs

Fetch API

Basic Requests

Request & Response Objects

Headers API

Abort Requests

WebSocket API

WebSocket Client

WebSocket Server

Streams API

ReadableStream

WritableStream

TransformStream

Timers

URL & URLSearchParams

Encoding & Decoding

TextEncoder & TextDecoder

Base64

Crypto API

Random Values

SubtleCrypto

File & Blob APIs

FormData

Events & EventTarget

AbortController & AbortSignal

BroadcastChannel

Performance API

Console API

Structured Clone

Deno Runtime APIs

HTTP Server

Build docs developers (and LLMs) love

Overview

Deno Namespace

Extensions

​Fetch API

​Basic Requests

​Request & Response Objects

​Headers API

​Abort Requests

​WebSocket API

​WebSocket Client

​WebSocket Server

​Streams API

​ReadableStream

​WritableStream

​TransformStream

​Timers

​URL & URLSearchParams

​Encoding & Decoding

​TextEncoder & TextDecoder

​Base64

​Crypto API

​Random Values

​SubtleCrypto

​File & Blob APIs

​FormData

​Events & EventTarget

​AbortController & AbortSignal

​BroadcastChannel

​Performance API

​Console API

​Structured Clone

​Related Resources

Deno Runtime APIs

HTTP Server

Build docs developers (and LLMs) love

Fetch API

Basic Requests

Request & Response Objects

Headers API

Abort Requests

WebSocket API

WebSocket Client

WebSocket Server

Streams API

ReadableStream

WritableStream

TransformStream

Timers

URL & URLSearchParams

Encoding & Decoding

TextEncoder & TextDecoder

Base64

Crypto API

Random Values

SubtleCrypto

File & Blob APIs

FormData

Events & EventTarget

AbortController & AbortSignal

BroadcastChannel

Performance API

Console API

Structured Clone

Related Resources