Netlify Release Notes

Enterprise teams can now create, track, and reply to support tickets without leaving Netlify in our new Support Hub. Go to User settings > Support to see your tickets, check their status, and continue your conversation with the Netlify support team.

Team Owners can see every ticket their team members created, not just their own. The Requester column shows who opened each ticket. Members on your team can only view the tickets they opened.

What you can do

• Create tickets with a subject, a Markdown description, and CC recipients.
• Track progress with clear statuses: Open, Awaiting customer response, and Closed.
• Search, sort, and filter your tickets, including tickets you're CC'd on.
• Reply from the dashboard. Your reply goes straight to the support team.

Not on Enterprise?

Support is available on every plan, including Free plans. Use the Netlify Support page or email [email protected].

Learn more

Learn more from our Support Hub guide

TypeSafe’s Jev 1.14.0 model is now available through Netlify’s AI Gateway with zero configuration required.

Install @typesafe-ai/sdk and use it directly in your Netlify Functions without managing API keys or authentication. AI Gateway handles credentials automatically, and usage is billed to your Netlify credits.

Jev answers typed questions about your application state. Here’s an example using jev-1.14.0 to categorize a support ticket as a bug, feature request, or question:

import { choice, TypeSafeClient } from '@typesafe-ai/sdk';
export default async () => {
const typesafe = new TypeSafeClient();
const response = await typesafe.systemOne({
model: 'jev-1.14.0',
state: { issue: 'App crashes when I click Save.' },
questions: {
label: choice('Categorize this ticket', {
bug: null,
feature: null,
question: null,
}),
},
});
return Response.json(response);
};

Jev 1.14.0 is also available across Scheduled Functions, Background Functions, and Edge Functions. You get automatic access to Netlify’s caching, rate limiting, and authentication infrastructure.

Learn more in the AI Gateway documentation and the TypeSafe documentation.

The Next.js and React teams have disclosed three security vulnerabilities (two critical, one high), released on October 14, 2026: a remote code execution (RCE) in SVG image processing, an RCE in use cache (Cache Components), and a denial of service (DoS) in App Router Server Actions. Here's what Netlify customers need to know.

Summary

If you run Next.js on Netlify, we strongly recommend upgrading next to 15.5.28 or 16.4.1 and redeploying. Several of these have limited or no impact on Netlify; see Impact on Netlify. See What should I do? for steps.

Vulnerabilities

All issues are patched in 15.5.28 and 16.4.1.

Vulnerability: GHSA-673q-mjm6-r5xr

— Unauthenticated Remote Code Execution in use cache functions returning typed arrays

Severity: Critical

Affected: 16.x apps using Cache Components with a use cache function returning typed arrays

Vulnerability: GHSA-2464-fhr4-w9xw

— Unauthenticated Remote Code Execution in Image Optimization API when SVG files are used (CVE-2026-96889)

Severity: Critical

Affected: Processing untrusted SVGs via sharp (Node.js runtime, glibc Linux); on Netlify, reachable through next/og ImageResponse

Vulnerability: GHSA-p3m5-59mp-jv5r

— Denial of Service in App Router using Server Actions

Severity: High

Affected: 13.x–16.x App Router apps with at least one Server Action

Impact on Netlify

Remote code execution

GHSA-673q-mjm6-r5xr is a Critical RCE affecting Next.js 16.x apps using Cache Components, triggered by a use cache function that returns typed arrays — an unusual configuration not expected in normally functioning applications. On Netlify, apps that meet those conditions are affected; upgrading Next.js resolves it.

GHSA-2464-fhr4-w9xw (CVE-2026-96889) is an RCE in the image library (sharp) Next.js uses to process SVGs. The advisory describes it through the next/image Image Optimization API — which on Netlify is served by Netlify Image CDN, not your function, so that path is not exercised on Netlify. The same flaw is reachable through next/og ImageResponse, which does run in your Netlify function: apps that render untrusted input via ImageResponse are affected. There, the impact is limited to a crashed function invocation, not code execution — minimal impact on our autoscaling serverless architecture, though active exploitation could increase your function costs. Upgrading Next.js (which also updates the bundled sharp) resolves it.

