Edge Runtime

Learn about the Edge runtime, the environment in which Edge Functions run.

Table of Contents

Next.js (/app)

Functions using the Edge Runtime, are ideal for a cost-effective option that use a limited set of Web Standard APIs that make sense on the server. The Edge runtime is built on top of the V8 engine, allowing it to run in isolated execution environments that don't require a container or virtual machine.

Functions using the Edge runtime execute in the data center closest to the user, or in a region near your databases. This can result in a much lower latency and allows you to provide personalization at speed.

Edge Functions run after the cache and so are ideal to be used on specific, dynamic parts of your site once the page is loaded. This response can be cached on the Edge Network making future invocations even faster.

See the quickstart to learn how to create your first function with the Edge runtime.

Supported APIs

The Edge runtime provides a subset of Web APIs such as fetch, Request, and Response. This lightweight API layer is built to be performant and execute code with minimal latency.

The following tables list the APIs that are available in the Edge runtime.

Network APIs

API	Description
`fetch`	Fetches a resource
`Request`	Represents an HTTP request
`Response`	Represents an HTTP response
`Headers`	Represents HTTP headers
`FormData`	Represents form data
`File`	Represents a file
`Blob`	Represents a blob
`URLSearchParams`	Represents URL search parameters
`Blob`	Represents a blob
`Event`	Represents an event
`EventTarget`	Represents an object that can handle events
`PromiseRejectEvent`	Represents an event that is sent to the global scope of a script when a JavaScript Promise is rejected

Encoding APIs

API	Description
`TextEncoder`	Encodes a string into a Uint8Array
`TextDecoder`	Decodes a Uint8Array into a string
`atob`	Decodes a base-64 encoded string
`btoa`	Encodes a string in base-64

Stream APIs

API	Description
`ReadableStream`	Represents a readable stream
`WritableStream`	Represents a writable stream
`WritableStreamDefaultWriter`	Represents a writer of a WritableStream
`TransformStream`	Represents a transform stream
`ReadableStreamDefaultReader`	Represents a reader of a ReadableStream
`ReadableStreamBYOBReader`	Represents a reader of a ReadableStream

Crypto APIs

API	Description
`crypto`	Provides access to the cryptographic functionality of the platform
`SubtleCrypto`	Provides access to common cryptographic primitives, like hashing, signing, encryption or decryption
`CryptoKey`	Represents a cryptographic key

Other Web Standard APIs

