integrations

---

Overview

Integrations module for calling integration methods.

This module provides access to integration methods for interacting with external services. Unlike the connectors module that gives you raw OAuth tokens, integrations provide pre-built functions that Base44 executes on your behalf.

Integration Types

There are two types of integrations:

• Built-in integrations (Core): Pre-built functions provided by Base44 for common tasks such as AI-powered text generation, image creation, file uploads, and email. Access core integration methods using:

  base44.integrations.Core.FunctionName(params)
  

• Custom workspace integrations (custom): Pre-configured external APIs set up by workspace administrators. Workspace integration calls are proxied through Base44’s backend, so credentials are never exposed to the frontend. Access custom workspace integration methods using:

  base44.integrations.custom.call(slug, operationId, params)
  
  To call a custom workspace integration, it must be pre-configured by a workspace administrator who imports an OpenAPI specification. Learn more about custom workspace integrations.

Authentication Modes

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

• Anonymous or User authentication (base44.integrations): Integration methods are invoked with the current user’s permissions. Anonymous users invoke methods without authentication, while authenticated users invoke methods with their authentication context.
• Service role authentication (base44.asServiceRole.integrations): Integration methods are invoked with the service role for backend code that needs elevated permissions.

Example

const response = await base44.integrations.Core.InvokeLLM({

  prompt: 'Explain quantum computing',
  model: 'gpt_5'
});

Example

const result = await base44.integrations.custom.call(

  'github',
  'get:/repos/{owner}/{repo}',
  { pathParams: { owner: 'myorg', repo: 'myrepo' } }
);

Core Integrations Methods

Core package containing built-in Base44 integration functions.

InvokeLLM()

InvokeLLM(params): Promise<string | object>

Generate text or structured JSON data using AI models.

Parameters

params · InvokeLLMParams · required

Parameters for the LLM invocation

Properties

prompt · string · required

The prompt text to send to the model

model · "gpt_5_mini" | "gemini_3_flash" | "gpt_5_4" | "gpt_5_5" | "gemini_3_1_pro" | "claude_sonnet_4_6" | "claude_opus_4_6" | "claude_opus_4_7" | "claude_opus_4_8"

Optionally specify a model to override the app-level model setting for this specific call.

Options: "gpt_5_mini", "gemini_3_flash", "gpt_5_4", "gpt_5_5", "gemini_3_1_pro", "claude_sonnet_4_6", "claude_opus_4_6", "claude_opus_4_7", "claude_opus_4_8"

add_context_from_internet · boolean

If set to true, the LLM will use Google Search, Maps, and News to gather real-time context before answering.

response_json_schema · object

If you want structured data back, provide a JSON schema object here. If provided, the function returns a JSON object; otherwise, it returns a string.

file_urls · string[]

A list of file URLs (uploaded via UploadFile) to provide as context/attachments to the LLM. Do not use this together with add_context_from_internet.

Returns

Promise<string | object>

Properties

an · Promise<string | object> · required

Promise resolving to a string (when no schema provided) or an object (when schema provided).

Examples

Basic prompt

const response = await base44.integrations.Core.InvokeLLM({
  prompt: "Write a haiku about coding."
});

const response = await base44.integrations.Core.InvokeLLM({
  prompt: "What is the current stock price of Wix and what was the latest major news about it?",
  add_context_from_internet: true
});

const response = await base44.integrations.Core.InvokeLLM({
  prompt: "Analyze the sentiment of this review: 'The service was slow but the food was amazing.'",
  response_json_schema: {
    type: "object",
    properties: {
      sentiment: { type: "string", enum: ["positive", "negative", "mixed"] },
      score: { type: "number", description: "Score from 1-10" },
      key_points: { type: "array", items: { type: "string" } }
    }
  }
});
// Returns object: { sentiment: "mixed", score: 7, key_points: ["slow service", "amazing food"] }

---

GenerateImage()

GenerateImage(params): Promise<GenerateImageResult>

Create AI-generated images from text prompts.

Images are generated as PNG files at approximately 1024px on the shorter side. The exact dimensions vary by aspect ratio.

Prompts that violate the AI provider’s content policy will be refused.

Parameters

params · GenerateImageParams · required

Parameters for image generation

Properties

prompt · string · required

Description of the image to generate.

Returns

GenerateImageResult

Properties

url · string · required

URL of the generated image.

Example

Generate an image from a text prompt

const {url} = await base44.integrations.Core.GenerateImage({
  prompt: "A serene mountain landscape with a lake in the foreground"
});
console.log(url); // https://...generated_image.png

---

UploadFile()

UploadFile(params): Promise<UploadFileResult>

Upload files to public storage and get a URL.

Parameters

params · UploadFileParams · required

Parameters for file upload

Properties

file · File · required

The file object to upload.

Returns

UploadFileResult

Properties

file_url · string · required

URL of the uploaded file.

Example

Upload a file in React

const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
  const file = event.target.files?.[0];
  if (!file) return;

  const { file_url } = await base44.integrations.Core.UploadFile({ file });
  console.log(file_url); // https://...uploaded_file.pdf
};

---

SendEmail()

SendEmail(params): Promise<any>

Send emails to registered users of your app.

Parameters

params · SendEmailParams · required

Parameters for sending email

Properties

to · string · required

Recipient email address.

subject · string · required

Email subject line.

body · string · required

Plain text email body content.

from_name · string

The name of the sender. If omitted, the app’s name will be used.

Returns

Promise<any>

