Skip to main content
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, seeUsing 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.
Each project supports a maximum of 50 backend functions.

​
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",
}
PropertyDescription
nameOptional. Unique identifier for the function. Used when invoking via SDK or HTTP. Defaults to the directory path relative to the functions root.
entryThe file containing the function code.
automationsOptional. 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 });
  }
});

​
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. For admin-level operations, 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