Denial of service

GHSA-p3m5-59mp-jv5r is a server-side DoS affecting App Router apps that define a Server Action. On Netlify, this has minimal impact: our autoscaling serverless architecture means a malicious request that consumes excessive CPU in one function does not affect other requests. However, active exploitation could increase your function costs. Upgrading Next.js resolves it.

What should I do?

We strongly recommend upgrading next to 15.5.28 or 16.4.1 and redeploying as soon as possible.

Note that any publicly available deploy previews and branch deploys may remain vulnerable until they are automatically deleted. Consider deleting these deploys manually.

Resources

Next.js Security Update for Upstream Vulnerabilities

Next.js security advisories

TanStack Start is now 1.0, and Start apps deploy on Netlify. SSR, server routes, server functions, and middleware run on Netlify Functions. It's also what new Agent Runners projects start with by default.

Start a new app

Deploy the official template, or generate your own:

npx create-tsrouter-app@latest --template file-router --add-ons tanchat,netlify

Deploy an existing app

Install the Netlify plugin:

npm install -D @netlify/vite-plugin-tanstack-start

Then add it to vite.config.ts after tanstackStart():

import { defineConfig } from 'vite'
import { tanstackStart } from '@tanstack/react-start/plugin/vite'
import netlify from '@netlify/vite-plugin-tanstack-start'

export default defineConfig({
  plugins: [tanstackStart(), netlify()],
})

Add a netlify.toml with your build settings:

[build]
command = "vite build"
publish = "dist/client"

Develop locally against the real platform

The plugin emulates Netlify in your dev server, so you can build against the same primitives you'll use in production, without the Netlify CLI:

• Serverless functions and edge functions
• Blobs and Netlify Database
• Cache API and Image CDN
• Redirects, rewrites, and headers
• Environment variables
• AI Gateway

Start with Agent Runners

New projects you start with Agent Runners use TanStack Start 1.0 unless another framework is specified.

Read the TanStack Start guide · Explore the template

Google’s Gemini 4 Argon model is now available through Netlify’s AI Gateway and Agent Runners with zero configuration required.

Use the Google GenAI SDK directly in your Netlify Functions without managing API keys or authentication. The AI Gateway handles everything automatically. Here’s an example using the Gemini 4 Argon model:

import { GoogleGenAI } from '@google/genai';

export default async () => {
  const ai = new GoogleGenAI({});
  const response = await ai.models.generateContent({
    model: 'gemini-4-argon',
    contents: 'How can AI improve my coding?'
  });
  return Response.json(response);
};

Gemini 4 Argon is available for all Function types and Agent Runners. You get automatic access to Netlify’s caching, rate limiting, and authentication infrastructure.

Learn more in the AI Gateway documentation and Agent Runners documentation.

Meta’s Muse Spark and Muse Wonder models are now available through Netlify’s AI Gateway with zero configuration required. Choose muse-spark-1.1 for coding, computer use, and multimodal perception; muse-spark-1.2 for coding-optimized agentic workflows; muse-spark-1.3 for long-horizon coding and agentic work with cleaner code and fewer tokens; or muse-wonder-1.0 for complex coding tasks, long-running agents, and advanced computer use.

Use the OpenAI SDK directly in your Netlify Functions without managing API keys or authentication. AI Gateway takes care of the setup automatically. Here’s an example using Muse Wonder with the Responses API:

import OpenAI from 'openai';

export default async () => {
  const meta = new OpenAI();
  const response = await meta.responses.create({
    model: 'muse-wonder-1.0',
    input: 'How can AI improve my coding?'
  });
  return Response.json(response);
};

These Meta models also work in Scheduled Functions, Background Functions, and Edge Functions, with Netlify’s caching, rate limiting, and authentication infrastructure available automatically.

Learn more in the AI Gateway documentation and explore the models on Meta’s developer site.

On private projects and sites protected with Netlify team login, your Netlify Functions and Edge Functions can now see who is making the request. The signed-in Netlify user is available as context.user, with their user ID, email address, and when their access expires.