Promise resolving when the email is sent.

---

ExtractDataFromUploadedFile()

ExtractDataFromUploadedFile(params): Promise<object>

Extract structured data from uploaded files based on the specified schema.

Start by uploading the file to public storage using the UploadFile() function. Then, use the file_url parameter to extract structured data from the uploaded file.

Parameters

params · ExtractDataFromUploadedFileParams · required

Parameters for data extraction

Properties

file_url · string · required

The URL of the uploaded file to extract data from.

json_schema · object · required

A JSON schema object defining what data fields you want to extract.

Returns

Promise<object>

Promise resolving to the extracted data.

Examples

Extract data from an already uploaded file

const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
  file_url: "https://example.com/files/invoice.pdf",
  json_schema: {
    type: "object",
    properties: {
      invoice_number: { type: "string" },
      total_amount: { type: "number" },
      date: { type: "string" },
      vendor_name: { type: "string" }
    }
  }
});
console.log(result); // { invoice_number: "INV-12345", total_amount: 1250.00, ... }

const handleFileExtraction = async (event: React.ChangeEvent<HTMLInputElement>) => {
  const file = event.target.files?.[0];
  if (!file) return;

  // First, upload the file
  const { file_url } = await base44.integrations.Core.UploadFile({ file });

  // Then extract structured data from it
  const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
    file_url,
    json_schema: {
      type: "object",
      properties: {
        summary: {
          type: "string",
          description: "A brief summary of the file content"
        },
        keywords: {
          type: "array",
          items: { type: "string" }
        },
        document_type: {
          type: "string"
        }
      }
    }
  });
  console.log(result); // { summary: "...", keywords: [...], document_type: "..." }
};

---

UploadPrivateFile()

UploadPrivateFile(params): Promise<UploadPrivateFileResult>

Upload files to private storage that requires a signed URL to access.

Create a signed URL to access uploaded files using the CreateFileSignedUrl() function.

Parameters

params · UploadPrivateFileParams · required

Parameters for private file upload

Properties

file · File · required

The file object to upload.

Returns

UploadPrivateFileResult

Properties

file_uri · string · required

URI of the uploaded private file, used to create a signed URL.

Examples

Upload a private file

const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });
console.log(file_uri); // "private/user123/document.pdf"

const handlePrivateUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
  const file = event.target.files?.[0];
  if (!file) return;

  // Upload to private storage
  const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });

  // Create a signed URL that expires in 1 hour (3600 seconds)
  const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
    file_uri,
    expires_in: 3600
  });

  console.log(signed_url); // Temporary URL to access the private file
};

---

CreateFileSignedUrl()

CreateFileSignedUrl(params): Promise<CreateFileSignedUrlResult>

Generate temporary access links for private files.

Start by uploading the file to private storage using the UploadPrivateFile() function. Then, use the file_uri parameter to create a signed URL to access the uploaded file.

Parameters

params · CreateFileSignedUrlParams · required

Parameters for creating signed URL

Properties

file_uri · string · required

URI of the uploaded private file.

expires_in · number

How long the signed URL should be valid for, in seconds.

Returns

CreateFileSignedUrlResult

Properties

signed_url · string · required

Temporary signed URL to access the private file.

Example

Create a signed URL for a private file

const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
  file_uri: "private/user123/document.pdf",
  expires_in: 7200 // URL expires in 2 hours
});
console.log(signed_url); // https://...?signature=...

Custom Integrations Methods

Module for calling custom pre-configured API integrations. Custom integrations allow workspace administrators to connect any external API by importing an OpenAPI specification. Apps in the workspace can then call these integrations using this module.

call()

call(
slug,
operationId,
params?
): Promise<CustomIntegrationCallResponse>

Call a custom integration endpoint.

Parameters

Properties

slug · string · required

The integration’s unique identifier, as defined by the workspace admin.

operationId · string · required

The endpoint in method:path format. For example, "get:/contacts", or "post:/users/{id}". The method is the HTTP verb in lowercase and the path matches the OpenAPI specification.

params · CustomIntegrationCallParams

Optional parameters including payload, pathParams, and queryParams.

Returns

Promise<CustomIntegrationCallResponse>

Promise resolving to the integration call response.

Throws

If slug is not provided.

Throws

If operationId is not provided.

Throws

If the integration or operation is not found (404).

Throws

If the external API call fails (502).

Throws

If the request times out (504).

Examples

Call a custom CRM integration

const response = await base44.integrations.custom.call(
  "my-crm",
  "get:/contacts",
  { queryParams: { limit: 10 } }
);

if (response.success) {
  console.log("Contacts:", response.data);
}

const response = await base44.integrations.custom.call(
  "github",
  "post:/repos/{owner}/{repo}/issues",
  {
    pathParams: { owner: "myorg", repo: "myrepo" },
    payload: {
      title: "Bug report",
      body: "Something is broken"
    }
  }
);

Type Definitions

Core

Core: CoreIntegrations

Core package containing built-in Base44 integration functions.

Example

Invoke an LLM

const response = await base44.integrations.Core.InvokeLLM({
  prompt: 'Explain quantum computing',
  model: 'gpt-4'
});

custom

custom: CustomIntegrationsModule

Workspace integrations module for calling pre-configured external APIs.

Example

Call a custom integration

const result = await base44.integrations.custom.call(
  'github',
  'get:/repos/{owner}/{repo}',
  { pathParams: { owner: 'myorg', repo: 'myrepo' } }
);