• Product Introduction
  • Quick Start
    • Importing a Git Repository
    • Starting From a Template
    • Direct Upload
    • Start with AI
  • Framework Guide
    • Frontends
    • Backends
    • Full-stack
      • Next.js
    • Custom 404 Page
  • Project Guide
    • Project Management
    • edgeone.json
    • Configuring Cache
    • Error Codes
  • Build Guide
  • Deployment Guide
    • Overview
    • Create Deploys
    • Manage Deploys
    • Deploy Button
    • Using Github Actions
    • Using CNB Plugin
    • Using IDE PlugIn
    • Using CodeBuddy IDE
  • Domain Management
    • Overview
    • Custom Domain
    • Configuring an HTTPS Certificate
    • How to Configure a DNS CNAME Record
  • Pages Functions
    • Overview
    • Edge Functions
    • Node Functions
  • Log Analysis
  • KV Storage
  • Edge AI
  • API Token
  • EdgeOne CLI
  • Pages MCP
  • Integration Guide
    • AI
      • Dialogue Large Models Integration
      • Large Models for Images Integration
    • Database
      • Supabase Integration
      • Pages KV Integration
    • Ecommerce
      • Shopify Integration
      • WooCommerce Integration
    • Payment
      • Stripe Integration
      • Integrating Paddle
    • CMS
      • WordPress Integration
      • Contentful Integration
      • Sanity Integration
    • Authentication
      • Supabase Integration
      • Clerk Integration
  • Best Practices
    • Using General Large Model to Quickly Build AI Application
    • Use the Deepseek-R1 model to quickly build a conversational AI site
    • Building an Ecommerce Platform with WordPress + WooCommerce and GatsbyJS
    • Building a SaaS Site Using Supabase and Stripe
    • Building a Company Brand Site Quickly
    • How to Quickly Build a Blog Site
  • Migration Guides
    • Migrating from Vercel to EdgeOne Pages
    • Migrating from Cloudflare Pages to EdgeOne Pages
    • Migrating from Netlify to EdgeOne Pages
  • Troubleshooting
  • FAQs
  • Contact Us
  • Release Notes

Node Functions

Overview

Node Functions simplifies your backend development process and provides a Node.js runtime that seamlessly integrates with front-end projects. You can build and deploy dynamic APIs and complex business logic in a uniform project. The platform automatically handles version control, build and deploy, and intelligently scales according to workload, helping you quickly launch and achieve continuous delivery.


Strengths

Rich Node.js ecosystem: can directly access the massive modules in the npm ecosystem, easily integrate various third-party libraries and tools, and meet complex business needs.
Full stack development experience: No need to separate frontend and backend projects. Develop and deploy in one project to drastically enhance collaboration efficiency.
Route as a service: Define API routes through the file system to implement rapid development and deployment of backend logic, managing backend services as conveniently as frontend pages.


Quick Start

Create hello.js under the ./node-functions directory and use the following example code to create your first Node Functions:
// File path ./node-functions/hello.js
// Access path example.com/hello
export default function onRequest(context) {
return new Response('Hello from Node Functions!');
}
Note:
If you see index.js created under the ./node-functions directory, accessing the root path will enter the function instead of the homepage.

We recommend that you manage function files through subdirectories. In the following example, create nodeinfo.js under ./node-functions/api to return information related to node:
// File path ./node-functions/api/nodeinfo.js
// Access path example.com/api/nodeinfo
import * as os from 'node:os'
import { randomUUID, createHash } from 'node:crypto'

export const onRequestGet = async ({ request }) => {
const info = {
nodeVersion: process.version,
pid: process.pid,
platform: os.platform(),
url: request.url,
}

return new Response(JSON.stringify(info), {
status: 200,
headers: { 'Content-Type': 'application/json; charset=UTF-8' },
})
}

When developing with Express/Koa in Node Functions, the framework's routes only need to be centralized in a function file for processing, without the need to start an additional HTTP Server, and the instance of the framework must be exported. In the following example, create [[default]].js under ./node-functions/express to handle the business logic of Express:
// File path ./node-functions/express/[[default]].js
import express from "express";
const app = express();

// Add log middleware
app.use((req, res, next) => {
console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
next();
});

// Add root route handling, access path example.com/express/
app.get("/", (req, res) => {
res.json({ message: "Hello from Express on Node Functions!" });
});

// Access path example.com/express/users/123
app.get("/users/:id", (req, res) => {
const { id } = req.params;
res.json({ userId: id, message: `Fetched user ${id}` });
});

// Export the express instance
export default app;


Function Debugging

1. Install EdgeOne CLI: npm install -g edgeone
2. Local development: Execute edgeone pages dev in your Pages code project to start local service and perform function debugging.
3. Function release: Push code to remote repository for auto-build function release.
More ways to use EdgeOne CLI can be found in Documentation.


Routing