API	Description
`AbortController`	Allows you to abort one or more DOM requests as and when desired
`AbortSignal`	Represents a signal object that allows you to communicate with a DOM request (such as a `Fetch` request) and abort it if required
`DOMException`	Represents an error that occurs in the DOM
`structuredClone`	Creates a deep copy of a value
`URLPattern`	Represents a URL pattern
`Array`	Represents an array of values
`ArrayBuffer`	Represents a generic, fixed-length raw binary data buffer
`Atomics`	Provides atomic operations as static methods
`BigInt`	Represents a whole number with arbitrary precision
`BigInt64Array`	Represents a typed array of 64-bit signed integers
`BigUint64Array`	Represents a typed array of 64-bit unsigned integers
`Boolean`	Represents a logical entity and can have two values: `true` and `false`
`clearInterval`	Cancels a timed, repeating action which was previously established by a call to `setInterval()`
`clearTimeout`	Cancels a timed, repeating action which was previously established by a call to `setTimeout()`
`console`	Provides access to the browser's debugging console
`DataView`	Represents a generic view of an `ArrayBuffer`
`Date`	Represents a single moment in time in a platform-independent format
`decodeURI`	Decodes a Uniform Resource Identifier (URI) previously created by `encodeURI` or by a similar routine
`decodeURIComponent`	Decodes a Uniform Resource Identifier (URI) component previously created by `encodeURIComponent` or by a similar routine
`encodeURI`	Encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character
`encodeURIComponent`	Encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character
`Error`	Represents an error when trying to execute a statement or accessing a property
`EvalError`	Represents an error that occurs regarding the global function `eval()`
`Float32Array`	Represents a typed array of 32-bit floating point numbers
`Float64Array`	Represents a typed array of 64-bit floating point numbers
`Function`	Represents a function
`Infinity`	Represents the mathematical Infinity value
`Int8Array`	Represents a typed array of 8-bit signed integers
`Int16Array`	Represents a typed array of 16-bit signed integers
`Int32Array`	Represents a typed array of 32-bit signed integers
`Intl`	Provides access to internationalization and localization functionality
`isFinite`	Determines whether a value is a finite number
`isNaN`	Determines whether a value is `NaN` or not
`JSON`	Provides functionality to convert JavaScript values to and from the JSON format
`Map`	Represents a collection of values, where each value may occur only once
`Math`	Provides access to mathematical functions and constants
`Number`	Represents a numeric value
`Object`	Represents the object that is the base of all JavaScript objects
`parseFloat`	Parses a string argument and returns a floating point number
`parseInt`	Parses a string argument and returns an integer of the specified radix
`Promise`	Represents the eventual completion (or failure) of an asynchronous operation, and its resulting value
`Proxy`	Represents an object that is used to define custom behavior for fundamental operations (e.g. property lookup, assignment, enumeration, function invocation, etc)
`RangeError`	Represents an error when a value is not in the set or range of allowed values
`ReferenceError`	Represents an error when a non-existent variable is referenced
`Reflect`	Provides methods for interceptable JavaScript operations
`RegExp`	Represents a regular expression, allowing you to match combinations of characters
`Set`	Represents a collection of values, where each value may occur only once
`setInterval`	Repeatedly calls a function, with a fixed time delay between each call
`setTimeout`	Calls a function or evaluates an expression after a specified number of milliseconds
`SharedArrayBuffer`	Represents a generic, fixed-length raw binary data buffer
`String`	Represents a sequence of characters
`Symbol`	Represents a unique and immutable data type that is used as the key of an object property
`SyntaxError`	Represents an error when trying to interpret syntactically invalid code
`TypeError`	Represents an error when a value is not of the expected type
`Uint8Array`	Represents a typed array of 8-bit unsigned integers
`Uint8ClampedArray`	Represents a typed array of 8-bit unsigned integers clamped to 0-255
`Uint32Array`	Represents a typed array of 32-bit unsigned integers
`URIError`	Represents an error when a global URI handling function was used in a wrong way
`URL`	Represents an object providing static methods used for creating object URLs
`URLSearchParams`	Represents a collection of key/value pairs
`WeakMap`	Represents a collection of key/value pairs in which the keys are weakly referenced
`WeakSet`	Represents a collection of objects in which each object may occur only once
`WebAssembly`	Provides access to WebAssembly

Check if you're running on the Edge runtime

You can check if your function is running on the Edge runtime by checking the global globalThis.EdgeRuntime property. This can be helpful if you need to validate that your function is running on the Edge runtime in tests, or if you need to use a different API depending on the runtime.

if (typeof EdgeRuntime !== 'string') {
  // dead-code elimination is enabled for the code inside this block
}

Compatible Node.js modules

The following modules can be imported with and without the node: prefix when using the import statement:

Module	Description
`async_hooks`	Manage asynchronous resources lifecycles with `AsyncLocalStorage`. Supports the WinterCG subset of APIs
`events`	Facilitate event-driven programming with custom event emitters and listeners. This API is fully supported
`buffer`	Efficiently manipulate binary data using fixed-size, raw memory allocations with `Buffer`. Every primitive compatible with `Uint8Array` accepts `Buffer` too
`assert`	Provide a set of assertion functions for verifying invariants in your code
`util`	Offer various utility functions where we include `promisify`/`callbackify` and `types`

Also, Buffer is globally exposed to maximize compatibility with existing Node.js modules.

Unsupported APIs

The Edge runtime has some restrictions including:

Some Node.js APIs other than the ones listed above are not supported. For example, you can't read or write to the filesystem
node_modules can be used, as long as they implement ES Modules and do not use native Node.js APIs
Calling require directly is not allowed. Use import instead

The following JavaScript language features are disabled, and will not work:

API	Description
`eval`	Evaluates JavaScript code represented as a string
`new Function(evalString)`	Creates a new function with the code provided as an argument
`WebAssembly.compile`	Compiles a WebAssembly module from a buffer source
`WebAssembly.instantiate`	Compiles and instantiates a WebAssembly module from a buffer source

While WebAssembly.instantiate is supported in Edge Runtime, it requires the Wasm source code to be provided using the import statement. This means you cannot use a buffer or byte array to dynamically compile the module at runtime.

Environment Variables

You can use process.env to access Environment Variables.

Last updated on July 16, 2024

Ruby

Functions API Reference

Was this helpful?