> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# functions

***

## Overview

Functions module for invoking custom backend functions.

This module allows you to invoke the custom backend functions defined in the app.

### Authentication Modes

This module is available to use with a client in all authentication modes:

* **Anonymous or User authentication** (`base44.functions`): Functions are invoked with the current user's permissions. Anonymous users invoke functions without authentication, while authenticated users invoke functions with their authentication context.
* **Service role authentication** (`base44.asServiceRole.functions`): Functions are invoked with the service role for backend code that needs elevated permissions.

### Generated Types

If you're working in a TypeScript project, you can generate types from your backend functions to get autocomplete on function names when calling `invoke()`. See the [Dynamic Types](https://docs.base44.com/developers/references/sdk/getting-started/dynamic-types.md) guide to get started.

## Methods

### invoke()

> **invoke**(`functionName`, `data?`): `Promise`\<`any`>

Invokes a custom backend function by name.

Sends a POST request to a custom backend function deployed to the app.
The function receives the provided data as named parameters and returns
the result. If any parameter is a `File` object, the request will automatically be
sent as `multipart/form-data`. Otherwise, it will be sent as JSON.

For streaming responses, non-POST methods, or raw response access, use [`fetch()`](#fetch) instead.

#### Parameters

> [accordion] Properties
>
> **functionName** `string` *required*
>
> The name of the function to invoke.
>
> **data** `Record\<string, any\>`
>
> An object containing named parameters for the function.

#### Returns

`Promise<any>`

Promise resolving to the function's response. The `data` property contains the data returned by the function, if there is any.

#### Examples

```typescript Basic function call theme={null}
const result = await base44.functions.invoke('calculateTotal', {
  items: ['item1', 'item2'],
});
console.log(result.data.total);
```

```typescript Function with file upload in React theme={null}
const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
  const file = event.target.files?.[0];
  if (file) {
    const processedImage = await base44.functions.invoke('processImage', {
      image: file,
      filter: 'grayscale',
      quality: 80
    });
  }
};
```

***

### fetch()

> **fetch**(`path`, `init?`): `Promise`\<`Response`>

Performs a direct HTTP request to a backend function path and returns the native `Response`.

Use `fetch()` when you need low-level control that [`invoke()`](#invoke) doesn't provide, such as:

* Streaming responses, like SSE, chunked text, or NDJSON
* Custom HTTP methods, like PUT, PATCH, or DELETE
* Raw response access, including status codes, headers, and binary bodies

#### Parameters

> [accordion] Properties
>
> **path** `string` *required*
>
> Function path. Leading slash is optional, so `/chat` and `chat` are equivalent. For example, `'/streaming_demo'` or `'reports/export'`.
>
> **init** `RequestInit`
>
> Optional [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) options such as `method`, `headers`, `body`, and `signal`. Auth headers are added automatically.

#### Returns

`Promise<Response>`

Promise resolving to a native [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).

#### Examples

```typescript Stream an SSE response theme={null}
const response = await base44.functions.fetch('/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ prompt: 'Hello!' }),
});

const reader = response.body!.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value, { stream: true }));
}
```

```typescript PUT request theme={null}
const response = await base44.functions.fetch('/users/profile', {
  method: 'PUT',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ name: 'Jane', role: 'admin' }),
});

if (!response.ok) {
  throw new Error(`Request failed: ${response.status}`);
}

const updated = await response.json();
```

```typescript Download a binary file theme={null}
const response = await base44.functions.fetch('/export/report');
const blob = await response.blob();

const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'report.pdf';
a.click();
```

## Type Definitions

### FunctionName

> **FunctionName** = keyof `FunctionNameRegistry` *extends* `never` ? `string` : keyof `FunctionNameRegistry`

Union of all function names from the [`FunctionNameRegistry`](#functionnameregistry). Defaults to `string` when no types have been generated.

#### Example

```typescript Using generated function name types theme={null}
// With generated types, you get autocomplete on function names
await base44.functions.invoke('calculateTotal', { items: ['item1', 'item2'] });
```

### FunctionNameRegistry

Registry of function names. The [`types generate`](https://docs.base44.com/developers/references/cli/commands/types-generate) command fills this registry, then [`FunctionName`](#functionname) resolves to a union of the keys.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.