配置浏览器

cloudflare.config.ts 是 TypeScript 文件，因此每个字段都有类型和说明。使用配置浏览器查看此文件如何描述应用的主要部分：项目设置、Worker、绑定、触发器和导出项。

选择一个类别，再选择高亮显示的字段，即可查看其类型、说明、默认值和可接受的选项。支持 TypeScript 的编辑器会在你编写文件时，通过自动补全和悬停提示显示相同信息；类型检查会标记不匹配的值。

要了解如何组织项目配置，请参阅以编程方式配置。要为每个环境返回不同的配置，请参阅模式。

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. "[email protected]") or a *@domain catch-all (e.g. "*@example.com").

addresses: ["[email protected]"],

addressesRequiredLink to addresses

addresses: string[]

Inbound Email Routing addresses handled by this Worker. Each entry is a literal recipient address (e.g. "[email protected]") 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; }