This function returns the signed-in user's ID, email address, and access expiry as JSON at /whoami, and responds with a 401 when context.user isn't set:

// netlify/functions/whoami.ts
import type { Config, Context } from '@netlify/functions'
export default async (req: Request, context: Context) => {
if (!context.user) {
return new Response('Unauthorized', { status: 401 })
}
return Response.json({
id: context.user.id,
email: context.user.email,
expiresAt: context.user.expiresAt.toISOString(),
})
}
export const config: Config = { path: '/whoami' }

Previously, protecting a site meant Netlify checked who could visit, but your code couldn't tell who they were. Knowing who's on the other end meant adding a second login of your own on top.

Now Netlify verifies the visitor at the edge and passes their identity to your code. Because context.user comes from Netlify and not from the request, a visitor can't impersonate someone else by sending their own headers.

With context.user, you can build on the login your team already uses. Examples like:

• Internal dashboards and admin tools that show each person their own data
• Audit logs that record who made a change or triggered an action
• Approval and review workflows that know who approved what
• Per-person settings, permissions, or feature access inside an internal app

Learn more in the Netlify documentation:

• context.user in Netlify Functions
• context.user in Edge Functions
• Private projects
• Team login protection

You can now subscribe to Netlify events from ChatGPT and set up automations that respond to what’s happening on your sites.

Instead of checking the Netlify dashboard or waiting on an email, you can have ChatGPT act as soon as something happens. Events you can subscribe to include:

• A deploy succeeded
• A build failed
• A form submission came in

For more events to subscribe to, check out our deploy events.

Combine events with Netlify plugin and MCP server

Events get more useful when you pair them with everything else you can already do through the Netlify ChatGPT plugin and Netlify MCP server. For example, you could set up an automation that:

• Reviews new form submissions and flags the ones that need a follow-up
• Summarizes what changed when a production deploy succeeds

Because these automations live in ChatGPT, you can describe what you want in plain language and adjust it as your workflow changes.

Get started

Connect Netlify in ChatGPT, then ask it to subscribe to the events you care about for your project. Learn more in our guide to using Netlify with ChatGPT.

OpenAI’s Decisions API is now available through Netlify’s AI Gateway with zero configuration required.

Use the OpenAI SDK directly in your Netlify Functions to classify, route, and score inputs without managing API keys. Instead of generating prose, the Decisions API answers questions you define about an input, and choice answers are always one of the options you declared. That means there’s no output to parse and nothing unexpected to handle before you branch on the result. The Decisions API is in beta and currently runs on gpt-6-luna.

Here’s a Function for an online store that sorts incoming return requests by reason:

import type { Config } from "@netlify/functions";
import OpenAI from "openai";

export default async (req: Request) => {
  const openai = new OpenAI();
  const { answers } = await openai.decisions.create({
    model: "gpt-6-luna",
    input: await req.text(),
    questions: [
      {
        type: "choice",
        name: "reason",
        instructions: "Why is the customer returning this item?",
        choices: [
          { value: "wrong_size" },
          { value: "defective" },
          { value: "not_as_described" },
          { value: "changed_mind" },
        ],
      },
    ],
  });
  return Response.json(answers[0]);
};

export const config: Config = { path: "/api/returns", method: "POST" };

Send it “The jacket fits well, but the zipper came off the second time I wore it” and you get back:

{
  "type": "choice",
  "name": "reason",
  "choice": "defective",
  "probabilities": [
    { "value": "wrong_size", "probability": 0.01 },
    { "value": "defective", "probability": 0.95 },
    { "value": "not_as_described", "probability": 0.03 },
    { "value": "changed_mind", "probability": 0.01 }
  ],
  "confidence": 0.93
}

choice is safe to branch on directly, so you can send a prepaid label for defective items or offer an exchange for the wrong size, and use confidence to pass unclear requests to your support team.

Learn more in the AI Gateway documentation and the OpenAI API reference.

