Configuration explorer

cloudflare.config.ts is a TypeScript file, so every field has a type and a description. Use the configuration explorer to see how the file describes the main parts of an application: project settings, the Worker, bindings, triggers, and exports.

Select a category, then select a highlighted field to see its type, description, default value, and accepted options. Editors with TypeScript support show the same information in autocomplete and hover text as you write the file, and type checking flags values that do not match.

To learn how to structure a project's configuration, refer to Programmatic configuration. To return different configuration for each environment, refer to Modes.

Select a highlighted line to show its type and description below it.

Generated from @cloudflare/config0.20.0

defineConfig

import { defineConfig } from "cf/config";

import * as entrypoint from "./src/index" with { type: "cf-worker" };

export default defineConfig(({ isPreview, mode }) => ({

isPreviewContext valueLink to isPreview

isPreview: boolean

Whether the config is being evaluated for a Preview build.

modeContext valueLink to mode

mode: string | undefined

The mode the config is being evaluated in. Set via the --mode CLI flag. In Vite the mode defaults to development in vite dev and production in vite build (more info). In Wrangler the mode defaults to undefined.

accountId: "<ACCOUNT_ID>",

accountIdOptionalLink to accountId

accountId?: string

This is the ID of the account associated with your zone. It can also be specified through the CLOUDFLARE_ACCOUNT_ID environment variable.

complianceRegion: mode === "fedramp" ? "fedramp-high" : "public",

complianceRegionOptionalLink to complianceRegion

complianceRegion?: "public" | "fedramp-high"

The compliance boundary in which commands should operate. When omitted, this can be supplied through CLOUDFLARE_COMPLIANCE_REGION.

worker: {

workerOptionalLink to worker

worker?: ConfigInput<WorkerConfig>

The Worker defined by this configuration.

nameRequiredLink to name

name: string

The name of your Worker.

entrypoint,

entrypointOptionalLink to entrypoint

entrypoint?: string | WorkerModule

The entrypoint module that will be executed. May be either a path string (e.g. "./src/index.ts") or a module namespace imported with the cf-worker import attribute.

compatibilityDate: "<COMPATIBILITY_DATE>",

compatibilityDateRequiredLink to compatibilityDate

compatibilityDate: string

A date in the form yyyy-mm-dd, which will be used to determine which version of the Workers runtime is used. More details at https://developers.cloudflare.com/workers/configuration/compatibility-dates

containers: [],

containersOptionalLink to containers

containers?: ConfigInput<ContainerConfig>[]

Container applications defined by this configuration.

}));

Worker

import { bindings, defineConfig, exports, triggers } from "cf/config";

import * as entrypoint from "./src/index" with { type: "cf-worker" };

export default defineConfig(({ mode }) => ({

modeContext valueLink to mode

mode: string | undefined

worker: {

workerOptionalLink to worker

worker?: ConfigInput<WorkerConfig>

The Worker defined by this configuration.

nameRequiredLink to name

name: string

The name of your Worker.

compatibilityDate: "<COMPATIBILITY_DATE>",

compatibilityDateRequiredLink to compatibilityDate

compatibilityDate: string

compatibilityFlags: ["nodejs_compat"],

compatibilityFlagsOptionalLink to compatibilityFlags

compatibilityFlags?: string[]

A list of flags that enable features from upcoming features of the Workers runtime, usually used together with compatibilityDate. More details at https://developers.cloudflare.com/workers/configuration/compatibility-flags/

Default: []

entrypoint,

entrypointOptionalLink to entrypoint

entrypoint?: string | WorkerModule

The entrypoint module that will be executed. May be either a path string (e.g. "./src/index.ts") or a module namespace imported with the cf-worker import attribute.

assets: {

assetsOptionalLink to assets

assets?: { /** How to handle HTML requests. */ htmlHandling?: "auto-trailing-slash" | "drop-trailing-slash" | "force-trailing-slash" | "none"; /** How to handle requests that do not match an asset. */ notFoundHandling?: "single-page-application" | "404-page" | "none"; /** * Matches will be routed to the User Worker, and matches to negative rules will go to the Asset Worker. * * Can also be `true`, indicating that every request should be routed to the User Worker. */ runWorkerFirst?: string[] | boolean; }

Specify the directory of static assets to deploy/serve. More details at https://developers.cloudflare.com/workers/frameworks/ For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#assets

htmlHandling: "auto-trailing-slash",

htmlHandlingOptionalLink to htmlHandling

htmlHandling?: "auto-trailing-slash" | "drop-trailing-slash" | "force-trailing-slash" | "none"

How to handle HTML requests.

domains: ["images.example.com"],

domainsOptionalLink to domains

domains?: string[]

Custom domains that your Worker should be published to. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#types-of-routes

triggers: [

triggersOptionalLink to triggers

triggers?: Trigger[]

Event triggers — fetch routes, queue consumers, cron schedules, Email Routing addresses, and raw sockets — that invoke this Worker. Construct entries with triggers.fetch(...), triggers.queue(...), triggers.scheduled(...), triggers.email(...), or triggers.connect(...). For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#triggers

triggers.scheduled({

scheduledBuilderLink to scheduled

scheduled(options: ScheduledTriggerOptions): ScheduledTrigger;

Scheduled (cron) trigger — invokes this Worker on the given schedules. More details here https://developers.cloudflare.com/workers/platform/cron-triggers

Options (1)

schedule: string: A "cron" definition to trigger a Worker's "scheduled" function. Lets you call Workers periodically, much like a cron job. More details here https://developers.cloudflare.com/workers/platform/cron-triggers

schedule: "0 * * * *",

scheduleRequiredLink to schedule

schedule: string

A "cron" definition to trigger a Worker's "scheduled" function. Lets you call Workers periodically, much like a cron job. More details here https://developers.cloudflare.com/workers/platform/cron-triggers

}),

tailConsumers: [

tailConsumersOptionalLink to tailConsumers

tailConsumers?: Array<{ /** The name of the service tail events will be forwarded to. */ worker: string; /** Whether to stream tail events in real time. */ streaming?: boolean; }>

A list of Tail Workers that are bound to this Worker. @cloudflare/config unifies regular and streaming tail consumers under a single field; pass streaming: true to forward streaming tail events.

Default: []

{

worker: "log-sink",

workerRequiredLink to worker

worker: string

The name of the service tail events will be forwarded to.

streaming: true,

streamingOptionalLink to streaming

streaming?: boolean

Whether to stream tail events in real time.

cache: {

cacheOptionalLink to cache

cache?: { /** If cache is enabled for this Worker. */ enabled: boolean; /** Whether cached assets may be reused across Worker versions. */ crossVersionCache?: boolean; }

Specify the cache behavior of the Worker.

enabled: true,

enabledRequiredLink to enabled

enabled: boolean

If cache is enabled for this Worker.

crossVersionCache: true,

crossVersionCacheOptionalLink to crossVersionCache

crossVersionCache?: boolean

Whether cached assets may be reused across Worker versions.

placement: {

placementOptionalLink to placement

placement?: { mode: "off" | "smart"; hint?: string; } | { mode?: "targeted"; region: string; } | { mode?: "targeted"; host: string; } | { mode?: "targeted"; hostname: string; }

Specify how the Worker should be located to minimize round-trip time. More details: https://developers.cloudflare.com/workers/platform/smart-placement/

mode: "smart",

modeRequiredLink to mode

mode: "off" | "smart"

The type definition does not include a description.

limits: {

limitsOptionalLink to limits

limits?: { /** Maximum allowed CPU time for a Worker's invocation in milliseconds. */ cpuMs?: number; /** Maximum allowed number of fetch requests that a Worker's invocation can execute. */ subrequests?: number; }

Specify limits for runtime behavior. Only supported for the "standard" Usage Model. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#limits

cpuMs: 50,

cpuMsOptionalLink to cpuMs

cpuMs?: number

Maximum allowed CPU time for a Worker's invocation in milliseconds.

subrequests: 100,

subrequestsOptionalLink to subrequests

subrequests?: number

Maximum allowed number of fetch requests that a Worker's invocation can execute.

logpush: true,

logpushOptionalLink to logpush

logpush?: boolean

Send Trace Events from this Worker to Workers Logpush. This will not configure a corresponding Logpush job automatically. For more information about Workers Logpush, see: https://blog.cloudflare.com/logpush-for-workers/

observability: {

observabilityOptionalLink to observability

observability?: { /** If observability is enabled for this Worker. */ enabled?: boolean; /** The sampling rate. */ headSamplingRate?: number; /** * Whether query strings are removed from request URLs in logs and traces. * * @default false */ redactQueryString?: boolean; /** Real-time Issues settings for this Worker. */ issues?: { /** Whether real-time Issues are enabled. */ enabled?: boolean; }; logs?: { enabled?: boolean; /** The sampling rate. */ headSamplingRate?: number; /** Set to false to disable invocation logs. */ invocationLogs?: boolean; /** * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard. * * @default true */ persist?: boolean; /** * What destinations logs emitted from the Worker should be sent to. * * @default [] */ destinations?: string[]; }; traces?: { enabled?: boolean; /** The sampling rate. */ headSamplingRate?: number; /** * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard. * * @default true */ persist?: boolean; /** * What destinations traces emitted from the Worker should be sent to. * * @default [] */ destinations?: string[]; }; }

Specify the observability behavior of the Worker. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#observability

enabled: true,

enabledOptionalLink to enabled

enabled?: boolean

If observability is enabled for this Worker.

logs: {

logsOptionalLink to logs

logs?: { enabled?: boolean; /** The sampling rate. */ headSamplingRate?: number; /** Set to false to disable invocation logs. */ invocationLogs?: boolean; /** * If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard. * * @default true */ persist?: boolean; /** * What destinations logs emitted from the Worker should be sent to. * * @default [] */ destinations?: string[]; }

The type definition does not include a description.

persist: true,

persistOptionalLink to persist

persist?: boolean

If logs should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.

Default: true

traces: {

tracesOptionalLink to traces

traces?: { enabled?: boolean; /** The sampling rate. */ headSamplingRate?: number; /** * If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard. * * @default true */ persist?: boolean; /** * What destinations traces emitted from the Worker should be sent to. * * @default [] */ destinations?: string[]; }

The type definition does not include a description.

persist: true,

persistOptionalLink to persist

persist?: boolean

If traces should be persisted to the Cloudflare observability platform where they can be queried in the dashboard.

Default: true

workersDev: false,

workersDevOptionalLink to workersDev

workersDev?: boolean

Whether we use <name>.<subdomain>.workers.dev to test and deploy your Worker. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#workersdev

Default: true

previewUrls: true,

previewUrlsOptionalLink to previewUrls

previewUrls?: boolean

Whether we use <version>-<name>.<subdomain>.workers.dev to serve Preview URLs for your Worker.

Default: false

unsafe: {

unsafeOptionalLink to unsafe

unsafe?: { /** * Arbitrary key/value pairs that will be included in the uploaded metadata. Values specified * here will always be applied to metadata last, so can add new or override existing fields. */ metadata?: Record<string, unknown>; /** * Used for internal capnp uploads for the Workers runtime. */ capnp?: { basePath: string; sourceSchemas: string[]; compiledSchema?: never; } | { basePath?: never; sourceSchemas?: never; compiledSchema: string; }; }

"Unsafe" tables for runtime features that aren't directly supported by this configuration. Values are forwarded verbatim in the Worker's upload metadata.

Default: {}

metadata: { build: "docs-example" },

metadataOptionalLink to metadata

metadata?: Record<string, unknown>

Arbitrary key/value pairs that will be included in the uploaded metadata. Values specified here will always be applied to metadata last, so can add new or override existing fields.

env: {

envOptionalLink to env

env?: Record<string, Binding>

Bindings exposed on the Worker's env object. Construct entries with bindings.kv(...), bindings.r2(...), etc.

API_ORIGIN: bindings.text("https://api.example.com"),

textBuilderLink to text

text<T$1 extends string>(value: T$1): TextBinding<T$1>;

Inline string value made available to the Worker on env under the binding name. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#environment-variables

DATABASE: bindings.d1({

d1BuilderLink to d1

d1(options?: D1BindingOptions): D1Binding;

Binding to a D1 database. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#d1-databases

Options (3)

id?: string: The UUID of this D1 database (not required).
name?: string: The name of this D1 database.
dev?: BindingDevOptions: Options that only apply during local development.

nameOptionalLink to name

name?: string

The name of this D1 database.

}),

IMAGES: bindings.r2({

r2BuilderLink to r2

r2(options?: R2BindingOptions): R2Binding;

Binding to an R2 bucket. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#r2-buckets

Options (3)

name?: string: The name of this R2 bucket at the edge.
jurisdiction?: string: The jurisdiction that the bucket exists in. Default if not present.
dev?: BindingDevOptions & { /** EXPERIMENTAL: credentials for the local S3-compatible endpoint. */ experimentalS3Credentials?: { accessKeyId: string; secretAccessKey: string; }; }: Settings that only apply to local development.

nameOptionalLink to name

name?: string

The name of this R2 bucket at the edge.

}),

exports: {

exportsOptionalLink to exports

exports?: Record<string, Export>

Configuration for named exports declared by the Worker. Each entry's key is the exported class name; the value configures the export. - Construct entries with exports.durableObject(...). - Declares Durable Object classes exported from this Worker. For more information about Durable Objects, see the documentation at https://developers.cloudflare.com/workers/learning/using-durable-objects. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#durable-objects. - Construct entries with exports.workflow(...). - Declares Workflows defined by this Worker. For more information about Workflows, see the documentation at https://developers.cloudflare.com/workflows/.

Admin: exports.worker({

workerBuilderLink to worker

worker(options?: WorkerEntrypointExportOptions): WorkerEntrypointExport;

Declares a WorkerEntrypoint export defined by this Worker.

Options (1)

cache?: { /** Whether cache is enabled for this entrypoint. */ enabled: boolean; }

cache: {

cacheOptionalLink to cache

cache?: { /** Whether cache is enabled for this entrypoint. */ enabled: boolean; }

The type definition does not include a description.

enabled: true,

enabledRequiredLink to enabled

enabled: boolean

Whether cache is enabled for this entrypoint.

}),

Counter: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject<TContainer extends ContainerDefinition | undefined = undefined>(options: DurableObjectCreatedExportOptions<TContainer>): DurableObjectCreatedExport<TContainer>;

Declares a Durable Object class defined by this Worker. For more information about Durable Objects, see the documentation at https://developers.cloudflare.com/workers/learning/using-durable-objects For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#durable-objects

Options (4)

state?: "created"
storage: "sqlite": Selects the SQLite-backed storage engine (recommended for new classes).
container?: TContainer: Attach a Container application to this Durable Object by config reference.
storage: "legacy-kv": Selects the legacy key-value storage engine.

storage: "sqlite",

storageRequiredLink to storage

storage: "sqlite"

Selects the SQLite-backed storage engine (recommended for new classes).

}),

}));

Bindings

import { bindings, defineConfig } from "cf/config";

import * as entrypoint from "./src/index" with { type: "cf-worker" };

export default defineConfig({

worker: {

workerOptionalLink to worker

worker?: ConfigInput<WorkerConfig>

The Worker defined by this configuration.

nameRequiredLink to name

name: string

The name of your Worker.

entrypoint,

entrypointOptionalLink to entrypoint

entrypoint?: string | WorkerModule

The entrypoint module that will be executed. May be either a path string (e.g. "./src/index.ts") or a module namespace imported with the cf-worker import attribute.

compatibilityDate: "<COMPATIBILITY_DATE>",

compatibilityDateRequiredLink to compatibilityDate

compatibilityDate: string

env: {

envOptionalLink to env

env?: Record<string, Binding>

Bindings exposed on the Worker's env object. Construct entries with bindings.kv(...), bindings.r2(...), etc.

MY_AGENT_MEMORY: bindings.agentMemory({

agentMemoryBuilderLink to agentMemory

agentMemory(options: AgentMemoryBindingOptions): AgentMemoryBinding;

Agent Memory namespace binding. Each binding is scoped to a namespace and allows agents to persist and recall memory.

Options (2)

namespace: string: The user-chosen namespace name. Must exist in Cloudflare at deploy time.
dev?: BindingDevOptions: Options that only apply during local development.

namespace: "my-namespace",

namespaceRequiredLink to namespace

namespace: string

The user-chosen namespace name. Must exist in Cloudflare at deploy time.

}),

MY_AI: bindings.ai(),

aiBuilderLink to ai

ai<TAiModelList extends AiModelListType = AiModels>(options?: AiBindingOptions): TypedAiBinding<TAiModelList>;

Binding to the Workers AI project. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#workers-ai

Options (1)

dev?: BindingDevOptions: Options that only apply during local development.

MY_AI_SEARCH: bindings.aiSearch({

aiSearchBuilderLink to aiSearch

aiSearch(options: AiSearchBindingOptions): AiSearchBinding;

AI Search instance binding. Each binding is bound directly to a single pre-existing instance within the "default" namespace.

Options (2)

name: string: The user-chosen instance name. Must exist in Cloudflare at deploy time.
dev?: BindingDevOptions: Options that only apply during local development.

nameRequiredLink to name

name: string

The user-chosen instance name. Must exist in Cloudflare at deploy time.

}),

MY_AI_SEARCH_NAMESPACE: bindings.aiSearchNamespace({

aiSearchNamespaceBuilderLink to aiSearchNamespace

aiSearchNamespace(options: AiSearchNamespaceBindingOptions): AiSearchNamespaceBinding;

AI Search namespace binding. Each binding is scoped to a namespace and allows dynamic instance CRUD within it.

Options (2)

namespace: string: The user-chosen namespace name. Must exist in Cloudflare at deploy time.
dev?: BindingDevOptions: Options that only apply during local development.

namespace: "my-namespace",

namespaceRequiredLink to namespace

namespace: string

The user-chosen namespace name. Must exist in Cloudflare at deploy time.

}),

MY_ANALYTICS_ENGINE_DATASET: bindings.analyticsEngineDataset(),

analyticsEngineDatasetBuilderLink to analyticsEngineDataset

analyticsEngineDataset(options?: AnalyticsEngineDatasetBindingOptions): AnalyticsEngineDatasetBinding;

Binding to an Analytics Engine dataset. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#analytics-engine-datasets

Options (1)

name?: string: The name of this dataset to write to.

MY_ARTIFACTS: bindings.artifacts({

artifactsBuilderLink to artifacts

artifacts(options: ArtifactsBindingOptions): ArtifactsBinding;

Binding to an Artifacts instance. Artifacts provides git-compatible file storage on Cloudflare Workers.

Options (2)

namespace: string: The namespace to use.
dev?: BindingDevOptions: Options that only apply during local development.

namespace: "my-namespace",

namespaceRequiredLink to namespace

namespace: string

The namespace to use.

}),

MY_ASSETS: bindings.assets(),

assetsBuilderLink to assets

assets(): AssetsBinding;

Binding to the Worker's static assets. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#assets

MY_BROWSER: bindings.browser(),

browserBuilderLink to browser

browser(options?: BrowserBindingOptions): BrowserBinding;

Binding to a headless browser usable from the Worker. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#browser-rendering

Options (1)

dev?: BindingDevOptions: Options that only apply during local development.

MY_D1: bindings.d1(),

d1BuilderLink to d1

d1(options?: D1BindingOptions): D1Binding;

Binding to a D1 database. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#d1-databases

Options (3)

id?: string: The UUID of this D1 database (not required).
name?: string: The name of this D1 database.
dev?: BindingDevOptions: Options that only apply during local development.

MY_DISPATCH_NAMESPACE: bindings.dispatchNamespace(),

dispatchNamespaceBuilderLink to dispatchNamespace

dispatchNamespace(options?: DispatchNamespaceBindingOptions): DispatchNamespaceBinding;

Binding to a Workers for Platforms dispatch namespace. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#dispatch-namespace-bindings-workers-for-platforms

Options (3)

namespace?: string: The namespace to bind to.
outbound?: { /** Name of the Worker handling the outbound requests. */ worker: string; /** (Optional) List of parameter names, for sending context from your dispatch Worker to the outbound handler. */ parameters?: string[]; }: Details about the outbound Worker which will handle outbound requests from your namespace.
dev?: BindingDevOptions: Options that only apply during local development.

MY_DURABLE_OBJECT: bindings.durableObject({

durableObjectBuilderLink to durableObject

durableObject<TWorker$1 extends WorkerReference, TExportName$1 extends DurableObjectExportName<TWorker$1>>(options: DurableObjectBindingOptions<TWorker$1, TExportName$1>): DurableObjectBinding<TWorker$1, TExportName$1>;

Binding to a Durable Object class. worker is the name or config of the Worker that defines the class; exportName is the exported class name. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#durable-objects

Options (2)

worker: TWorker$1: The name or config of the Worker that defines the Durable Object class.
exportName: TExportName$1: The exported class name of the Durable Object.

worker: "my-worker",

workerRequiredLink to worker

worker: TWorker$1

The name or config of the Worker that defines the Durable Object class.

exportName: "MyDurableObject",

exportNameRequiredLink to exportName

exportName: TExportName$1

The exported class name of the Durable Object.

}),

MY_FLAGSHIP: bindings.flagship(),

flagshipBuilderLink to flagship

flagship(options?: FlagshipBindingOptions): FlagshipBinding;

Binding to a Flagship feature-flag service.

Options (2)

id?: string: The Flagship app ID to bind to.
dev?: BindingDevOptions: Options that only apply during local development.

MY_HYPERDRIVE: bindings.hyperdrive({

hyperdriveBuilderLink to hyperdrive

hyperdrive(options: HyperdriveBindingOptions): HyperdriveBinding;

Binding to a Hyperdrive configuration. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#hyperdrive

Options (2)

id: string: The ID of the Hyperdrive configuration.
dev?: { /** The database connection string used during local development. */ connectionString?: string; }: Options that only apply during local development.

id: "resource-id",

idRequiredLink to id

id: string

The ID of the Hyperdrive configuration.

}),

MY_IMAGES: bindings.images(),

imagesBuilderLink to images

images(options?: ImagesBindingOptions): ImagesBinding$1;

Binding to Cloudflare Images. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#images

Options (1)

dev?: BindingDevOptions: Options that only apply during local development.

MY_JSON: bindings.json({ feature: true }),

jsonBuilderLink to json

json<T$1 extends Json>(value: T$1): JsonBinding<T$1>;

Inline JSON value made available to the Worker on env under the binding name.

MY_KV: bindings.kv(),

kvBuilderLink to kv

kv<TKey extends string = string>(options?: KvBindingOptions): TypedKvBinding<TKey>;

Binding to a Workers KV namespace. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#kv-namespaces

Options (2)

id?: string: The ID of the KV namespace.
dev?: BindingDevOptions: Options that only apply during local development.

MY_LOGFWDR: bindings.logfwdr({

logfwdrBuilderLink to logfwdr

logfwdr(options: LogfwdrBindingOptions): LogfwdrBinding;

Binding for forwarding logs to logfwdr.

Options (1)

destination: string: The destination for this logged message.

destination: "my-destination",

destinationRequiredLink to destination

destination: string

The destination for this logged message.

}),

MY_MEDIA: bindings.media(),

mediaBuilderLink to media

media(options?: MediaBindingOptions): MediaBinding$1;

Binding to Cloudflare Media Transformations.

Options (1)

dev?: BindingDevOptions: Options that only apply during local development.

MY_MTLS_CERTIFICATE: bindings.mtlsCertificate({

mtlsCertificateBuilderLink to mtlsCertificate

mtlsCertificate(options: MtlsCertificateBindingOptions): MtlsCertificateBinding;

Binding to an uploaded mTLS certificate. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#mtls-certificates

Options (2)

id: string: The UUID of the uploaded mTLS certificate.
dev?: BindingDevOptions: Options that only apply during local development.

id: "resource-id",

idRequiredLink to id

id: string

The UUID of the uploaded mTLS certificate.

}),

MY_PIPELINE: bindings.pipeline({

pipelineBuilderLink to pipeline

pipeline<TRecord extends PipelineRecord = PipelineRecord>(options: PipelineBindingOptions): TypedPipelineBinding<TRecord>;

Binding to a Cloudflare Pipeline.

Options (2)

name: string: Name of the Pipeline to bind.
dev?: BindingDevOptions: Options that only apply during local development.

nameRequiredLink to name

name: string

Name of the Pipeline to bind.

}),

MY_QUEUE: bindings.queue(),

queueBuilderLink to queue

queue<TBody = unknown>(options?: QueueBindingOptions): TypedQueueBinding<TBody>;

Producer binding to a Cloudflare Queue. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#queues

Options (3)

name?: string: The name of this Queue.
deliveryDelay?: number: The number of seconds to wait before delivering a message.
dev?: BindingDevOptions: Options that only apply during local development.

MY_R2: bindings.r2(),

r2BuilderLink to r2

r2(options?: R2BindingOptions): R2Binding;

Binding to an R2 bucket. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#r2-buckets

Options (3)

name?: string: The name of this R2 bucket at the edge.
jurisdiction?: string: The jurisdiction that the bucket exists in. Default if not present.
dev?: BindingDevOptions & { /** EXPERIMENTAL: credentials for the local S3-compatible endpoint. */ experimentalS3Credentials?: { accessKeyId: string; secretAccessKey: string; }; }: Settings that only apply to local development.

MY_RATE_LIMIT: bindings.rateLimit({

rateLimitBuilderLink to rateLimit

rateLimit(options: RateLimitBindingOptions): RateLimitBinding;

Binding to a rate limiter.

Options (2)

namespace: string: The namespace ID for this rate limiter.
simple: { /** The maximum number of requests allowed in the time period. */ limit: number; /** The time period in seconds (10 for ten seconds, 60 for one minute). */ period: 10 | 60; }: Simple rate limiting configuration.

namespace: "my-namespace",

namespaceRequiredLink to namespace

namespace: string

The namespace ID for this rate limiter.

simple: {

simpleRequiredLink to simple

simple: { /** The maximum number of requests allowed in the time period. */ limit: number; /** The time period in seconds (10 for ten seconds, 60 for one minute). */ period: 10 | 60; }

Simple rate limiting configuration.

limit: 1,

limitRequiredLink to limit

limit: number

The maximum number of requests allowed in the time period.

period: 10,

periodRequiredLink to period

period: 10 | 60

The time period in seconds (10 for ten seconds, 60 for one minute).

}),

MY_SECRET: bindings.secret(),

secretBuilderLink to secret

secret(): SecretBinding;

Declares a secret that is required by your Worker, exposed on env under the binding name. When defined, this binding: - Replaces .dev.vars/.env/process.env inference for type generation - Enables local dev validation with warnings for missing secrets For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#secrets-configuration-property

MY_SECRETS_STORE_SECRET: bindings.secretsStoreSecret({

secretsStoreSecretBuilderLink to secretsStoreSecret

secretsStoreSecret(options: SecretsStoreSecretBindingOptions): SecretsStoreSecretBinding;

Binding to a Secrets Store secret.

Options (2)

storeId: string: ID of the secret store.
secretName: string: Name of the secret.

storeId: "store-id",

storeIdRequiredLink to storeId

storeId: string

ID of the secret store.

secretName: "my-secret",

secretNameRequiredLink to secretName

secretName: string

Name of the secret.

}),

MY_SEND_EMAIL: bindings.sendEmail({

sendEmailBuilderLink to sendEmail

sendEmail(options?: SendEmailBindingOptions): SendEmailBinding;

Binding for sending email from inside the Worker. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#email-bindings

Options (6)

destinationAddress: string: If this binding should be restricted to a specific verified address.
allowedDestinationAddresses?: never
destinationAddress?: never
allowedDestinationAddresses: string[]: If this binding should be restricted to a set of verified addresses.
allowedSenderAddresses?: string[]: If this binding should be restricted to a set of sender addresses.
dev?: BindingDevOptions: Options that only apply during local development.

destinationAddress: "value",

destinationAddressRequiredLink to destinationAddress

destinationAddress: string

If this binding should be restricted to a specific verified address.

}),

MY_STREAM: bindings.stream(),

streamBuilderLink to stream

stream(options?: StreamBindingOptions): StreamBinding$1;

Binding to Cloudflare Stream.

Options (1)

dev?: BindingDevOptions: Options that only apply during local development.

MY_TEXT: bindings.text("production"),

textBuilderLink to text

text<T$1 extends string>(value: T$1): TextBinding<T$1>;

Inline string value made available to the Worker on env under the binding name. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#environment-variables

MY_VECTORIZE: bindings.vectorize({

vectorizeBuilderLink to vectorize

vectorize(options: VectorizeBindingOptions): VectorizeBinding;

Binding to a Vectorize index. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#vectorize-indexes

Options (2)

name: string: The name of the Vectorize index.
dev?: BindingDevOptions: Options that only apply during local development.

nameRequiredLink to name

name: string

The name of the Vectorize index.

}),

MY_VERSION_METADATA: bindings.versionMetadata(),

versionMetadataBuilderLink to versionMetadata

versionMetadata(): VersionMetadataBinding;

Binding to the Worker version's metadata.

MY_VPC_NETWORK: bindings.vpcNetwork({

vpcNetworkBuilderLink to vpcNetwork

vpcNetwork(options: VpcNetworkBindingOptions): VpcNetworkBinding;

Binding to a VPC network.

Options (5)

tunnelId: string: The tunnel ID of the Cloudflare Tunnel to route traffic through. Mutually exclusive with networkId.
networkId?: never
dev?: BindingDevOptions: Options that only apply during local development.
tunnelId?: never
networkId: string: The network ID to route traffic through. Mutually exclusive with tunnelId.

tunnelId: "tunnel-id",

tunnelIdRequiredLink to tunnelId

tunnelId: string

The tunnel ID of the Cloudflare Tunnel to route traffic through. Mutually exclusive with networkId.

}),

MY_VPC_SERVICE: bindings.vpcService({

vpcServiceBuilderLink to vpcService

vpcService(options: VpcServiceBindingOptions): VpcServiceBinding;

Binding to a VPC service.

Options (2)

id: string: The service ID of the VPC connectivity service.
dev?: BindingDevOptions: Options that only apply during local development.

id: "resource-id",

idRequiredLink to id

id: string

The service ID of the VPC connectivity service.

}),

MY_WORKER: bindings.worker({

workerBuilderLink to worker

worker<TWorker$1 extends WorkerReference, TExportName$1 extends WorkerEntrypointExportName<TWorker$1> | undefined = undefined>(options: WorkerBindingOptions<TWorker$1, TExportName$1>): WorkerBinding<TWorker$1, NoInfer<TExportName$1>>;

Service binding (Worker-to-Worker). worker is the name or config of the bound Worker; exportName selects a named WorkerEntrypoint export (defaults to the default export). For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#service-bindings

Options (4)

worker: TWorker$1: The name or config of the bound Worker.
exportName?: TExportName$1: The named export to bind to (defaults to the default export).
props?: Record<string, unknown>: Optional properties that will be made available to the service via ctx.props.
dev?: BindingDevOptions: Options that only apply during local development.

worker: "my-worker",

workerRequiredLink to worker

worker: TWorker$1

The name or config of the bound Worker.

}),

MY_WORKER_LOADER: bindings.workerLoader(),

workerLoaderBuilderLink to workerLoader

workerLoader(): WorkerLoaderBinding;

Binding to a Worker Loader.

MY_WORKFLOW: bindings.workflow({

workflowBuilderLink to workflow

workflow<TWorker$1 extends WorkerReference, TExportName$1 extends WorkflowExportName<TWorker$1>>(options: WorkflowBindingOptions<TWorker$1, TExportName$1>): WorkflowBinding<TWorker$1, NoInfer<TExportName$1>>;

Create a Workflow binding. worker may be a Worker config reference or a Worker name. exportName must be a valid WorkflowEntrypoint export for the given Worker.

Options (3)

name: string: The name of the Workflow.
worker: TWorker$1: The name or config of the Worker that defines the Workflow.
exportName: TExportName$1: The exported class name of the Workflow.

nameRequiredLink to name

name: string

The name of the Workflow.

worker: "my-worker",

workerRequiredLink to worker

worker: TWorker$1

The name or config of the Worker that defines the Workflow.

exportName: "MyWorkflow",

exportNameRequiredLink to exportName

exportName: TExportName$1

The exported class name of the Workflow.

}),

});

Triggers

import { defineConfig, triggers } from "cf/config";

import * as entrypoint from "./src/index" with { type: "cf-worker" };

export default defineConfig({

worker: {

workerOptionalLink to worker

worker?: ConfigInput<WorkerConfig>

The Worker defined by this configuration.

nameRequiredLink to name

name: string

The name of your Worker.

entrypoint,

entrypointOptionalLink to entrypoint

entrypoint?: string | WorkerModule

The entrypoint module that will be executed. May be either a path string (e.g. "./src/index.ts") or a module namespace imported with the cf-worker import attribute.

compatibilityDate: "<COMPATIBILITY_DATE>",

compatibilityDateRequiredLink to compatibilityDate

compatibilityDate: string

triggers: [

triggersOptionalLink to triggers

triggers?: Trigger[]

triggers.fetch({

fetchBuilderLink to fetch

fetch(options: FetchTriggerOptions): FetchTrigger;

Fetch trigger — a route that your Worker should be published to. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#types-of-routes

Options (2)

pattern: string: A route that your Worker should be published to. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#types-of-routes
zone?: string: The DNS zone the pattern is attached to. Required when the pattern is ambiguous.

pattern: "example.com/*",

patternRequiredLink to pattern

pattern: string

A route that your Worker should be published to. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#types-of-routes

zone: "example.com",

zoneOptionalLink to zone

zone?: string

The DNS zone the pattern is attached to. Required when the pattern is ambiguous.

}),

triggers.queue({

queueBuilderLink to queue

queue(options: QueueConsumerTriggerOptions): QueueConsumerTrigger;

Queue consumer trigger — invokes this Worker when messages arrive on the named queue. For reference, see https://developers.cloudflare.com/workers/wrangler/configuration/#queues

Options (8)

name: string: The name of the queue from which this consumer should consume.
deadLetterQueue?: string: The queue to send messages that failed to be consumed.
maxBatchSize?: number: The maximum number of messages per batch.
maxBatchTimeout?: number: The maximum number of seconds to wait to fill a batch with messages.
maxConcurrency?: number | null: The maximum number of concurrent consumer Worker invocations. Leaving this unset will allow your consumer to scale to the maximum concurrency needed to keep up with the message backlog.
maxRetries?: number: The maximum number of retries for each message.
retryDelay?: number: The number of seconds to wait before retrying a message.
visibilityTimeoutMs?: number: The number of milliseconds to wait for pulled messages to become visible again.

nameRequiredLink to name

name: string

The name of the queue from which this consumer should consume.

maxBatchSize: 20,

maxBatchSizeOptionalLink to maxBatchSize

maxBatchSize?: number

The maximum number of messages per batch.

}),

triggers.scheduled({

scheduledBuilderLink to scheduled

scheduled(options: ScheduledTriggerOptions): ScheduledTrigger;

Scheduled (cron) trigger — invokes this Worker on the given schedules. More details here https://developers.cloudflare.com/workers/platform/cron-triggers

Options (1)

schedule: string: A "cron" definition to trigger a Worker's "scheduled" function. Lets you call Workers periodically, much like a cron job. More details here https://developers.cloudflare.com/workers/platform/cron-triggers

schedule: "0 * * * *",

scheduleRequiredLink to schedule

schedule: string

}),

triggers.email({

emailBuilderLink to email

email(options: EmailTriggerOptions): EmailTrigger;

Email trigger — invokes this Worker for the configured Email Routing addresses.

Options (1)

addresses: string[]: Inbound Email Routing addresses handled by this Worker. Each entry is a literal recipient address (e.g. "support@example.com") or a *@domain catch-all (e.g. "*@example.com").

addresses: ["support@example.com"],

addressesRequiredLink to addresses

addresses: string[]

Inbound Email Routing addresses handled by this Worker. Each entry is a literal recipient address (e.g. "support@example.com") or a *@domain catch-all (e.g. "*@example.com").

}),

triggers.connect({

connectBuilderLink to connect

connect(options: ConnectTriggerOptions): ConnectTrigger;

Connect trigger — invokes this Worker's connect(socket, env, ctx) handler for raw socket connections received on the configured protocol/port.

Options (6)

port: number: The port to listen on.
address?: string: The address to bind to. Defaults to 127.0.0.1.
protocol: "tcp"
protocol: "udp"
idleTimeoutMs?: number: The idle timeout in milliseconds after which a peer flow is closed.
maxPendingBytes?: number: The maximum number of pending datagram bytes per peer flow.

protocol: "tcp",

protocolRequiredLink to protocol

protocol: "tcp"

The type definition does not include a description.

port: 5432,

portRequiredLink to port

port: number

The port to listen on.

}),

});

Exports

import { defineConfig, exports } from "cf/config";

import * as entrypoint from "./src/index" with { type: "cf-worker" };

export default defineConfig({

worker: {

workerOptionalLink to worker

worker?: ConfigInput<WorkerConfig>

The Worker defined by this configuration.

nameRequiredLink to name

name: string

The name of your Worker.

entrypoint,

entrypointOptionalLink to entrypoint

entrypoint?: string | WorkerModule

The entrypoint module that will be executed. May be either a path string (e.g. "./src/index.ts") or a module namespace imported with the cf-worker import attribute.

compatibilityDate: "<COMPATIBILITY_DATE>",

compatibilityDateRequiredLink to compatibilityDate

compatibilityDate: string

exports: {

exportsOptionalLink to exports

exports?: Record<string, Export>

LiveClass: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject<TContainer extends ContainerDefinition | undefined = undefined>(options: DurableObjectCreatedExportOptions<TContainer>): DurableObjectCreatedExport<TContainer>;

Options (4)

state?: "created"
storage: "sqlite": Selects the SQLite-backed storage engine (recommended for new classes).
container?: TContainer: Attach a Container application to this Durable Object by config reference.
storage: "legacy-kv": Selects the legacy key-value storage engine.

storage: "sqlite",

storageRequiredLink to storage

storage: "sqlite"

Selects the SQLite-backed storage engine (recommended for new classes).

}),

RemovedClass: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject(options: DurableObjectDeletedExportOptions): DurableObjectDeletedExport;

Retire a provisioned Durable Object namespace whose class has been removed from code.

Options (1)

state: "deleted"

state: "deleted",

stateRequiredLink to state

state: "deleted"

The type definition does not include a description.

}),

OldClass: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject(options: DurableObjectRenamedExportOptions): DurableObjectRenamedExport;

Rename a provisioned Durable Object namespace's class.

Options (2)

state: "renamed"
renamedTo: string: The destination class name. Must be a valid JavaScript identifier and must appear as a live (state: "created") durableObject entry in the same exports map.

state: "renamed",

stateRequiredLink to state

state: "renamed"

The type definition does not include a description.

renamedTo: "NewClass",

renamedToRequiredLink to renamedTo

renamedTo: string

The destination class name. Must be a valid JavaScript identifier and must appear as a live (state: "created") durableObject entry in the same exports map.

}),

OutgoingClass: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject(options: DurableObjectTransferredExportOptions): DurableObjectTransferredExport;

Transfer ownership of a Durable Object namespace to another Worker in the same account.

Options (2)

state: "transferred"
transferredTo: string: The destination Worker. Must reference a Worker in the same account.

state: "transferred",

stateRequiredLink to state

state: "transferred"

The type definition does not include a description.

transferredTo: "target-worker",

transferredToRequiredLink to transferredTo

transferredTo: string

The destination Worker. Must reference a Worker in the same account.

}),

IncomingClass: exports.durableObject({

durableObjectBuilderLink to durableObject

durableObject<TContainer extends ContainerDefinition | undefined = undefined>(options: DurableObjectExpectingTransferExportOptions<TContainer>): DurableObjectExpectingTransferExport<TContainer>;

Prepare to receive cross-Worker Durable Object transfer. The source Worker must follow up with a deployment containing a transferred export to commit the transfer.

Options (5)

state: "expecting-transfer"
transferFrom: string: The source Worker for the two-phase cross-Worker transfer.
storage: "sqlite": Selects the SQLite-backed storage engine (recommended for new classes).
container?: TContainer: Attach a Container application to this Durable Object by config reference.
storage: "legacy-kv": Selects the legacy key-value storage engine.

state: "expecting-transfer",

stateRequiredLink to state

state: "expecting-transfer"

The type definition does not include a description.

storage: "sqlite",

storageRequiredLink to storage

storage: "sqlite"

Selects the SQLite-backed storage engine (recommended for new classes).

transferFrom: "source-worker",

transferFromRequiredLink to transferFrom

transferFrom: string

The source Worker for the two-phase cross-Worker transfer.

}),

ApiEntrypoint: exports.worker({

workerBuilderLink to worker

worker(options?: WorkerEntrypointExportOptions): WorkerEntrypointExport;

Declares a WorkerEntrypoint export defined by this Worker.

Options (1)

cache?: { /** Whether cache is enabled for this entrypoint. */ enabled: boolean; }

cache: {

cacheOptionalLink to cache

cache?: { /** Whether cache is enabled for this entrypoint. */ enabled: boolean; }

The type definition does not include a description.

enabled: true,

enabledRequiredLink to enabled

enabled: boolean

Whether cache is enabled for this entrypoint.

}),

CheckoutWorkflow: exports.workflow({

workflowBuilderLink to workflow

workflow(options: WorkflowExportOptions): WorkflowExport;

Declares a Workflow defined by this Worker. The export's key must name a class that extends WorkflowEntrypoint. For more information about Workflows, see the documentation at https://developers.cloudflare.com/workflows/

Options (5)

name: string: The name of the Workflow. It identifies the Workflow's instances and must be unique within the account.
limits?: { /** Maximum number of steps a single Workflow instance may run. */ steps?: number; }
concurrency?: { /** Maximum number of Workflow instances that can run concurrently. */ limit?: number; }
schedules?: string | string[]: Cron schedule(s) that automatically trigger Workflow instances.
defaultRetention?: { /** How long to retain instances that completed successfully or were terminated. */ successRetention?: number | string; /** How long to retain errored instances. */ errorRetention?: number | string; }: Default retention for instances of this Workflow, applied when an instance does not set its own retention. Accepts milliseconds or a duration string such as "3 days".

nameRequiredLink to name

name: string

The name of the Workflow. It identifies the Workflow's instances and must be unique within the account.

limits: {

limitsOptionalLink to limits

limits?: { /** Maximum number of steps a single Workflow instance may run. */ steps?: number; }

The type definition does not include a description.

steps: 100,

stepsOptionalLink to steps

steps?: number

Maximum number of steps a single Workflow instance may run.

}),

});

.ace-bar { display: none !important; } .ace-panel[hidden] { display: block !important; content-visibility: visible !important; } .ace-panel-heading { display: block !important; }