---
title: Developer platform Changelog
image: https://edgetunnel-b2h.pages.dev/cf-twitter-card.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://edgetunnel-b2h.pages.dev/changelog/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Changelog

New updates and improvements at Cloudflare.

[ Subscribe to RSS ](https://edgetunnel-b2h.pages.dev/changelog/rss/index.xml) [ View RSS feeds ](https://edgetunnel-b2h.pages.dev/fundamentals/new-features/available-rss-feeds/) 

Developer platform

![hero image](https://edgetunnel-b2h.pages.dev/_astro/hero.CVYJHPAd_26AMqX.svg) 

Feb 15, 2026
1. ### [New Best Practices guide for Workers](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-15-workers-best-practices/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
A new [Workers Best Practices](https://edgetunnel-b2h.pages.dev/workers/best-practices/workers-best-practices/) guide provides opinionated recommendations for building fast, reliable, observable, and secure Workers. The guide draws on production patterns, Cloudflare internal usage, and best practices observed from developers building on Workers.  
Key guidance includes:

  * **Keep your compatibility date current and enable `nodejs_compat`** — Ensure you have access to the latest runtime features and Node.js built-in modules.

  * [  wrangler.jsonc ](#tab-panel-3505)
  * [  wrangler.toml ](#tab-panel-3506)

**JSONC**  
```jsonc  
{  
  "name": "my-worker",  
  "main": "src/index.ts",  
  // Set this to today's date  
  "compatibility_date": "2026-07-20",  
  "compatibility_flags": ["nodejs_compat"],  
}  
```

**TOML**  
```toml  
name = "my-worker"  
main = "src/index.ts"  
# Set this to today's date  
compatibility_date = "2026-07-20"  
compatibility_flags = [ "nodejs_compat" ]  
```

  * **Generate binding types with `wrangler types`** — Never hand-write your `Env` interface. Let Wrangler generate it from your actual configuration to catch mismatches at compile time.
  * **Stream request and response bodies** — Avoid buffering large payloads in memory. Use `TransformStream` and `pipeTo` to stay within the 128 MB memory limit and improve time-to-first-byte.
  * **Use bindings, not REST APIs** — Bindings to KV, R2, D1, Queues, and other Cloudflare services are direct, in-process references with no network hop and no authentication overhead.
  * **Use Queues and Workflows for background work** — Move long-running or retriable tasks out of the critical request path. Use Queues for simple fan-out and buffering, and Workflows for multi-step durable processes.
  * **Enable Workers Logs and Traces** — Configure observability before deploying to production so you have data when you need to debug.
  * **Avoid global mutable state** — Workers reuse isolates across requests. Storing request-scoped data in module-level variables causes cross-request data leaks.
  * **Always `await` or `waitUntil` your Promises** — Floating promises cause silent bugs and dropped work.
  * **Use Web Crypto for secure token generation** — Never use `Math.random()` for security-sensitive operations.  
To learn more, refer to [Workers Best Practices](https://edgetunnel-b2h.pages.dev/workers/best-practices/workers-best-practices/).

Feb 13, 2026
1. ### [Cloudflare Python SDK v5.0.0-beta.1 now available](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-13-cloudflare-python-v500-beta1/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ SDK ](https://edgetunnel-b2h.pages.dev/fundamentals/api/reference/sdks/)  
> **Disclaimer:** Please note that v5.0.0-beta.1 is in Beta and we are still testing it for stability.  
Full Changelog: [v4.3.1...v5.0.0-beta.1 ↗](https://github.com/cloudflare/cloudflare-python/compare/v4.3.1...v5.0.0-beta.1)  
In this release, you'll see a large number of breaking changes. This is primarily due to a change in OpenAPI definitions, which our libraries are based off of, and codegen updates that we rely on to read those OpenAPI definitions and produce our SDK libraries. As the codegen is always evolving and improving, so are our code bases.  
There may be changes that are not captured in this changelog. Feel free to open an issue to report any inaccuracies, and we will make sure it gets into the changelog before the v5.0.0 release.  
Most of the breaking changes below are caused by improvements to the accuracy of the base OpenAPI schemas, which sometimes translates to breaking changes in downstream clients that depend on those schemas.  
Please ensure you read through the list of changes below and the migration guide before moving to this version - this will help you understand any down or upstream issues it may cause to your environments.  
#### Breaking Changes

**The following resources have breaking changes. See the [v5 Migration Guide ↗](https://github.com/cloudflare/cloudflare-python/blob/main/docs/v5-migration-guide.md) for detailed migration instructions.**

  * `abusereports`
  * `acm.totaltls`
  * `apigateway.configurations`
  * `cloudforceone.threatevents`
  * `d1.database`
  * `intel.indicatorfeeds`
  * `logpush.edge`
  * `origintlsclientauth.hostnames`
  * `queues.consumers`
  * `radar.bgp`
  * `rulesets.rules`
  * `schemavalidation.schemas`
  * `snippets`
  * `zerotrust.dlp`
  * `zerotrust.networks`  
#### Features  
#### New API Resources

  * `abusereports` \- Abuse report management
  * `abusereports.mitigations` \- Abuse report mitigation actions
  * `ai.tomarkdown` \- AI-powered markdown conversion
  * `aigateway.dynamicrouting` \- AI Gateway dynamic routing configuration
  * `aigateway.providerconfigs` \- AI Gateway provider configurations
  * `aisearch` \- AI-powered search functionality
  * `aisearch.instances` \- AI Search instance management
  * `aisearch.tokens` \- AI Search authentication tokens
  * `alerting.silences` \- Alert silence management
  * `brandprotection.logomatches` \- Brand protection logo match detection
  * `brandprotection.logos` \- Brand protection logo management
  * `brandprotection.matches` \- Brand protection match results
  * `brandprotection.queries` \- Brand protection query management
  * `cloudforceone.binarystorage` \- CloudForce One binary storage
  * `connectivity.directory` \- Connectivity directory services
  * `d1.database` \- D1 database management
  * `diagnostics.endpointhealthchecks` \- Endpoint health check diagnostics
  * `fraud` \- Fraud detection and prevention
  * `iam.sso` \- IAM Single Sign-On configuration
  * `loadbalancers.monitorgroups` \- Load balancer monitor groups
  * `organizations` \- Organization management
  * `organizations.organizationprofile` \- Organization profile settings
  * `origintlsclientauth.hostnamecertificates` \- Origin TLS client auth hostname certificates
  * `origintlsclientauth.hostnames` \- Origin TLS client auth hostnames
  * `origintlsclientauth.zonecertificates` \- Origin TLS client auth zone certificates
  * `pipelines` \- Data pipeline management
  * `pipelines.sinks` \- Pipeline sink configurations
  * `pipelines.streams` \- Pipeline stream configurations
  * `queues.subscriptions` \- Queue subscription management
  * `r2datacatalog` \- R2 Data Catalog integration
  * `r2datacatalog.credentials` \- R2 Data Catalog credentials
  * `r2datacatalog.maintenanceconfigs` \- R2 Data Catalog maintenance configurations
  * `r2datacatalog.namespaces` \- R2 Data Catalog namespaces
  * `radar.bots` \- Radar bot analytics
  * `radar.ct` \- Radar certificate transparency data
  * `radar.geolocations` \- Radar geolocation data
  * `realtimekit.activesession` \- Real-time Kit active session management
  * `realtimekit.analytics` \- Real-time Kit analytics
  * `realtimekit.apps` \- Real-time Kit application management
  * `realtimekit.livestreams` \- Real-time Kit live streaming
  * `realtimekit.meetings` \- Real-time Kit meeting management
  * `realtimekit.presets` \- Real-time Kit preset configurations
  * `realtimekit.recordings` \- Real-time Kit recording management
  * `realtimekit.sessions` \- Real-time Kit session management
  * `realtimekit.webhooks` \- Real-time Kit webhook configurations
  * `tokenvalidation.configuration` \- Token validation configuration
  * `tokenvalidation.rules` \- Token validation rules
  * `workers.beta` \- Workers beta features  
#### New Endpoints (Existing Resources)  
#### `acm.totaltls`

  * `edit()`
  * `update()`  
#### `cloudforceone.threatevents`

  * `list()`  
#### `contentscanning`

  * `create()`
  * `get()`
  * `update()`  
#### `dns.records`

  * `scan_list()`
  * `scan_review()`
  * `scan_trigger()`  
#### `intel.indicatorfeeds`

  * `create()`
  * `delete()`
  * `list()`  
#### `leakedcredentialchecks.detections`

  * `get()`  
#### `queues.consumers`

  * `list()`  
#### `radar.ai`

  * `summary()`
  * `timeseries()`
  * `timeseries_groups()`  
#### `radar.bgp`

  * `changes()`
  * `snapshot()`  
#### `workers.subdomains`

  * `delete()`  
#### `zerotrust.networks`

  * `create()`
  * `delete()`
  * `edit()`
  * `get()`
  * `list()`  
#### General Fixes and Improvements  
#### Type System & Compatibility

  * **Type inference improvements**: Allow Pyright to properly infer TypedDict types within SequenceNotStr
  * **Type completeness**: Add missing types to method arguments and response models
  * **Pydantic compatibility**: Ensure compatibility with Pydantic versions prior to 2.8.0 when using additional fields  
#### Request/Response Handling

  * **Multipart form data**: Correctly handle sending multipart/form-data requests with JSON data
  * **Header handling**: Do not send headers with default values set to omit
  * **GET request headers**: Don't send Content-Type header on GET requests
  * **Response body model accuracy**: Broad improvements to the correctness of models  
#### Parsing & Data Processing

  * **Discriminated unions**: Correctly handle nested discriminated unions in response parsing
  * **Extra field types**: Parse extra field types correctly
  * **Empty metadata**: Ignore empty metadata fields during parsing
  * **Singularization rules**: Update resource name singularization rules for better consistency

Feb 13, 2026
1. ### [Introducing GLM-4.7-Flash on Workers AI, @cloudflare/tanstack-ai, and workers-ai-provider v3.1.1](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-13-glm-47-flash-workers-ai/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ Agents ](https://edgetunnel-b2h.pages.dev/agents/)[ Workers AI ](https://edgetunnel-b2h.pages.dev/workers-ai/)  
We're excited to announce **GLM-4.7-Flash** on Workers AI, a fast and efficient text generation model optimized for multilingual dialogue and instruction-following tasks, along with the brand-new [**@cloudflare/tanstack-ai** ↗](https://www.npmjs.com/package/@cloudflare/tanstack-ai) package and [**workers-ai-provider v3.1.1** ↗](https://www.npmjs.com/package/workers-ai-provider).  
You can now run AI agents entirely on Cloudflare. With GLM-4.7-Flash's multi-turn tool calling support, plus full compatibility with TanStack AI and the Vercel AI SDK, you have everything you need to build agentic applications that run completely at the edge.  
#### GLM-4.7-Flash — Multilingual Text Generation Model  
[@cf/zai-org/glm-4.7-flash](https://edgetunnel-b2h.pages.dev/workers-ai/models/glm-4.7-flash/) is a multilingual model with a 131,072 token context window, making it ideal for long-form content generation, complex reasoning tasks, and multilingual applications.

**Key Features and Use Cases:**

  * **Multi-turn Tool Calling for Agents**: Build AI agents that can call functions and tools across multiple conversation turns
  * **Multilingual Support**: Built to handle content generation in multiple languages effectively
  * **Large Context Window**: 131,072 tokens for long-form writing, complex reasoning, and processing long documents
  * **Fast Inference**: Optimized for low-latency responses in chatbots and virtual assistants
  * **Instruction Following**: Excellent at following complex instructions for code generation and structured tasks  
Use GLM-4.7-Flash through the [Workers AI binding](https://edgetunnel-b2h.pages.dev/workers-ai/configuration/bindings/) (`env.AI.run()`), the REST API at `/run` or `/v1/chat/completions`, [AI Gateway](https://edgetunnel-b2h.pages.dev/ai-gateway/), or via [workers-ai-provider](https://edgetunnel-b2h.pages.dev/workers-ai/configuration/ai-sdk/) for the Vercel AI SDK.  
Pricing is available on the [model page](https://edgetunnel-b2h.pages.dev/workers-ai/models/glm-4.7-flash/) or [pricing page](https://edgetunnel-b2h.pages.dev/workers-ai/platform/pricing/).  
#### @cloudflare/tanstack-ai v0.1.1 — TanStack AI adapters for Workers AI and AI Gateway  
We've released `@cloudflare/tanstack-ai`, a new package that brings Workers AI and AI Gateway support to [TanStack AI ↗](https://tanstack.com/ai). This provides a framework-agnostic alternative for developers who prefer TanStack's approach to building AI applications.

**Workers AI adapters** support four configuration modes — plain binding (`env.AI`), plain REST, AI Gateway binding (`env.AI.gateway(id)`), and AI Gateway REST — across all capabilities:

  * **Chat** (`createWorkersAiChat`) — Streaming chat completions with tool calling, structured output, and reasoning text streaming.
  * **Image generation** (`createWorkersAiImage`) — Text-to-image models.
  * **Transcription** (`createWorkersAiTranscription`) — Speech-to-text.
  * **Text-to-speech** (`createWorkersAiTts`) — Audio generation.
  * **Summarization** (`createWorkersAiSummarize`) — Text summarization.

**AI Gateway adapters** route requests from third-party providers — OpenAI, Anthropic, Gemini, Grok, and OpenRouter — through Cloudflare AI Gateway for caching, rate limiting, and unified billing.  
To get started:  
```sh  
npm install @cloudflare/tanstack-ai @tanstack/ai  
```  
#### workers-ai-provider v3.1.1 — transcription, speech, reranking, and reliability  
The Workers AI provider for the [Vercel AI SDK ↗](https://ai-sdk.dev) now supports three new capabilities beyond chat and image generation:

  * **Transcription** (`provider.transcription(model)`) — Speech-to-text with automatic handling of model-specific input formats across binding and REST paths.
  * **Text-to-speech** (`provider.speech(model)`) — Audio generation with support for voice and speed options.
  * **Reranking** (`provider.reranking(model)`) — Document reranking for RAG pipelines and search result ordering.

**TypeScript**  
```typescript  
import { createWorkersAI } from "workers-ai-provider";  
import {  
  experimental_transcribe,  
  experimental_generateSpeech,  
  rerank,  
} from "ai";  
const workersai = createWorkersAI({ binding: env.AI });  
const transcript = await experimental_transcribe({  
  model: workersai.transcription("@cf/openai/whisper-large-v3-turbo"),  
  audio: audioData,  
  mediaType: "audio/wav",  
});  
const speech = await experimental_generateSpeech({  
  model: workersai.speech("@cf/deepgram/aura-1"),  
  text: "Hello world",  
  voice: "asteria",  
});  
const ranked = await rerank({  
  model: workersai.reranking("@cf/baai/bge-reranker-base"),  
  query: "What is machine learning?",  
  documents: ["ML is a branch of AI.", "The weather is sunny."],  
});  
```  
This release also includes a comprehensive reliability overhaul (v3.0.5):

  * **Fixed streaming** — Responses now stream token-by-token instead of buffering all chunks, using a proper `TransformStream` pipeline with backpressure.
  * **Fixed tool calling** — Resolved issues with tool call ID sanitization, conversation history preservation, and a heuristic that silently fell back to non-streaming mode when tools were defined.
  * **Premature stream termination detection** — Streams that end unexpectedly now report `finishReason: "error"` instead of silently reporting `"stop"`.
  * **AI Search support** — Added `createAISearch` as the canonical export (renamed from AutoRAG). `createAutoRAG` still works with a deprecation warning.  
To upgrade:  
```sh  
npm install workers-ai-provider@latest ai  
```  
#### Resources

  * [@cloudflare/tanstack-ai on npm ↗](https://www.npmjs.com/package/@cloudflare/tanstack-ai)
  * [workers-ai-provider on npm ↗](https://www.npmjs.com/package/workers-ai-provider)
  * [GitHub repository ↗](https://github.com/cloudflare/ai)

Feb 13, 2026
1. ### [Origin CA certificate support for Workers VPC](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-13-origin-ca-certificate-support/)  
[ Workers VPC ](https://edgetunnel-b2h.pages.dev/workers-vpc/)  
Workers VPC now supports [Cloudflare Origin CA certificates](https://edgetunnel-b2h.pages.dev/ssl/origin-configuration/origin-ca/) when connecting to your private services over HTTPS. Previously, Workers VPC only trusted certificates issued by publicly trusted certificate authorities (for example, Let's Encrypt, DigiCert).  
With this change, you can use free Cloudflare Origin CA certificates on your origin servers within private networks and connect to them from Workers VPC using the `https` scheme. This is useful for encrypting traffic between the tunnel and your service without needing to provision certificates from a public CA.  
For more information, refer to [Supported TLS certificates](https://edgetunnel-b2h.pages.dev/workers-vpc/configuration/vpc-services/#supported-tls-certificates).

Feb 12, 2026
1. ### [Terraform v5.17.0 now available](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-12-terraform-v5170-provider/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ Terraform ](https://edgetunnel-b2h.pages.dev/terraform/)  
In January 2025, we announced the launch of the new Terraform v5 Provider. We greatly appreciate the proactive engagement and valuable feedback from the Cloudflare community following the v5 release. In response, we have established a consistent and rapid [2-3 week cadence ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/5774) for releasing targeted improvements, demonstrating our commitment to stability and reliability.  
With the help of the community, we have a growing number of resources that we have marked as [stable ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237), with that list continuing to grow with every release. The most used [resources ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237) are on track to be stable by the end of March 2026, when we will also be releasing a new migration tool to help you migrate from v4 to v5 with ease.  
This release brings new capabilities for AI Search, enhanced Workers Script placement controls, and numerous bug fixes based on community feedback. We also begun laying foundational work for improving the v4 to v5 migration process. Stay tuned for more details as we approach the March 2026 release timeline.  
Thank you for continuing to raise issues. They make our provider stronger and help us build products that reflect your needs.  
#### Features

  * **ai\_search\_instance:** add data source for querying AI Search instances
  * **ai\_search\_token:** add data source for querying AI Search tokens
  * **account:** add support for tenant unit management with new `unit` field
  * **account:** add automatic mapping from `managed_by.parent_org_id` to `unit.id`
  * **authenticated\_origin\_pulls\_certificate:** add data source for querying authenticated origin pull certificates
  * **authenticated\_origin\_pulls\_hostname\_certificate:** add data source for querying hostname-specific authenticated origin pull certificates
  * **authenticated\_origin\_pulls\_settings:** add data source for querying authenticated origin pull settings
  * **workers\_kv:** add `value` field to data source to retrieve KV values directly
  * **workers\_script:** add `script` field to data source to retrieve script content
  * **workers\_script:** add support for `simple` rate limit binding
  * **workers\_script:** add support for targeted placement mode with `placement.target` array for specifying placement targets (region, hostname, host)
  * **workers\_script:** add `placement_mode` and `placement_status` computed fields
  * **zero\_trust\_dex\_test:** add data source with filter support for finding specific tests
  * **zero\_trust\_dlp\_predefined\_profile:** add `enabled_entries` field for flexible entry management  
#### Bug Fixes

  * **account:** map `managed_by.parent_org_id` to `unit.id` in unmarshall and add acceptance tests
  * **authenticated\_origin\_pulls\_certificate:** add certificate normalization to prevent drift
  * **authenticated\_origin\_pulls:** handle array response and implement full lifecycle
  * **authenticated\_origin\_pulls\_hostname\_certificate:** fix resource and tests
  * **cloudforce\_one\_request\_message:** use correct `request_id` field instead of `id` in API calls
  * **dns\_zone\_transfers\_incoming:** use correct `zone_id` field instead of `id` in API calls
  * **dns\_zone\_transfers\_outgoing:** use correct `zone_id` field instead of `id` in API calls
  * **email\_routing\_settings:** use correct `zone_id` field instead of `id` in API calls
  * **hyperdrive\_config:** add proper handling for write-only fields to prevent state drift
  * **hyperdrive\_config:** add normalization for empty `mtls` objects to prevent unnecessary diffs
  * **magic\_network\_monitoring\_rule:** use correct `account_id` field instead of `id` in API calls
  * **mtls\_certificates:** fix resource and test
  * **pages\_project:** revert build\_config to computed optional
  * **stream\_key:** use correct `account_id` field instead of `id` in API calls
  * **total\_tls:** use upsert pattern for singleton zone setting
  * **waiting\_room\_rules:** use correct `waiting_room_id` field instead of `id` in API calls
  * **workers\_script:** add support for placement mode/status
  * **zero\_trust\_access\_application:** update v4 version on migration tests
  * **zero\_trust\_device\_posture\_rule:** update tests to match API
  * **zero\_trust\_dlp\_integration\_entry:** use correct `entry_id` field instead of `id` in API calls
  * **zero\_trust\_dlp\_predefined\_entry:** use correct `entry_id` field instead of `id` in API calls
  * **zero\_trust\_organization:** fix plan issues  
#### Chores

  * add state upgraders to 95+ resources to lay the foundation for replacing Grit (still under active development)
  * **certificate\_pack:** add state migration handler for SDKv2 to Framework conversion
  * **custom\_hostname\_fallback\_origin:** add comprehensive lifecycle test and migration support
  * **dns\_record:** add state migration handler for SDKv2 to Framework conversion
  * **leaked\_credential\_check:** add import functionality and tests
  * **load\_balancer\_pool:** add state migration handler with detection for v4 vs v5 format
  * **pages\_project:** add state migration handlers
  * **tiered\_cache:** add state migration handlers
  * **zero\_trust\_dlp\_predefined\_profile:** deprecate `entries` field in favor of `enabled_entries`  
#### For more information

  * [Terraform Provider ↗](https://registry.terraform.io/providers/cloudflare/cloudflare/latest/docs)
  * [Documentation on using Terraform with Cloudflare](https://edgetunnel-b2h.pages.dev/terraform/)
  * [List of stabilized resources ↗](https://github.com/cloudflare/terraform-provider-cloudflare/issues/6237)

Feb 11, 2026
1. ### [Workers are no longer limited to 1000 subrequests](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-11-subrequests-limit/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Workers no longer have a limit of 1000 subrequests per invocation, allowing you to make more `fetch()` calls or requests to Cloudflare services on every incoming request. This is especially important for long-running Workers requests, such as open websockets on [Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects) or long-running [Workflows](https://edgetunnel-b2h.pages.dev/workflows), as these could often exceed this limit and error.  
By default, Workers on paid plans are now limited to 10,000 subrequests per invocation, but this limit can be increased up to 10 million by setting the new `subrequests` limit in your Wrangler configuration file.

  * [  wrangler.jsonc ](#tab-panel-3507)
  * [  wrangler.toml ](#tab-panel-3508)

**JSONC**  
```jsonc  
{  
  "limits": {  
    "subrequests": 50000,  
  },  
}  
```

**TOML**  
```toml  
[limits]  
subrequests = 50_000  
```  
Workers on the free plan remain limited to 50 external subrequests and 1000 subrequests to Cloudflare services per invocation.  
To protect against runaway code or unexpected costs, you can also set a lower limit for both subrequests and CPU usage.

  * [  wrangler.jsonc ](#tab-panel-3509)
  * [  wrangler.toml ](#tab-panel-3510)

**JSONC**  
```jsonc  
{  
  "limits": {  
    "subrequests": 10,  
    "cpu_ms": 1000,  
  },  
}  
```

**TOML**  
```toml  
[limits]  
subrequests = 10  
cpu_ms = 1_000  
```  
For more information, refer to the [Wrangler configuration documentation for limits](https://edgetunnel-b2h.pages.dev/workers/wrangler/configuration/#limits) and [subrequest limits](https://edgetunnel-b2h.pages.dev/workers/platform/limits/#subrequests).

Feb 11, 2026
1. ### [Improved React Server Components support in the Cloudflare Vite plugin](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-11-vite-plugin-child-environments/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The Cloudflare Vite plugin now integrates seamlessly [@vitejs/plugin-rsc ↗](https://github.com/vitejs/vite-plugin-react/tree/main/packages/plugin-rsc), the official Vite plugin for [React Server Components ↗](https://react.dev/reference/rsc/server-components).  
A `childEnvironments` option has been added to the plugin config to enable using multiple environments within a single Worker. The parent environment can then import modules from a child environment in order to access a separate module graph. For a typical RSC use case, the plugin might be configured as in the following example:

**vite.config.ts**  
```ts  
export default defineConfig({  
  plugins: [  
    cloudflare({  
      viteEnvironment: {  
        name: "rsc",  
        childEnvironments: ["ssr"],  
      },  
    }),  
  ],  
});  
```  
`@vitejs/plugin-rsc` provides the lower level functionality that frameworks, such as [React Router ↗](https://reactrouter.com/how-to/react-server-components), build upon. The GitHub repository includes a [basic Cloudflare example ↗](https://github.com/vitejs/vite-plugin-react/tree/f066114c3e6bf18f5209ff3d3ef6bf1ab46d3866/packages/plugin-rsc/examples/starter-cf-single).

Feb 09, 2026
1. ### [Agents SDK v0.4.0: Readonly connections, MCP security improvements, x402 v2 migration, and custom MCP OAuth providers](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-09-agents-sdk-v040/)  
[ Agents ](https://edgetunnel-b2h.pages.dev/agents/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The latest release of the [Agents SDK ↗](https://github.com/cloudflare/agents) brings readonly connections, MCP protocol and security improvements, x402 payment protocol v2 migration, and the ability to customize OAuth for MCP server connections.  
#### Readonly connections  
Agents can now restrict WebSocket clients to read-only access, preventing them from modifying agent state. This is useful for dashboards, spectator views, or any scenario where clients should observe but not mutate.  
New hooks: `shouldConnectionBeReadonly`, `setConnectionReadonly`, `isConnectionReadonly`. Readonly connections block both client-side `setState()` and mutating `@callable()` methods, and the readonly flag survives hibernation.

  * [  JavaScript ](#tab-panel-3519)
  * [  TypeScript ](#tab-panel-3520)

**JavaScript**  
```js  
class MyAgent extends Agent {  
  shouldConnectionBeReadonly(connection) {  
    // Make spectators readonly  
    return connection.url.includes("spectator");  
  }  
}  
```

**TypeScript**  
```ts  
class MyAgent extends Agent {  
  shouldConnectionBeReadonly(connection) {  
    // Make spectators readonly  
    return connection.url.includes("spectator");  
  }  
}  
```  
#### Custom MCP OAuth providers  
The new `createMcpOAuthProvider` method on the `Agent` class allows subclasses to override the default OAuth provider used when connecting to MCP servers. This enables custom authentication strategies such as pre-registered client credentials or mTLS, beyond the built-in dynamic client registration.

  * [  JavaScript ](#tab-panel-3523)
  * [  TypeScript ](#tab-panel-3524)

**JavaScript**  
```js  
class MyAgent extends Agent {  
  createMcpOAuthProvider(callbackUrl) {  
    return new MyCustomOAuthProvider(this.ctx.storage, this.name, callbackUrl);  
  }  
}  
```

**TypeScript**  
```ts  
class MyAgent extends Agent {  
  createMcpOAuthProvider(callbackUrl: string): AgentMcpOAuthProvider {  
    return new MyCustomOAuthProvider(this.ctx.storage, this.name, callbackUrl);  
  }  
}  
```  
#### MCP SDK upgrade to 1.26.0  
Upgraded the MCP SDK to 1.26.0 to prevent cross-client response leakage. Stateless MCP Servers should now create a new `McpServer` instance per request instead of sharing a single instance. A guard is added in this version of the MCP SDK which will prevent connection to a Server instance that has already been connected to a transport. Developers will need to modify their code if they declare their `McpServer` instance as a global variable.  
#### MCP OAuth callback URL security fix  
Added `callbackPath` option to `addMcpServer` to prevent instance name leakage in MCP OAuth callback URLs. When `sendIdentityOnConnect` is `false`, `callbackPath` is now required — the default callback URL would expose the instance name, undermining the security intent. Also fixes callback request detection to match via the `state` parameter instead of a loose `/callback` URL substring check, enabling custom callback paths.  
#### Deprecate `onStateUpdate` in favor of `onStateChanged`  
`onStateChanged` is a drop-in rename of `onStateUpdate` (same signature, same behavior). `onStateUpdate` still works but emits a one-time console warning per class. `validateStateChange` rejections now propagate a `CF_AGENT_STATE_ERROR` message back to the client.  
#### x402 v2 migration  
Migrated the x402 MCP payment integration from the legacy `x402` package to `@x402/core` and `@x402/evm` v2.

**Breaking changes for x402 users:**

  * Peer dependencies changed: replace `x402` with `@x402/core` and `@x402/evm`
  * `PaymentRequirements` type now uses v2 fields (e.g. `amount` instead of `maxAmountRequired`)
  * `X402ClientConfig.account` type changed from `viem.Account` to `ClientEvmSigner` (structurally compatible with `privateKeyToAccount()`)  
```bash  
npm uninstall x402  
npm install @x402/core @x402/evm  
```  
Network identifiers now accept both legacy names and CAIP-2 format:

**TypeScript**  
```ts  
// Legacy name (auto-converted)  
{  
  network: "base-sepolia",  
}  
// CAIP-2 format (preferred)  
{  
  network: "eip155:84532",  
}  
```

**Other x402 changes:**

  * `X402ClientConfig.network` is now optional — the client auto-selects from available payment requirements
  * Server-side lazy initialization: facilitator connection is deferred until the first paid tool invocation
  * Payment tokens support both v2 (`PAYMENT-SIGNATURE`) and v1 (`X-PAYMENT`) HTTP headers
  * Added `normalizeNetwork` export for converting legacy network names to CAIP-2 format
  * Re-exports `PaymentRequirements`, `PaymentRequired`, `Network`, `FacilitatorConfig`, and `ClientEvmSigner` from `agents/x402`  
#### Other improvements

  * Fix `useAgent` and `AgentClient` crashing when using `basePath` routing
  * CORS handling delegated to partyserver's native support (simpler, more reliable)
  * Client-side `onStateUpdateError` callback for handling rejected state updates  
#### Upgrade  
To update to the latest version:  
```sh  
npm i agents@latest  
```

Feb 09, 2026
1. ### [Interactive browser terminals in Sandboxes](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-09-pty-terminal-support/)  
[ Agents ](https://edgetunnel-b2h.pages.dev/agents/)  
The [Sandbox SDK ↗](https://github.com/cloudflare/sandbox-sdk) now supports PTY (pseudo-terminal) passthrough, enabling browser-based terminal UIs to connect to sandbox shells via WebSocket.  
#### `sandbox.terminal(request)`  
The new `terminal()` method proxies a WebSocket upgrade to the container's PTY endpoint, with output buffering for replay on reconnect.

  * [  JavaScript ](#tab-panel-3521)
  * [  TypeScript ](#tab-panel-3522)

**JavaScript**  
```js  
// Worker: proxy WebSocket to container terminal  
return sandbox.terminal(request, { cols: 80, rows: 24 });  
```

**TypeScript**  
```ts  
// Worker: proxy WebSocket to container terminal  
return sandbox.terminal(request, { cols: 80, rows: 24 });  
```  
#### Multiple terminals per sandbox  
Each session can have its own terminal with an isolated working directory and environment, so users can run separate shells side-by-side in the same container.

  * [  JavaScript ](#tab-panel-3525)
  * [  TypeScript ](#tab-panel-3526)

**JavaScript**  
```js  
// Multiple isolated terminals in the same sandbox  
const dev = await sandbox.getSession("dev");  
return dev.terminal(request);  
```

**TypeScript**  
```ts  
// Multiple isolated terminals in the same sandbox  
const dev = await sandbox.getSession("dev");  
return dev.terminal(request);  
```  
#### xterm.js addon  
The new `@cloudflare/sandbox/xterm` export provides a `SandboxAddon` for [xterm.js ↗](https://xtermjs.org/) with automatic reconnection (exponential backoff + jitter), buffered output replay, and resize forwarding.

  * [  JavaScript ](#tab-panel-3527)
  * [  TypeScript ](#tab-panel-3528)

**JavaScript**  
```js  
import { SandboxAddon } from "@cloudflare/sandbox/xterm";  
const addon = new SandboxAddon({  
  getWebSocketUrl: ({ sandboxId, origin }) =>  
    `${origin}/ws/terminal?id=${sandboxId}`,  
  onStateChange: (state, error) => updateUI(state),  
});  
terminal.loadAddon(addon);  
addon.connect({ sandboxId: "my-sandbox" });  
```

**TypeScript**  
```ts  
import { SandboxAddon } from "@cloudflare/sandbox/xterm";  
const addon = new SandboxAddon({  
  getWebSocketUrl: ({ sandboxId, origin }) =>  
    `${origin}/ws/terminal?id=${sandboxId}`,  
  onStateChange: (state, error) => updateUI(state),  
});  
terminal.loadAddon(addon);  
addon.connect({ sandboxId: "my-sandbox" });  
```  
#### Upgrade  
To update to the latest version:  
```sh  
npm i @cloudflare/sandbox@latest  
```

Feb 09, 2026
1. ### [AI Search now with more granular controls over indexing](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-09-indexing-improvements/)  
[ AI Search ](https://edgetunnel-b2h.pages.dev/ai-search/)  
Get your content updates into [AI Search](https://edgetunnel-b2h.pages.dev/ai-search/) faster and avoid a full rescan when you do not need it.  
#### Reindex individual files without a full sync  
Updated a file or need to retry one that errored? When you know exactly which file changed, you can now [reindex it directly](https://edgetunnel-b2h.pages.dev/ai-search/configuration/indexing/syncing/#controls) instead of rescanning your entire data source.  
Go to **Overview** \> **Indexed Items** and select the sync icon next to any file to reindex it immediately.  
![Sync individual files from Indexed Items](https://edgetunnel-b2h.pages.dev/_astro/individual-file-indexing.CQgoIj85_ZIBUBg.webp)  
#### Crawl only the sitemap you need  
By default, AI Search crawls all sitemaps listed in your `robots.txt`, up to the [maximum files per index limit](https://edgetunnel-b2h.pages.dev/ai-search/platform/limits-pricing/#limits). If your site has multiple sitemaps but you only want to index a specific set, you can now [specify a single sitemap URL](https://edgetunnel-b2h.pages.dev/ai-search/configuration/data-source/website/#sitemap) to limit what the crawler visits.  
For example, if your `robots.txt` lists both `blog-sitemap.xml` and `docs-sitemap.xml`, you can specify just `https://example.com/docs-sitemap.xml` to index only your documentation.  
Configure your selection anytime in **Settings** \> **Parsing options** \> **Specific sitemaps**, then trigger a sync to apply the changes.  
![Specify a sitemap in Parsinh options](https://edgetunnel-b2h.pages.dev/_astro/specify-sitemap.pLCkwmJ-_2vbphB.webp)  
Learn more about [indexing controls](https://edgetunnel-b2h.pages.dev/ai-search/configuration/indexing/syncing/#controls) and [website crawling configuration](https://edgetunnel-b2h.pages.dev/ai-search/configuration/data-source/website/#sitemap).

Feb 09, 2026
1. ### [R2 SQL now supports approximate aggregation functions](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-09-approximate-aggregation-functions/)  
[ R2 SQL ](https://edgetunnel-b2h.pages.dev/r2-sql/)  
R2 SQL now supports five approximate aggregation functions for fast analysis of large datasets. These functions trade minor precision for improved performance on high-cardinality data.  
#### New functions

  * `APPROX_PERCENTILE_CONT(column, percentile)` — Returns the approximate value at a given percentile (0.0 to 1.0). Works on integer and decimal columns.
  * `APPROX_PERCENTILE_CONT_WITH_WEIGHT(column, weight, percentile)` — Weighted percentile calculation where each row contributes proportionally to its weight column value.
  * `APPROX_MEDIAN(column)` — Returns the approximate median. Equivalent to `APPROX_PERCENTILE_CONT(column, 0.5)`.
  * `APPROX_DISTINCT(column)` — Returns the approximate number of distinct values. Works on any column type.
  * `APPROX_TOP_K(column, k)` — Returns the `k` most frequent values with their counts as a JSON array.  
All functions support `WHERE` filters. All except `APPROX_TOP_K` support `GROUP BY`.  
#### Examples  
```sql
-- Percentile analysis on revenue data  
SELECT approx_percentile_cont(total_amount, 0.25),  
       approx_percentile_cont(total_amount, 0.5),  
       approx_percentile_cont(total_amount, 0.75)  
FROM my_namespace.sales_data  
```  
```sql
-- Median per department  
SELECT department, approx_median(total_amount)  
FROM my_namespace.sales_data  
GROUP BY department  
```  
```sql
-- Approximate distinct customers by region  
SELECT region, approx_distinct(customer_id)  
FROM my_namespace.sales_data  
GROUP BY region  
```  
```sql
-- Top 5 most frequent departments  
SELECT approx_top_k(department, 5)  
FROM my_namespace.sales_data  
```  
```sql
-- Combine approximate and standard aggregations  
SELECT COUNT(*),  
       AVG(total_amount),  
       approx_percentile_cont(total_amount, 0.5),  
       approx_distinct(customer_id)  
FROM my_namespace.sales_data  
WHERE region = 'North'  
```  
For the full syntax and additional examples, refer to the [SQL reference](https://edgetunnel-b2h.pages.dev/r2-sql/sql-reference/).

Feb 06, 2026
1. ### [Visualize data, share links, and create exports with the new Workers Observability dashboard](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-06-observability-ui-refresh/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The [Workers Observability dashboard ↗](https://dash.cloudflare.com/?to=/:account/workers-and-pages/observability/) has some major updates to make it easier to debug your application's issues and share findings with your team.  
![Workers Observability dashboard showing events view with event details and share options](https://edgetunnel-b2h.pages.dev/_astro/2026-01-22-events_share_obs_wobs.BvzY4TNV_eC7Hu.webp)  
You can now:

  * **Create visualizations** — Build charts from your Worker data directly in a Worker's Observability tab
  * **Export data as JSON or CSV** — Download logs and traces for offline analysis or to share with teammates
  * **Share events and traces** — Generate direct URLs to specific events, invocations, and traces that open standalone pages with full context
  * **Customize table columns** — Improved field picker to add, remove, and reorder columns in the events table
  * **Expandable event details** — Expand events inline to view full details without leaving the table
  * **Keyboard shortcuts** — Navigate the dashboard with hotkey support  
![Workers Observability dashboard showing a P99 CPU time visualization grouped by outcome](https://edgetunnel-b2h.pages.dev/_astro/2026-01-22-vis_qb_wobs.Bb5eVQNT_at6AT.webp)  
These updates are now live in the Cloudflare dashboard, both in a Worker's Observability tab and in the account-level Observability dashboard for a unified experience. To get started, go to **Workers & Pages** \> select your Worker > **Observability**.

Feb 04, 2026
1. ### [Cloudflare Queues now available on Workers Free plan](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-04-queues-free-plan/)  
[ Queues ](https://edgetunnel-b2h.pages.dev/queues/)  
[Cloudflare Queues](https://edgetunnel-b2h.pages.dev/queues) is now part of the Workers free plan, offering guaranteed message delivery across up to **10,000 queues** to either [Cloudflare Workers](https://edgetunnel-b2h.pages.dev/workers) or [HTTP pull consumers](https://edgetunnel-b2h.pages.dev/queues/configuration/pull-consumers). Every Cloudflare account now includes **10,000 operations per day** across reads, writes, and deletes. For more details on how each operation is defined, refer to [Queues pricing ↗](https://edgetunnel-b2h.pages.dev/workers/platform/pricing/#queues).  
All features of the existing Queues functionality are available on the free plan, including unlimited [event subscriptions](https://edgetunnel-b2h.pages.dev/queues/event-subscriptions/). Note that the maximum retention period on the free tier, however, is 24 hours rather than 14 days.  
If you are new to Cloudflare Queues, follow [this guide ↗](https://edgetunnel-b2h.pages.dev/queues/get-started/) or try one of our [tutorials](https://edgetunnel-b2h.pages.dev/queues/tutorials/) to get started.

Feb 04, 2026
1. ### [Visualize your Workflows in the Cloudflare dashboard](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-03-workflows-visualizer/)  
[ Workflows ](https://edgetunnel-b2h.pages.dev/workflows/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Cloudflare Workflows now automatically generates visual diagrams from your code  
Your Workflow is parsed to provide a visual map of the Workflow structure, allowing you to:

  * Understand how steps connect and execute
  * Visualize loops and nested logic
  * Follow branching paths for conditional logic  
![Example diagram](https://edgetunnel-b2h.pages.dev/_astro/2026-02-03-workflows-diagram.BfQAnWL3_Z203oFd.webp)  
You can collapse loops and nested logic to see the high-level flow, or expand them to see every step.  
Workflow diagrams are available in beta for all JavaScript and TypeScript Workflows. Find your Workflows in the [Cloudflare dashboard ↗](https://dash.cloudflare.com/?to=/:account/workers/workflows) to see their diagrams.

Feb 03, 2026
1. ### [Agents SDK v0.3.7: Workflows integration, synchronous state, and scheduleEvery()](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-03-agents-workflows-integration/)  
[ Agents ](https://edgetunnel-b2h.pages.dev/agents/)[ Workflows ](https://edgetunnel-b2h.pages.dev/workflows/)  
The latest release of the [Agents SDK ↗](https://github.com/cloudflare/agents) brings first-class support for [Cloudflare Workflows](https://edgetunnel-b2h.pages.dev/workflows/), synchronous state management, and new scheduling capabilities.  
#### Cloudflare Workflows integration  
Agents excel at real-time communication and state management. Workflows excel at durable execution. Together, they enable powerful patterns where Agents handle WebSocket connections while Workflows handle long-running tasks, retries, and human-in-the-loop flows.  
Use the new `AgentWorkflow` class to define workflows with typed access to your Agent:

  * [  JavaScript ](#tab-panel-3537)
  * [  TypeScript ](#tab-panel-3538)

**JavaScript**  
```js  
import { AgentWorkflow } from "agents/workflows";  
export class ProcessingWorkflow extends AgentWorkflow {  
  async run(event, step) {  
    // Call Agent methods via RPC  
    await this.agent.updateStatus(event.payload.taskId, "processing");  
    // Non-durable: progress reporting to clients  
    await this.reportProgress({ step: "process", percent: 0.5 });  
    this.broadcastToClients({ type: "update", taskId: event.payload.taskId });  
    // Durable via step: idempotent, won't repeat on retry  
    await step.mergeAgentState({ taskProgress: 0.5 });  
    const result = await step.do("process", async () => {  
      return processData(event.payload.data);  
    });  
    await step.reportComplete(result);  
    return result;  
  }  
}  
```

**TypeScript**  
```ts  
import { AgentWorkflow } from "agents/workflows";  
import type { AgentWorkflowEvent, AgentWorkflowStep } from "agents/workflows";  
export class ProcessingWorkflow extends AgentWorkflow<MyAgent, TaskParams> {  
  async run(event: AgentWorkflowEvent<TaskParams>, step: AgentWorkflowStep) {  
    // Call Agent methods via RPC  
    await this.agent.updateStatus(event.payload.taskId, "processing");  
    // Non-durable: progress reporting to clients  
    await this.reportProgress({ step: "process", percent: 0.5 });  
    this.broadcastToClients({ type: "update", taskId: event.payload.taskId });  
    // Durable via step: idempotent, won't repeat on retry  
    await step.mergeAgentState({ taskProgress: 0.5 });  
    const result = await step.do("process", async () => {  
      return processData(event.payload.data);  
    });  
    await step.reportComplete(result);  
    return result;  
  }  
}  
```  
Start workflows from your Agent with `runWorkflow()` and handle lifecycle events:

  * [  JavaScript ](#tab-panel-3539)
  * [  TypeScript ](#tab-panel-3540)

**JavaScript**  
```js  
export class MyAgent extends Agent {  
  async startTask(taskId, data) {  
    const instanceId = await this.runWorkflow("PROCESSING_WORKFLOW", {  
      taskId,  
      data,  
    });  
    return { instanceId };  
  }  
  async onWorkflowProgress(workflowName, instanceId, progress) {  
    this.broadcast(JSON.stringify({ type: "progress", progress }));  
  }  
  async onWorkflowComplete(workflowName, instanceId, result) {  
    console.log(`Workflow ${instanceId} completed`);  
  }  
  async onWorkflowError(workflowName, instanceId, error) {  
    console.error(`Workflow ${instanceId} failed:`, error);  
  }  
}  
```

**TypeScript**  
```ts  
export class MyAgent extends Agent {  
  async startTask(taskId: string, data: string) {  
    const instanceId = await this.runWorkflow("PROCESSING_WORKFLOW", {  
      taskId,  
      data,  
    });  
    return { instanceId };  
  }  
  async onWorkflowProgress(  
    workflowName: string,  
    instanceId: string,  
    progress: unknown,  
  ) {  
    this.broadcast(JSON.stringify({ type: "progress", progress }));  
  }  
  async onWorkflowComplete(  
    workflowName: string,  
    instanceId: string,  
    result?: unknown,  
  ) {  
    console.log(`Workflow ${instanceId} completed`);  
  }  
  async onWorkflowError(  
    workflowName: string,  
    instanceId: string,  
    error: unknown,  
  ) {  
    console.error(`Workflow ${instanceId} failed:`, error);  
  }  
}  
```  
Key workflow methods on your Agent:

  * `runWorkflow(workflowName, params, options?)` — Start a workflow with optional metadata
  * `getWorkflow(workflowId)` / `getWorkflows(criteria?)` — Query workflows with cursor-based pagination
  * `approveWorkflow(workflowId)` / `rejectWorkflow(workflowId)` — Human-in-the-loop approval flows
  * `pauseWorkflow()`, `resumeWorkflow()`, `terminateWorkflow()` — Workflow control  
#### Synchronous setState()  
State updates are now synchronous with a new `validateStateChange()` validation hook:

  * [  JavaScript ](#tab-panel-3531)
  * [  TypeScript ](#tab-panel-3532)

**JavaScript**  
```js  
export class MyAgent extends Agent {  
  validateStateChange(oldState, newState) {  
    // Return false to reject the change  
    if (newState.count < 0) return false;  
    // Return modified state to transform  
    return { ...newState, lastUpdated: Date.now() };  
  }  
}  
```

**TypeScript**  
```ts  
export class MyAgent extends Agent<Env, State> {  
  validateStateChange(oldState: State, newState: State): State | false {  
    // Return false to reject the change  
    if (newState.count < 0) return false;  
    // Return modified state to transform  
    return { ...newState, lastUpdated: Date.now() };  
  }  
}  
```  
#### scheduleEvery() for recurring tasks  
The new `scheduleEvery()` method enables fixed-interval recurring tasks with built-in overlap prevention:

  * [  JavaScript ](#tab-panel-3529)
  * [  TypeScript ](#tab-panel-3530)

**JavaScript**  
```js  
// Run every 5 minutes  
await this.scheduleEvery("syncData", 5 * 60 * 1000, { source: "api" });  
```

**TypeScript**  
```ts  
// Run every 5 minutes  
await this.scheduleEvery("syncData", 5 * 60 * 1000, { source: "api" });  
```  
#### Callable system improvements

  * **Client-side RPC timeout** — Set timeouts on callable method invocations
  * **`StreamingResponse.error(message)`** — Graceful stream error signaling
  * **`getCallableMethods()`** — Introspection API for discovering callable methods
  * **Connection close handling** — Pending calls are automatically rejected on disconnect

  * [  JavaScript ](#tab-panel-3533)
  * [  TypeScript ](#tab-panel-3534)

**JavaScript**  
```js  
await agent.call("method", [args], {  
  timeout: 5000,  
  stream: { onChunk, onDone, onError },  
});  
```

**TypeScript**  
```ts  
await agent.call("method", [args], {  
  timeout: 5000,  
  stream: { onChunk, onDone, onError },  
});  
```  
#### Email and routing enhancements

**Secure email reply routing** — Email replies are now secured with HMAC-SHA256 signed headers, preventing unauthorized routing of emails to agent instances.

**Routing improvements:**

  * `basePath` option to bypass default URL construction for custom routing
  * Server-sent identity — Agents send `name` and `agent` type on connect
  * New `onIdentity` and `onIdentityChange` callbacks on the client

  * [  JavaScript ](#tab-panel-3535)
  * [  TypeScript ](#tab-panel-3536)

**JavaScript**  
```js  
const agent = useAgent({  
  basePath: "user",  
  onIdentity: (name, agentType) => console.log(`Connected to ${name}`),  
});  
```

**TypeScript**  
```ts  
const agent = useAgent({  
  basePath: "user",  
  onIdentity: (name, agentType) => console.log(`Connected to ${name}`),  
});  
```  
#### Upgrade  
To update to the latest version:  
```sh  
npm i agents@latest  
```  
For the complete Workflows API reference and patterns, see [Run Workflows](https://edgetunnel-b2h.pages.dev/agents/runtime/execution/run-workflows/).

Feb 03, 2026
1. ### [Improve Global Upload Performance with R2 Local Uploads - Now in Open Beta](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-03-r2-local-uploads/)  
[ R2 ](https://edgetunnel-b2h.pages.dev/r2/)  
[Local Uploads](https://edgetunnel-b2h.pages.dev/r2/buckets/local-uploads/) is now available in open beta. Enable it on your [R2](https://edgetunnel-b2h.pages.dev/r2/) bucket to improve upload performance when clients upload data from a different region than your bucket. With Local Uploads enabled, object data is written to storage infrastructure near the client, then asynchronously replicated to your bucket. The object is immediately accessible and remains strongly consistent throughout. Refer to [How R2 works](https://edgetunnel-b2h.pages.dev/r2/how-r2-works/) for details on how data is written to your bucket.  
In our tests, we observed **up to 75% reduction in Time to Last Byte (TTLB)** for upload requests when Local Uploads is enabled.  
![Local Uploads latency comparison showing p50 TTLB dropping from around 2 seconds to 500ms after enabling Local Uploads](https://edgetunnel-b2h.pages.dev/_astro/local-uploads-latency.R4pUgVuI_2cwpHU.webp)  
This feature is ideal when:

  * Your users are globally distributed
  * Upload performance and reliability is critical to your application
  * You want to optimize write performance without changing your bucket's primary location  
To enable Local Uploads on your bucket, find **Local Uploads** in your bucket settings in the [Cloudflare Dashboard ↗](https://dash.cloudflare.com/?to=/:account/r2/overview), or run:  
```sh  
npx wrangler r2 bucket local-uploads enable <BUCKET_NAME>  
```  
Enabling Local Uploads on a bucket is seamless: existing uploads will complete as expected and there’s no interruption to traffic. There is no additional cost to enable Local Uploads. Upload requests incur the standard [Class A operation costs](https://edgetunnel-b2h.pages.dev/r2/pricing/) same as upload requests made without Local Uploads.  
For more information, refer to [Local Uploads](https://edgetunnel-b2h.pages.dev/r2/buckets/local-uploads/).

Jan 30, 2026
1. ### [Reduced minimum cache TTL for Workers KV to 30 seconds](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-30-kv-reduced-minimum-cachettl/)  
[ KV ](https://edgetunnel-b2h.pages.dev/kv/)  
The minimum `cacheTtl` parameter for Workers KV has been reduced from 60 seconds to 30 seconds. This change applies to both `get()` and `getWithMetadata()` methods.  
This reduction allows you to maintain more up-to-date cached data and have finer-grained control over cache behavior. Applications requiring faster data refresh rates can now configure cache durations as low as 30 seconds instead of the previous 60-second minimum.  
The `cacheTtl` parameter defines how long a KV result is cached at the global network location it is accessed from:

**JavaScript**  
```js  
// Read with custom cache TTL  
const value = await env.NAMESPACE.get("my-key", {  
  cacheTtl: 30, // Cache for minimum 30 seconds (previously 60)  
});  
// getWithMetadata also supports the reduced cache TTL  
const valueWithMetadata = await env.NAMESPACE.getWithMetadata("my-key", {  
  cacheTtl: 30, // Cache for minimum 30 seconds  
});  
```  
The default cache TTL remains unchanged at 60 seconds. Upgrade to the latest version of Wrangler to be able to use 30 seconds `cacheTtl`.  
This change affects all KV read operations using the binding API. For more information, consult the [Workers KV cache TTL documentation](https://edgetunnel-b2h.pages.dev/kv/api/read-key-value-pairs/#cachettl-parameter).

Jan 28, 2026
1. ### [Launching FLUX.2 \[klein\] 9B on Workers AI](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-28-flux-2-klein-9b-workers-ai/)  
[ Workers AI ](https://edgetunnel-b2h.pages.dev/workers-ai/)  
We have partnered with Black Forest Labs (BFL) again to bring their optimized FLUX.2 \[klein\] 9B model to Workers AI. This distilled model offers enhanced quality compared to the 4B variant, while maintaining cost-effective pricing. With a fixed 4-step inference process, Klein 9B is ideal for rapid prototyping and real-time applications where both speed and quality matter.  
Read the [BFL blog ↗](https://bfl.ai/blog) to learn more about the model itself, or try it out yourself on our [multi modal playground ↗](https://multi-modal.ai.cloudflare.com/).  
Pricing documentation is available on the [model page](https://edgetunnel-b2h.pages.dev/workers-ai/models/flux-2-klein-9b/) or [pricing page](https://edgetunnel-b2h.pages.dev/workers-ai/platform/pricing/).  
#### Workers AI platform specifics  
The model hosted on Workers AI is optimized for speed with a **fixed 4-step inference process** and supports up to 4 image inputs. Since this is a distilled model, the `steps` parameter is fixed at 4 and cannot be adjusted. Like FLUX.2 \[dev\] and FLUX.2 \[klein\] 4B, this image model uses multipart form data inputs, even if you just have a prompt.  
With the REST API, the multipart form data input looks like this:  
```bash  
curl --request POST \
  --url 'https://api.cloudflare.com/client/v4/accounts/{ACCOUNT}/ai/run/@cf/black-forest-labs/flux-2-klein-9b' \
  --header 'Authorization: Bearer {TOKEN}' \
  --header 'Content-Type: multipart/form-data' \
  --form 'prompt=a sunset at the alps' \
  --form width=1024 \
  --form height=1024  
```  
With the Workers AI binding, you can use it as such:

**JavaScript**  
```javascript  
const form = new FormData();  
form.append("prompt", "a sunset with a dog");  
form.append("width", "1024");  
form.append("height", "1024");  
// FormData doesn't expose its serialized body or boundary. Passing it to a  
// Request (or Response) constructor serializes it and generates the Content-Type  
// header with the boundary, which is required for the server to parse the multipart fields.  
const formResponse = new Response(form);  
const formStream = formResponse.body;  
const formContentType = formResponse.headers.get('content-type');  
const resp = await env.AI.run("@cf/black-forest-labs/flux-2-klein-9b", {  
  multipart: {  
    body: formStream,  
    contentType: formContentType,  
  },  
});  
```  
The parameters you can send to the model are detailed here:  
JSON Schema for Model **Required Parameters**
  * `prompt` (string) - Text description of the image to generate

**Optional Parameters**

  * `input_image_0` (string) - Binary image
  * `input_image_1` (string) - Binary image
  * `input_image_2` (string) - Binary image
  * `input_image_3` (string) - Binary image
  * `guidance` (float) - Guidance scale for generation. Higher values follow the prompt more closely
  * `width` (integer) - Width of the image, default `1024` Range: 256-1920
  * `height` (integer) - Height of the image, default `768` Range: 256-1920
  * `seed` (integer) - Seed for reproducibility

**Note:** Since this is a distilled model, the `steps` parameter is fixed at 4 and cannot be adjusted.  
#### Multi-reference images  
The FLUX.2 klein-9b model supports generating images based on reference images, just like FLUX.2 \[dev\] and FLUX.2 \[klein\] 4B. You can use this feature to apply the style of one image to another, add a new character to an image, or iterate on past generated images. You would use it with the same multipart form data structure, with the input images in binary. The model supports up to 4 input images.  
For the prompt, you can reference the images based on the index, like `take the subject of image 1 and style it like image 0` or even use natural language like `place the dog beside the woman`.  
You must name the input parameter as `input_image_0`, `input_image_1`, `input_image_2`, `input_image_3` for it to work correctly. All input images must be smaller than 512x512.  
```bash  
curl --request POST \
  --url 'https://api.cloudflare.com/client/v4/accounts/{ACCOUNT}/ai/run/@cf/black-forest-labs/flux-2-klein-9b' \
  --header 'Authorization: Bearer {TOKEN}' \
  --header 'Content-Type: multipart/form-data' \
  --form 'prompt=take the subject of image 1 and style it like image 0' \
  --form input_image_0=@/Users/johndoe/Desktop/icedoutkeanu.png \
  --form input_image_1=@/Users/johndoe/Desktop/me.png \
  --form width=1024 \
  --form height=1024  
```  
Through Workers AI Binding:

**JavaScript**  
```javascript  
//helper function to convert ReadableStream to Blob  
async function streamToBlob(stream: ReadableStream, contentType: string): Promise<Blob> {  
  const reader = stream.getReader();  
  const chunks = [];  
  while (true) {  
    const { done, value } = await reader.read();  
    if (done) break;  
    chunks.push(value);  
  }  
  return new Blob(chunks, { type: contentType });  
}  
const image0 = await fetch("http://image-url");  
const image1 = await fetch("http://image-url");  
const form = new FormData();  
const image_blob0 = await streamToBlob(image0.body, "image/png");  
const image_blob1 = await streamToBlob(image1.body, "image/png");  
form.append('input_image_0', image_blob0)  
form.append('input_image_1', image_blob1)  
form.append('prompt', 'take the subject of image 1 and style it like image 0')  
// FormData doesn't expose its serialized body or boundary. Passing it to a  
// Request (or Response) constructor serializes it and generates the Content-Type  
// header with the boundary, which is required for the server to parse the multipart fields.  
const formResponse = new Response(form);  
const formStream = formResponse.body;  
const formContentType = formResponse.headers.get('content-type');  
const resp = await env.AI.run("@cf/black-forest-labs/flux-2-klein-9b", {  
    multipart: {  
        body: formStream,  
        contentType: formContentType  
    }  
})  
```

Jan 23, 2026
1. ### [Increased Pages file limit to 100,000 for paid plans](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-23-pages-file-limit-increase/)  
[ Pages ](https://edgetunnel-b2h.pages.dev/pages/)  
Paid plans can now have up to 100,000 files per Pages site, increased from the previous limit of 20,000 files.  
To enable this increased limit, set the environment variable `PAGES_WRANGLER_MAJOR_VERSION=4` in your Pages project settings.  
The Free plan remains at 20,000 files per site.  
For more details, refer to the [Pages limits documentation](https://edgetunnel-b2h.pages.dev/pages/platform/limits/#files).

Jan 23, 2026
1. ### [Vectorize indexes now support up to 10 million vectors](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-23-increased-index-capacity/)  
[ Vectorize ](https://edgetunnel-b2h.pages.dev/vectorize/)  
You can now store up to 10 million vectors in a single Vectorize index, doubling the previous limit of 5 million vectors. This enables larger-scale semantic search, recommendation systems, and retrieval-augmented generation (RAG) applications without splitting data across multiple indexes.  
Vectorize continues to support indexes with up to 1,536 dimensions per vector at 32-bit precision. Refer to the [Vectorize limits documentation](https://edgetunnel-b2h.pages.dev/vectorize/platform/limits/) for complete details.

Jan 22, 2026
1. ### [New Placement Hints for Workers](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-22-explicit-placement-hints/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
You can now configure Workers to run close to infrastructure in legacy cloud regions to minimize latency to existing services and databases. This is most useful when your Worker makes multiple round trips.  
To [set a placement hint](https://edgetunnel-b2h.pages.dev/workers/configuration/placement/#configure-explicit-placement-hints), set the `placement.region` property in your Wrangler configuration file:

  * [  wrangler.jsonc ](#tab-panel-3511)
  * [  wrangler.toml ](#tab-panel-3512)

**JSONC**  
```jsonc  
{  
  "placement": {  
    "region": "aws:us-east-1",  
  },  
}  
```

**TOML**  
```toml  
[placement]  
region = "aws:us-east-1"  
```  
Placement hints support Amazon Web Services (AWS), Google Cloud Platform (GCP), and Microsoft Azure region identifiers. Workers run in the [Cloudflare data center ↗](https://www.cloudflare.com/network/) with the lowest latency to the specified cloud region.  
If your existing infrastructure is not in these cloud providers, expose it to placement probes with `placement.host` for layer 4 checks or `placement.hostname` for layer 7 checks. These probes are designed to locate single-homed infrastructure and are not suitable for anycasted or multicasted resources.

  * [  wrangler.jsonc ](#tab-panel-3513)
  * [  wrangler.toml ](#tab-panel-3514)

**JSONC**  
```jsonc  
{  
  "placement": {  
    "host": "my_database_host.com:5432",  
  },  
}  
```

**TOML**  
```toml  
[placement]  
host = "my_database_host.com:5432"  
```

  * [  wrangler.jsonc ](#tab-panel-3515)
  * [  wrangler.toml ](#tab-panel-3516)

**JSONC**  
```jsonc  
{  
  "placement": {  
    "hostname": "my_api_server.com",  
  },  
}  
```

**TOML**  
```toml  
[placement]  
hostname = "my_api_server.com"  
```  
This is an extension of [Smart Placement](https://edgetunnel-b2h.pages.dev/workers/configuration/placement/#enable-smart-placement), which automatically places your Workers closer to back-end APIs based on measured latency. When you do not know the location of your back-end APIs or have multiple back-end APIs, set `mode: "smart"`:

  * [  wrangler.jsonc ](#tab-panel-3517)
  * [  wrangler.toml ](#tab-panel-3518)

**JSONC**  
```jsonc  
{  
  "placement": {  
    "mode": "smart",  
  },  
}  
```

**TOML**  
```toml  
[placement]  
mode = "smart"  
```

Jan 20, 2026
1. ### [AI Search path filtering for website and R2 data sources](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-ai-search-path-filtering/)  
[ AI Search ](https://edgetunnel-b2h.pages.dev/ai-search/)  
[AI Search](https://edgetunnel-b2h.pages.dev/ai-search/) now includes [path filtering](https://edgetunnel-b2h.pages.dev/ai-search/configuration/indexing/path-filtering/) for both [website](https://edgetunnel-b2h.pages.dev/ai-search/configuration/data-source/website/#path-filtering) and [R2](https://edgetunnel-b2h.pages.dev/ai-search/configuration/data-source/r2/#path-filtering) data sources. You can now control which content gets indexed by defining include and exclude rules for paths.  
By controlling what gets indexed, you can improve the relevance and quality of your search results. You can also use path filtering to split a single data source across multiple AI Search instances for specialized search experiences.  
![Path filtering configuration in AI Search](https://edgetunnel-b2h.pages.dev/_astro/path-filtering.BCH7HN-Q_vEVaf.webp)  
Path filtering uses [micromatch ↗](https://github.com/micromatch/micromatch) patterns, so you can use `*` to match within a directory and `**` to match across directories.

| Use case                        | Include        | Exclude               |
| ------------------------------- | -------------- | --------------------- |
| Index docs but skip drafts      | \*\*/docs/\*\* | \*\*/docs/drafts/\*\* |
| Keep admin pages out of results | —              | \*\*/admin/\*\*       |
| Index only English content      | \*\*/en/\*\*   | —                     |  
Configure path filters when creating a new instance or update them anytime from **Settings**. Check out [path filtering](https://edgetunnel-b2h.pages.dev/ai-search/configuration/indexing/path-filtering/) to learn more.

Jan 20, 2026
1. ### [Create AI Search instances programmatically via REST API](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-ai-search-simplified-api/)  
[ AI Search ](https://edgetunnel-b2h.pages.dev/ai-search/)  
You can now create [AI Search](https://edgetunnel-b2h.pages.dev/ai-search/) instances programmatically using the [API](https://edgetunnel-b2h.pages.dev/ai-search/get-started/api/). For example, use the API to create instances for each customer in a multi-tenant application or manage AI Search alongside your other infrastructure.  
If you have created an AI Search instance via the [dashboard](https://edgetunnel-b2h.pages.dev/ai-search/get-started/dashboard/) before, you already have a [service API token](https://edgetunnel-b2h.pages.dev/ai-search/configuration/indexing/service-api-token/) registered and can start creating instances programmatically right away. If not, follow the [API guide](https://edgetunnel-b2h.pages.dev/ai-search/get-started/api/) to set up your first instance.  
For example, you can now create separate search instances for each language on your website:  
```bash  
for lang in en fr es de; do  
  curl -X POST "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/ai-search/instances" \
    -H "Authorization: Bearer $API_TOKEN" \
    -H "Content-Type: application/json" \
    --data '{  
      "id": "docs-'"$lang"'",  
      "type": "web-crawler",  
      "source": "example.com",  
      "source_params": {  
        "path_include": ["**/'"$lang"'/**"]  
      }  
    }'  
done  
```  
Refer to the [REST API reference](https://edgetunnel-b2h.pages.dev/api/resources/ai%5Fsearch/subresources/instances/methods/create/) for additional configuration options.

Jan 20, 2026
1. ### [New Workers KV Dashboard UI](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-kv-dash-ui-homepage/)  
[ KV ](https://edgetunnel-b2h.pages.dev/kv/)  
[Workers KV](https://edgetunnel-b2h.pages.dev/kv/) has an updated dashboard UI with new dashboard styling that makes it easier to navigate and see analytics and settings for a KV namespace.  
The new dashboard features a **streamlined homepage** for easy access to your namespaces and key operations, with consistent design with the rest of the dashboard UI updates. It also provides an **improved analytics view**.  
![New KV Dashboard Homepage](https://edgetunnel-b2h.pages.dev/_astro/kv-dash-ui-homepage.BT5hNntj_1OgUmv.webp)  
The updated dashboard is now available for all Workers KV users. Log in to the [Cloudflare Dashboard ↗](https://dash.cloudflare.com/) to start exploring the new interface.

Jan 20, 2026
1. ### [Cloudflare Typescript SDK v6.0.0-beta.1 now available](https://edgetunnel-b2h.pages.dev/changelog/post/2026-01-20-cloudflare-typescript-v600-beta1/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ SDK ](https://edgetunnel-b2h.pages.dev/fundamentals/api/reference/sdks/)  
> **Disclaimer:** Please note that v6.0.0-beta.1 is in Beta and we are still testing it for stability.  
Full Changelog: [v5.2.0...v6.0.0-beta.1 ↗](https://github.com/cloudflare/cloudflare-typescript/compare/v5.2.0...v6.0.0-beta.1)  
In this release, you'll see a large number of breaking changes. This is primarily due to a change in OpenAPI definitions, which our libraries are based off of, and codegen updates that we rely on to read those OpenAPI definitions and produce our SDK libraries. As the codegen is always evolving and improving, so are our code bases.  
Some breaking changes were introduced due to bug fixes, also listed below.  
Please ensure you read through the list of changes below before moving to this version - this will help you understand any down or upstream issues it may cause to your environments.

---  
#### Breaking Changes  
#### Addressing - Parameter Requirements Changed

  * `BGPPrefixCreateParams.cidr`: optional → **required**
  * `PrefixCreateParams.asn`: `number | null` → `number`
  * `PrefixCreateParams.loa_document_id`: required → **optional**
  * `ServiceBindingCreateParams.cidr`: optional → **required**
  * `ServiceBindingCreateParams.service_id`: optional → **required**  
#### API Gateway

  * `ConfigurationUpdateResponse` removed
  * `PublicSchema` → `OldPublicSchema`
  * `SchemaUpload` → `UserSchemaCreateResponse`
  * `ConfigurationUpdateParams.properties` removed; use `normalize`  
#### CloudforceOne - Response Type Changes

  * `ThreatEventBulkCreateResponse`: `number` → complex object with counts and errors  
#### D1 Database - Query Parameters

  * `DatabaseQueryParams`: simple interface → union type (`D1SingleQuery | MultipleQueries`)
  * `DatabaseRawParams`: same change
  * Supports batch queries via `batch` array  
#### DNS Records - Type Renames (21 types)  
All record type interfaces renamed from `*Record` to short names:

  * `RecordResponse.ARecord` → `RecordResponse.A`
  * `RecordResponse.AAAARecord` → `RecordResponse.AAAA`
  * `RecordResponse.CNAMERecord` → `RecordResponse.CNAME`
  * `RecordResponse.MXRecord` → `RecordResponse.MX`
  * `RecordResponse.NSRecord` → `RecordResponse.NS`
  * `RecordResponse.PTRRecord` → `RecordResponse.PTR`
  * `RecordResponse.TXTRecord` → `RecordResponse.TXT`
  * `RecordResponse.CAARecord` → `RecordResponse.CAA`
  * `RecordResponse.CERTRecord` → `RecordResponse.CERT`
  * `RecordResponse.DNSKEYRecord` → `RecordResponse.DNSKEY`
  * `RecordResponse.DSRecord` → `RecordResponse.DS`
  * `RecordResponse.HTTPSRecord` → `RecordResponse.HTTPS`
  * `RecordResponse.LOCRecord` → `RecordResponse.LOC`
  * `RecordResponse.NAPTRRecord` → `RecordResponse.NAPTR`
  * `RecordResponse.SMIMEARecord` → `RecordResponse.SMIMEA`
  * `RecordResponse.SRVRecord` → `RecordResponse.SRV`
  * `RecordResponse.SSHFPRecord` → `RecordResponse.SSHFP`
  * `RecordResponse.SVCBRecord` → `RecordResponse.SVCB`
  * `RecordResponse.TLSARecord` → `RecordResponse.TLSA`
  * `RecordResponse.URIRecord` → `RecordResponse.URI`
  * `RecordResponse.OpenpgpkeyRecord` → `RecordResponse.Openpgpkey`  
#### IAM Resource Groups

  * `ResourceGroupCreateResponse.scope`: optional single → **required array**
  * `ResourceGroupCreateResponse.id`: optional → **required**  
#### Origin CA Certificates - Parameter Requirements Changed

  * `OriginCACertificateCreateParams.csr`: optional → **required**
  * `OriginCACertificateCreateParams.hostnames`: optional → **required**
  * `OriginCACertificateCreateParams.request_type`: optional → **required**  
#### Pages

  * Renamed: `DeploymentsSinglePage` → `DeploymentListResponsesV4PagePaginationArray`
  * Domain response fields: many optional → **required**  
#### Pipelines - v0 to v1 Migration

  * Entire v0 API deprecated; use v1 methods (`createV1`, `listV1`, etc.)
  * New sub-resources: `Sinks`, `Streams`  
#### R2

  * `EventNotificationUpdateParams.rules`: optional → **required**
  * Super Slurper: `bucket`, `secret` now required in source params  
#### Radar

  * `dataSource`: `string` → typed enum (23 values)
  * `eventType`: `string` → typed enum (6 values)
  * V2 methods require `dimension` parameter (breaking signature change)  
#### Resource Sharing

  * Removed: `status_message` field from all recipient response types  
#### Schema Validation

  * Consolidated `SchemaCreateResponse`, `SchemaListResponse`, `SchemaEditResponse`, `SchemaGetResponse` → `PublicSchema`
  * Renamed: `SchemaListResponsesV4PagePaginationArray` → `PublicSchemasV4PagePaginationArray`  
#### Spectrum

  * Renamed union members: `AppListResponse.UnionMember0` → `SpectrumConfigAppConfig`
  * Renamed union members: `AppListResponse.UnionMember1` → `SpectrumConfigPaygoAppConfig`  
#### Workers

  * Removed: `WorkersBindingKindTailConsumer` type (all occurrences)
  * Renamed: `ScriptsSinglePage` → `ScriptListResponsesSinglePage`
  * Removed: `DeploymentsSinglePage`  
#### Zero-Trust DLP

  * `datasets.create()`, `update()`, `get()` return types changed
  * `PredefinedGetResponse` union members renamed to `UnionMember0-5`  
#### Zero-Trust Tunnels

  * Removed: `CloudflaredCreateResponse`, `CloudflaredListResponse`, `CloudflaredDeleteResponse`, `CloudflaredEditResponse`, `CloudflaredGetResponse`
  * Removed: `CloudflaredListResponsesV4PagePaginationArray`

---  
#### Features  
#### Abuse Reports (`client.abuseReports`)

  * **Reports**: `create`, `list`, `get`
  * **Mitigations**: sub-resource for abuse mitigations  
#### AI Search (`client.aisearch`)

  * **Instances**: `create`, `update`, `list`, `delete`, `read`, `stats`
  * **Items**: `list`, `get`
  * **Jobs**: `create`, `list`, `get`, `logs`
  * **Tokens**: `create`, `update`, `list`, `delete`, `read`  
#### Connectivity (`client.connectivity`)

  * **Directory Services**: `create`, `update`, `list`, `delete`, `get`
  * Supports IPv4, IPv6, dual-stack, and hostname configurations  
#### Organizations (`client.organizations`)

  * **Organizations**: `create`, `update`, `list`, `delete`, `get`
  * **OrganizationProfile**: `update`, `get`
  * Hierarchical organization support with parent/child relationships  
#### R2 Data Catalog (`client.r2DataCatalog`)

  * **Catalog**: `list`, `enable`, `disable`, `get`
  * **Credentials**: `create`
  * **MaintenanceConfigs**: `update`, `get`
  * **Namespaces**: `list`
  * **Tables**: `list`, maintenance config management
  * Apache Iceberg integration  
#### Realtime Kit (`client.realtimeKit`)

  * **Apps**: `get`, `post`
  * **Meetings**: `create`, `get`, participant management
  * **Livestreams**: 10+ methods for streaming
  * **Recordings**: start, pause, stop, get
  * **Sessions**: transcripts, summaries, chat
  * **Webhooks**: full CRUD
  * **ActiveSession**: polls, kick participants
  * **Analytics**: organization analytics  
#### Token Validation (`client.tokenValidation`)

  * **Configuration**: `create`, `list`, `delete`, `edit`, `get`
  * **Credentials**: `update`
  * **Rules**: `create`, `list`, `delete`, `bulkCreate`, `bulkEdit`, `edit`, `get`
  * JWT validation with RS256/384/512, PS256/384/512, ES256, ES384  
#### Alerting Silences (`client.alerting.silences`)

  * `create`, `update`, `list`, `delete`, `get`  
#### IAM SSO (`client.iam.sso`)

  * `create`, `update`, `list`, `delete`, `get`, `beginVerification`  
#### Pipelines v1 (`client.pipelines`)

  * **Sinks**: `create`, `list`, `delete`, `get`
  * **Streams**: `create`, `update`, `list`, `delete`, `get`  
#### Zero-Trust AI Controls / MCP (`client.zeroTrust.access.aiControls.mcp`)

  * **Portals**: `create`, `update`, `list`, `delete`, `read`
  * **Servers**: `create`, `update`, `list`, `delete`, `read`, `sync`  
#### Accounts

  * `managed_by` field with `parent_org_id`, `parent_org_name`  
#### Addressing LOA Documents

  * `auto_generated` field on `LOADocumentCreateResponse`  
#### Addressing Prefixes

  * `delegate_loa_creation`, `irr_validation_state`, `ownership_validation_state`, `ownership_validation_token`, `rpki_validation_state`  
#### AI

  * Added `toMarkdown.supported()` method to get all supported conversion formats  
#### AI Gateway

  * `zdr` field added to all responses and params  
#### Alerting

  * New alert type: `abuse_report_alert`
  * `type` field added to PolicyFilter  
#### Browser Rendering

  * `ContentCreateParams`: refined to discriminated union (`Variant0 | Variant1`)
  * Split into URL-based and HTML-based parameter variants for better type safety  
#### Client Certificates

  * `reactivate` parameter in edit  
#### CloudforceOne

  * `ThreatEventCreateParams.indicatorType`: required → optional
  * `hasChildren` field added to all threat event response types
  * `datasetIds` query parameter on `AttackerListParams`, `CategoryListParams`, `TargetIndustryListParams`
  * `categoryUuid` field on `TagCreateResponse`
  * `indicators` array for multi-indicator support per event
  * `uuid` and `preserveUuid` fields for UUID preservation in bulk create
  * `format` query parameter (`'json' | 'stix2'`) on `ThreatEventListParams`
  * `createdAt`, `datasetId` fields on `ThreatEventEditParams`  
#### Content Scanning

  * Added `create()`, `update()`, `get()` methods  
#### Custom Pages

  * New page types: `basic_challenge`, `under_attack`, `waf_challenge`  
#### D1

  * `served_by_colo` \- colo that handled query
  * `jurisdiction` \- `'eu' | 'fedramp'`
  * **Time Travel** (`client.d1.database.timeTravel`): `getBookmark()`, `restore()` \- point-in-time recovery  
#### Email Security

  * New fields on `InvestigateListResponse`/`InvestigateGetResponse`: `envelope_from`, `envelope_to`, `postfix_id_outbound`, `replyto`
  * New detection classification: `'outbound_ndr'`
  * Enhanced `Finding` interface with `attachment`, `detection`, `field`, `portion`, `reason`, `score`
  * Added `cursor` query parameter to `InvestigateListParams`  
#### Gateway Lists

  * New list types: `CATEGORY`, `LOCATION`, `DEVICE`  
#### Intel

  * New issue type: `'configuration_suggestion'`
  * `payload` field: `unknown` → typed `Payload` interface with `detection_method`, `zone_tag`  
#### Leaked Credential Checks

  * Added `detections.get()` method  
#### Logpush

  * New datasets: `dex_application_tests`, `dex_device_state_events`, `ipsec_logs`, `warp_config_changes`, `warp_toggle_changes`  
#### Load Balancers

  * `Monitor.port`: `number` → `number | null`
  * `Pool.load_shedding`: `LoadShedding` → `LoadShedding | null`
  * `Pool.origin_steering`: `OriginSteering` → `OriginSteering | null`  
#### Magic Transit

  * `license_key` field on connectors
  * `provision_license` parameter for auto-provisioning
  * IPSec: `custom_remote_identities` with FQDN support
  * Snapshots: Bond interface, `probed_mtu` field  
#### Pages

  * New response types: `ProjectCreateResponse`, `ProjectListResponse`, `ProjectEditResponse`, `ProjectGetResponse`
  * Deployment methods return specific response types instead of generic `Deployment`  
#### Queues

  * Added `subscriptions.get()` method
  * Enhanced `SubscriptionGetResponse` with typed event source interfaces
  * New event source types: Images, KV, R2, Vectorize, Workers AI, Workers Builds, Workflows  
#### R2

  * Sippy: new provider `s3` (S3-compatible endpoints)
  * Sippy: `bucketUrl` field for S3-compatible sources
  * Super Slurper: `keys` field on source response schemas (specify specific keys to migrate)
  * Super Slurper: `pathPrefix` field on source schemas
  * Super Slurper: `region` field on S3 source params  
#### Radar

  * Added `geolocations.list()`, `geolocations.get()` methods
  * Added V2 dimension-based methods (`summaryV2`, `timeseriesGroupsV2`) to radar sub-resources  
#### Resource Sharing

  * Added `terminal` boolean field to Resource Error interfaces  
#### Rules

  * Added `id` field to `ItemDeleteParams.Item`  
#### Rulesets

  * New buffering fields on `SetConfigRule`: `request_body_buffering`, `response_body_buffering`  
#### Secrets Store

  * New scopes: `'dex'`, `'access'` (in addition to `'workers'`, `'ai_gateway'`)  
#### SSL Certificate Packs

  * Response types now proper interfaces (was `unknown`)
  * Fields now required: `id`, `certificates`, `hosts`, `status`, `type`  
#### Security Center

  * `payload` field: `unknown` → typed `Payload` interface with `detection_method`, `zone_tag`  
#### Shared Types

  * Added: `CloudflareTunnelsV4PagePaginationArray` pagination class  
#### Workers

  * Added `subdomains.delete()` method
  * `Worker.references` \- track external dependencies (domains, Durable Objects, queues)
  * `Worker.startup_time_ms` \- startup timing
  * `Script.observability` \- observability settings with logging
  * `Script.tag`, `Script.tags` \- immutable ID and tags
  * Placement: support for region, hostname, host-based placement
  * `tags`, `tail_consumers` now accept `| null`
  * Telemetry: `traces` field, `$containers` event info, `durableObjectId`, `transactionName`, `abr_level` fields  
#### Workers for Platforms

  * `ScriptUpdateResponse`: new fields `entry_point`, `observability`, `tag`, `tags`
  * `placement` field now union of 4 variants (smart mode, region, hostname, host)
  * `tags`, `tail_consumers` now nullable
  * `TagUpdateParams.body` now accepts `null`  
#### Workflows

  * `instance_retention`: `unknown` → typed `InstanceRetention` interface with `error_retention`, `success_retention`
  * New status option: `'restart'` added to `StatusEditParams.status`  
#### Zero-Trust Devices

  * External emergency disconnect settings (4 new fields)
  * `antivirus` device posture check type
  * `os_version_extra` documentation improvements  
#### Zones

  * New response types: `SubscriptionCreateResponse`, `SubscriptionUpdateResponse`, `SubscriptionGetResponse`  
#### Zero-Trust Access Applications

  * New `ApplicationType` values: `'mcp'`, `'mcp_portal'`, `'proxy_endpoint'`
  * New destination type: `ViaMcpServerPortalDestination` for MCP server access  
#### Zero-Trust Gateway

  * Added `rules.listTenant()` method  
#### Zero-Trust Gateway - Proxy Endpoints

  * `ProxyEndpoint`: interface → discriminated union (`ZeroTrustGatewayProxyEndpointIP | ZeroTrustGatewayProxyEndpointIdentity`)
  * `ProxyEndpointCreateParams`: interface → union type
  * Added `kind` field: `'ip' | 'identity'`  
#### Zero-Trust Tunnels

  * `WARPConnector*Response`: union type → interface

---  
#### Deprecations

  * **API Gateway**: `UserSchemas`, `Settings`, `SchemaValidation` resources
  * **Audit Logs**: `auditLogId.not` (use `id.not`)
  * **CloudforceOne**: `ThreatEvents.get()`, `IndicatorTypes.list()`
  * **Devices**: `public_ip` field (use DEX API)
  * **Email Security**: `item_count` field in Move responses
  * **Pipelines**: v0 methods (use v1)
  * **Radar**: old `summary()` and `timeseriesGroups()` methods (use V2)
  * **Rulesets**: `disable_apps`, `mirage` fields
  * **WARP Connector**: `connections` field
  * **Workers**: `environment` parameter in Domains
  * **Zones**: `ResponseBuffering` page rule

---  
#### Bug Fixes

  * **mcp:** correct code tool API endpoint ([599703c ↗](https://github.com/cloudflare/cloudflare-typescript/commit/599703c45672dc899455d74b124018efd4b75095))
  * **mcp:** return correct lines on typescript errors ([5d6f999 ↗](https://github.com/cloudflare/cloudflare-typescript/commit/5d6f9998ed9999aaa95e1bda8cf50929f3555cf1))
  * **organization\_profile:** fix bad reference ([d84ea77 ↗](https://github.com/cloudflare/cloudflare-typescript/commit/d84ea77094400055c06554812b84c2f0c8d00cc4))
  * **schema\_validation:** correctly reflect model to openapi mapping ([bb86151 ↗](https://github.com/cloudflare/cloudflare-typescript/commit/bb861516774b159d80e0f46a5f3abc5a4c9f9d49))
  * **workers:** fix tests ([2ee37f7 ↗](https://github.com/cloudflare/cloudflare-typescript/commit/2ee37f7adf5a4637d65f61fc225e135eec2579fc))

---  
#### Documentation

  * Added deprecation notices with migration paths
  * **api\_gateway:** deprecate API Shield Schema Validation resources ([8a4b20f ↗](https://github.com/cloudflare/cloudflare-typescript/commit/8a4b20f7a572422f74179fbdb4f1c4fb555e3e40))
  * Improved JSDoc examples across all resources
  * **workers:** expose subdomain delete documentation ([4f7cc1f ↗](https://github.com/cloudflare/cloudflare-typescript/commit/4f7cc1f2b8861a5b8abc193d287f78264a425062))

```json
{"@context":"https://schema.org","@type":"BlogPosting","@id":"https://edgetunnel-b2h.pages.dev/changelog/product-group/developer-platform/9/#page","headline":"Developer platform Changelog | Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/changelog/product-group/developer-platform/9/","inLanguage":"en","image":"https://edgetunnel-b2h.pages.dev/cf-twitter-card.png","publisher":{"@type":"Organization","name":"Cloudflare","url":"https://www.cloudflare.com/"},"isPartOf":{"@type":"WebSite","@id":"https://edgetunnel-b2h.pages.dev/#website","name":"Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/"}}
```