Anthropic’s Claude Haiku 5.5 model is now available through Netlify’s AI Gateway and Agent Runners with zero configuration required.

Use the Anthropic SDK directly in your Netlify Functions without managing API keys or authentication. AI Gateway handles everything automatically. Here’s an example using Claude Haiku 5.5 with the Messages API:

import Anthropic from '@anthropic-ai/sdk';
export default async () => {
const anthropic = new Anthropic();
const response = await anthropic.messages.create({
model: 'claude-haiku-5-5',
max_tokens: 1024,
messages: [
{ role: 'user', content: 'Give a concise explanation of how AI works.' }
],
});
return Response.json(response);
};

Claude Haiku 5.5 is also available across Scheduled Functions, Background Functions, and Edge Functions. You get automatic access to Netlify’s caching, rate limiting, and authentication infrastructure.

Learn more in the AI Gateway documentation and Agent Runners documentation.

You can now add comments to individual lines in the diff on the Code tab of Agent Runners, so you can give your agent precise feedback on the code it generated.

Previously, asking for a fix meant describing where the problem was in your prompt, such as naming the file, quoting the code, or explaining which function you meant.

Now you can pinpoint exactly where you want changes. Open the Code tab for an agent run, select the + next to a line in the diff, and leave a comment about what you want changed. Your comments are sent along with your next prompt, so the agent knows exactly which code lines you’re referring to.

Agent Runners Code tab showing a diff of index.html with a comment box open on line 278 that reads “use class name subdued instead” and an Add comment button

This makes follow-up prompts more useful when you want to:

• Correct a specific bug or edge case without rewriting the whole request
• Ask for a different approach in one part of a change while keeping the rest
• Flag naming, styling, or structure issues right where they appear
• Leave feedback on several spots across multiple files in a single follow-up run

Try it on your next agent run, or learn more about making changes with Agent Runners.

Google’s Gemini Nano Banana 2.1 is now available through Netlify AI Gateway. You can call this image generation model from Netlify Functions without configuring API keys; AI Gateway provides the connection to Google for you.

Use the Google Gen AI SDK with the model ID gemini-nano-banana-2.1. Here’s an example that generates an image from a prompt and returns it directly from a Function:

import { GoogleGenAI } from '@google/genai';