Node Functions generates access routes based on the /node-functions directory structure. You can create subdirectories at any level under the /node-functions directory in the project repository. See the example below.
...
node-functions
├── index.js
├── hello-pages.js
├── helloworld.js
├── api
├── users
├── list.js
├── geo.js
├── [id].js
├── visit
├── index.js
├── [[default]].js
...
The file structure in the above directory will generate the following routes after platform construction by EdgeOne Pages. These routes map Pages URLs to /node-functions files. When a client accesses the URL, it will trigger the corresponding file code to run:
File path
Routing
/node-functions/index.js
example.com/
/node-functions/hello-pages.js
example.com/hello-pages
/node-functions/helloworld.js
example.com/helloworld
/node-functions/api/users/list.js
example.com/api/users/list
/node-functions/api/users/geo.js
example.com/api/users/geo
/node-functions/api/users/[id].js
example.com/api/users/1024
/node-functions/api/visit/index.js
example.com/api/visit
/node-functions/api/[[default]].js
example.com/api/books/list
example.com/api/books/1024
example.com/api/...
Note:
The trailing slash / in routes is optional. /hello-pages and /hello-pages/ will be routed to /node-functions/hello-pages.js.
If no Node Functions route is matched, client requests will be routed to the static resource of Pages.
Routes are case-sensitive. /helloworld will be routed to /node-functions/helloworld.js and cannot be routed to /node-functions/HelloWorld.js.

Dynamic Routing
Node Functions support dynamic routing. In the above example, the first-level dynamic path is /node-functions/api/users/[id].js, and the multi-level dynamic path is /node-functions/api/[[default]].js. See the following usage:
File path
Routing
Match
/node-functions/api/users/[id].js
example.com/api/users/1024
Yes
example.com/api/users/vip/1024
No
example.com/api/vip/1024
No
/node-functions/api/[[default]].js
example.com/api/books/list
Yes
example.com/api/1024
Yes
example.com/v2/vip/1024
No

Built-in Routing Framework
When developing with the Express/Koa framework, there are key points to pay attention to in code compilation and file group organization.
Express/Koa framework:
All routing services are consolidated in one function file, and the file name must be in [[]] format, for example [[default]].js.
No need to start up an HTTP Server or set port listen
The framework instance must be exported, otherwise the builder will not recognize it as a function export default app;
For example, to create an Express app in the directory node-functions/express/*, use [[default]].js as the entry, and all Express-related routing is inside [[default]].js:
node-functions
└── express
└── [[default]].js # express.js/koa.js entry point with built-in route definition


Function Handlers

Functions Handlers can create custom request handlers for Pages and define RESTful APIs to implement full-stack applications. Supported handler methods:
Handlers method
Description
onRequest(context: EventContext): Response | Promise<Response>
Match HTTP Methods
(GET, POST, PATCH, PUT, DELETE, HEAD, OPTIONS)
onRequestGet(context: EventContext): Response | Promise<Response>
Match HTTP Methods (GET)
onRequestPost(context: EventContext): Response | Promise<Response>
Match HTTP Methods (POST)
onRequestPatch(context: EventContext): Response | Promise<Response>
Match HTTP Methods (PATCH)
onRequestPut(context: EventContext): Response | Promise<Response>
Match HTTP Methods (PUT)
onRequestDelete(context: EventContext): Response | Promise<Response>
Match HTTP Methods (DELETE)
onRequestHead(context: EventContext): Response | Promise<Response>
Match HTTP Methods (HEAD)
onRequestOptions(context: EventContext): Response | Promise<Response>
Match HTTP Methods (OPTIONS)

EventContext object description
The context is an object passed to Function Handlers methods, containing the following properties:
uuid: EO-LOG-UUID represents the unique identifier of an EO request
params: dynamic routing /node-functions/api/users/[id].js parameter value
export function onRequestGet(context) {
return new Response(`User id is ${context.params.id}`);
}
env: Pages environment variables
clientIp: client IP address
server:
region: region code of the deployment location
requestrequestId: request ID, used for log tracking>
geo: client geographic location

Response object description
The function must return a Response object to respond to the client's HTTP request, including headers, status, and body.


Use Limits

Content
Limit
Description
Code package size
128 MB
Single function code package size supports up to 128 MB
Request body size
6 MB
Client request body supports up to 6 MB
Running time
30s
Wall time
Development Language
Node
Currently only support Node.js, default version v20.x
Note:
When file transfer is involved in, it is not recommended to store data that needs long-term retention. We recommend using Tencent Cloud COS to handle persistence needs.



Log Analysis

The Pages console provides basic log viewing functionality. Developers can view basic log information for Node Functions calls, quickly detect and resolve anomalies or errors in API calls through logs. For detailed directions, view the document Log Analysis.



Example Template

Connect to a third-party MySQL database:

Use the Express framework:

Use the Koa framework: