Backend Functions Overview

Write custom backend logic with Deno-powered serverless functions

You’re viewing developer documentation

This documentation is for developers working with the Base44 developer platform. For information about backend functions in the app editor, see

Using Integrations

.

Backend functions let you run custom backend code in a secure, isolated environment. Use functions to implement business logic that shouldn’t run in the browser, connect to third-party APIs with protected credentials, process webhooks, or extend your app with custom endpoints.

Backend functions run on Deno, a modern TypeScript runtime. Call functions from your frontend using the SDK, which handles authentication automatically. Each function also gets its own HTTP endpoint for webhooks and external integrations.

Functions can also run automatically using automations. Schedule functions to run at specific times or trigger them in response to database events like creating, updating, or deleting records.

Note the following:

• Each project supports a maximum of 50 backend functions.
• Backend functions have a maximum execution time of 5 minutes. Requests that exceed this limit are terminated.

Create functions

Create backend functions as TypeScript files in your project’s functions directory. By default the functions directory is base44/functions/, but you can customize the path in your project configuration.

Each function lives in its own subdirectory with an entry.ts or entry.js file:

functions

<function-name>

entry.ts

The CLI uses the directory path relative to the functions root as the function name. For example, functions/sendWelcomeEmail/entry.ts creates a function named sendWelcomeEmail. You can also nest functions in subdirectories for organization. functions/email/send/entry.ts creates a function named email/send.

Adding a configuration file

For advanced needs like custom function names or automations, add a function.jsonc file:

functions

<function-name>

entry.ts

function.jsonc

The configuration file defines the function’s name and entry point:

{
  "name": "sendWelcomeEmail",
  "entry": "entry.ts",
}

Property	Description
name	Optional. Unique identifier for the function. Used when invoking via SDK or HTTP. Defaults to the directory path relative to the functions root.
entry	The file containing the function code.
automations	Optional. Array of automation configurations to run the function on a schedule or in response to database events. See Automations for details.

entry.ts

The code file contains your function logic. Functions must use the Deno.serve() wrapper and return Response objects:

import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  try {
    const base44 = createClientFromRequest(req);
    const user = await base44.auth.me();

    if (!user) {
      return Response.json({ error: "Unauthorized" }, { status: 401 });
    }

    const { name } = await req.json();

    return Response.json({
      message: `Hello, ${name || user.full_name}!`,
    });
  } catch (error) {
    return Response.json({ error: error.message }, { status: 500 });
  }
});

Multiple files per function

A function isn’t limited to a single entry.ts. Split logic into multiple files within the function’s directory and import them with relative paths. Every .js, .ts, .json, and .jsonc file in the function directory is deployed with the function.

functions

process-order

entry.ts

validate.ts

types.ts

// entry.ts
import { validate } from "./validate.ts";

Relative imports are resolved when you deploy. An import that points to a file the function isn’t deployed with, such as a file in another function’s directory, fails at deploy time.

Share code between functions

To reuse code across functions, place it in a shared directory inside your base44/ folder.

The entire shared directory is bundled with every function, so each function is deployed with its own copy. This means:

• Any function can import from shared with a relative path.
• Different functions can end up running different versions of the same shared file. Changing a shared file and deploying a single function updates only that function’s copy. The others keep the old version until you redeploy them. To apply a shared change everywhere, run base44 functions deploy with no arguments to redeploy every function at once.

base44

shared

response.ts

functions

greet

entry.ts

farewell

entry.ts

// base44/functions/greet/entry.ts
import { ok } from "../../shared/response.ts";

Deno.serve(async (req) => {
  const { name } = await req.json();
  return ok({ message: `Hello, ${name}!` });
});

Relative imports can reach base44/shared/ but can’t escape base44/. To use code from outside base44/, move it into base44/shared/, or import it with an npm: or jsr: specifier.

Test locally

Run your functions locally with base44 dev to test changes without deploying. See Local development for details.

Deploy functions

Deploy functions with functions deploy or deploy to push all project resources at once. You can deploy specific functions by name with functions deploy <names...>, or use --force to remove remote functions not found locally.

To download deployed functions to your local project, use functions pull. To see what’s currently deployed, use functions list.

Call functions

Call backend functions from your frontend using the SDK, or via HTTP for webhooks and external integrations.

Via the SDK

Use base44.functions.invoke() to call functions from your frontend. The SDK handles authentication automatically, passing the current user’s credentials to your function.

import { base44 } from "@/api/base44Client";

const response = await base44.functions.invoke("sendWelcomeEmail", {
  name: "Alice",
});

Via HTTP

Each deployed function gets an HTTP endpoint at:

https://<your-app-domain>/functions/<function-name>

This is useful for:

• Webhooks: Receive callbacks from external services like Stripe or GitHub.
• External integrations: Allow other systems to interact with your app.
• Testing: Call functions directly with tools like cURL or Postman.

Example usage

curl -X POST https://your-app.base44.app/functions/sendWelcomeEmail \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice"}'

When calling functions via direct HTTP (like cURL or webhooks), there’s no authenticated user context. Use asServiceRole for all operations in these cases.

Use the SDK in functions

Inside your backend functions, you can access your app’s data, authentication, and integrations through the Base44 SDK. Use createClientFromRequest() to create a client from the incoming request.

The authentication context depends on how the function was called:

• When called via the SDK from your frontend: The user’s authentication is passed through automatically. You can access the current user with base44.auth.me() and perform operations with their permissions. To read or write data without entity access rules applying, use asServiceRole.

• When called via direct HTTP (cURL, webhooks, external services): There’s no authenticated user, so use asServiceRole for all operations.

Connect to third-party APIs

Backend functions are one of several ways to connect to third-party APIs. They’re ideal when you need full control over requests or want to store API keys securely as environment variables. Use secrets set to configure environment variables from the CLI.

View logs

During local development, function output is printed directly to your terminal without needing the logs command.

For deployed functions, view logs with the logs command. The logs include console output, errors, and timing information. You can filter by function name or time range. If you’re using an AI coding agent, the base44-troubleshooter skill can fetch and analyze these logs automatically.

TypeScript types

Generate TypeScript types from your function configurations to get type safety and autocomplete for function names in your SDK code. Learn more about dynamic types.

See also

• Automations: Schedule functions or trigger them on database events
• functions module: SDK reference for invoking functions
• createClientFromRequest: Creating a client in backend functions
• functions deploy: Deploy local functions to Base44
• functions pull: Download deployed functions to your local project
• functions list: List all deployed functions
• functions delete: Delete deployed functions
• logs: View function logs
• exec: Test functions in isolation from standalone scripts