// Netlify Function: Generate an image with Gemini Nano Banana 2.1 and return it directly.
// Usage (GET): /.netlify/functions/nano-banana-2-1?prompt=Your+prompt+here
// Returns: binary image (PNG/JPEG/etc) with proper content-type. If no image, JSON error.
export default async (request: Request) => {
  const url = new URL(request.url);
  const prompt = url.searchParams.get('prompt') || 'two happy bananas holding flashlights';
  const ai = new GoogleGenAI({});
  try {
    const response = await ai.models.generateContent({
      model: 'gemini-nano-banana-2.1',
      contents: prompt,
      config: {
        imageConfig: {
          aspectRatio: '16:9',
          imageSize: '1K'
        }
      }
    });
    let imagePart = null;
    for (const part of response.candidates[0].content.parts) {
      if (part.inlineData) {
        imagePart = part.inlineData;
        break;
      }
    }
    const bytes = Buffer.from(imagePart.data, 'base64');
    const mimeType = imagePart.mimeType || 'image/png';
    return new Response(bytes, {
      status: 200,
      headers: {
        'Content-Type': mimeType,
        'Cache-Control': 'no-store'
      }
    });
  } catch (err) {
    return new Response(JSON.stringify({ error: String(err), prompt }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
};

Gemini Nano Banana 2.1 is also available across Scheduled Functions, Background Functions, and Edge Functions. You get automatic access to Netlify’s caching, rate limiting, and authentication infrastructure.

Learn more in the AI Gateway documentation.

What’s new

SvelteKit 3 is out today, and it just works on Netlify on day one. To upgrade, run:

npx sv migrate sveltekit-3

The migration tool handles most of the mechanical changes for you, including moving your config and updating imports. You can also check out the official migration guide.

Some highlights include:

• Vite 8 — SvelteKit 3 requires Vite 8, bringing faster builds powered by Rolldown.
• Config lives in vite.config.ts — SvelteKit configuration moves out of svelte.config.js and into your Vite config, so Vite plugins can read it right away.
• Explicit environment variables are stable — Declare the environment variables your app depends on in src/env.ts, and specify whether each one is public and whether it’s resolved at build time or when the app boots. You get validation and type safety out of the box.
• $lib is now #lib — The $lib alias is replaced by #lib, using Node’s subpath imports. Imports need to be unambiguous, so write #lib/foo.ts or #lib/foo/index.ts.
• Shallow routing is built into goto — Use goto() with shallow: true instead of pushState and replaceState.
• Consistent error handling — All errors, including ones you throw with error(...), now go through your handleError hook.
• New service worker modules — $service-worker is replaced by imports from $app/env, $app/paths, and $app/manifest, with better type checking in service workers.
• Tracing is stable — Tracing support has moved out of the experimental namespace.

Check the full migration guide for all the details.

Watch out for the #lib alias

Nearly every SvelteKit project imports from $lib, so this is the change you’re most likely to run into. The migration tool rewrites these imports for you, but because #lib relies on Node’s subpath imports, directory imports without an explicit file no longer resolve:

// Before
import { formatDate } from '$lib/utils';
// After
import { formatDate } from '#lib/utils/index.ts';

If a build fails after upgrading with a module resolution error, look for #lib imports that point to a directory or leave off the file extension.

Deploy a SvelteKit 3 site on Netlify

If you want to get started with a new site, start with the SvelteKit on Netlify doc, or just click this button:

Deploy to Netlify

The TanStack team has disclosed a critical cross-site scripting (XSS) vulnerability in TanStack Start. A crafted URL can cause an affected app to return attacker-controlled HTML from its own origin, which may run attacker-supplied JavaScript in a visitor's browser. Here's what Netlify customers need to know.

Vulnerabilities

• GHSA-qx66-fv34-fjm8 (CVE-2026-102989): Unauthenticated reflected XSS in server-function responses.
• Package: @tanstack/react-start
• Affected versions: >= 1.143.12, < 1.168.60
• Fixed in: 1.168.60
• Package: @tanstack/solid-start
• Affected versions: >= 1.143.12, < 1.168.57
• Fixed in: 1.168.57
• Package: @tanstack/vue-start
• Affected versions: >= 1.143.12, < 1.168.56
• Fixed in: 1.168.56
• Package: @tanstack/start-server-core
• Affected versions: >= 1.143.12, < 1.169.39
• Fixed in: 1.169.39

Impact on Netlify

This is a client-side cross-site scripting (XSS) vulnerability in TanStack Start's server-function response handling. Because the malicious response is returned from the app's own origin, an attacker who gets a victim to open a crafted link can run JavaScript in that visitor's session — for example, to read their data or act as them on the site. All applications on an affected version should upgrade.

What should I do?

We strongly recommend upgrading as soon as possible to the patched releases:

• @tanstack/react-start 1.168.60 or later
• @tanstack/solid-start 1.168.57 or later
• @tanstack/vue-start 1.168.56 or later
• @tanstack/start-server-core 1.169.39 or later

Not sure if you're affected?

Open your project in Agent Runners in ask mode and try this prompt:

Does this project use TanStack Start? If so, which versions of @tanstack/react-start, @tanstack/solid-start, @tanstack/vue-start, and @tanstack/start-server-core are resolved in the lockfile? Is the resolved @tanstack/start-server-core version 1.169.39 or later? If not, what do I need to change to upgrade? (Advisory: GHSA-qx66-fv34-fjm8)

Ask mode answers without changing your code. If an upgrade is needed, switch to Build mode to make the change, preview, and redeploy.

Deploy previews and branch deploys

Note that any publicly available deploy previews and branch deploys may remain vulnerable until they are automatically deleted. Consider deleting these deploys manually.

Resources

• GitHub security advisory (GHSA-qx66-fv34-fjm8)
• TanStack security update: CVE-2026-102989
• CVE-2026-102989