​
The integration you create will:

  • Appear in your private catalog for future use
  • Be reusable across your apps
  • Be shareable with your teammates (workspace-level)
  • And if submitted to the public catalog:
    • It will be reviewed by Base44
    • If approved → available to all users
    • You’ll receive 250 free credits 🎉

​
Prefer to watch instead of read:

Here’s a short video showing how to create an integration in Base44.
This video uses an earlier version of our platform, so the interface may look a little different, but the overall process is the same.
If you’d rather follow along in writing, or just want a handy reference while you build, the step-by-step instructions are right below

​
Step 0: Before you start, make sure you have

  • An API key from the platform you want to connect (for example, Open AI keys start with sk-)
  • A logo image (256×256 PNG image) saved to your computer
  • 3–5 example prompts you can copy-paste

​
Step 1: Open the integration catalog

  1. Go to your Base44 Dashboard
  2. Click Integrations in the header menu Integrations Pn
  3. Click Create New Integration Create Integration Pn

​
Step 2: Fill out integration metadata (in the first tab)

This information is what users see when browsing your integration. Integrationmetadata Pn
FieldWhat to EnterExample
Integration NameWhat it doesOpenAI Text to Image
(Example shown here is for OpenAI, but you can replace this with details for your chosen platform)
Short DescriptionPurposeGenerate custom images from text prompts using OpenAI DALL·E
LogoUpload a 256×256 PNG imageUse OpenAI’s logo or a visual art icon
Example PromptsAdd 3–5“Generate a realistic cat photo”, “Create a fantasy landscape”
Public or PrivateVisibilityChoose between “Private” for yourself, or “Public” for community use & reward

​
Step 3: Define integration functionality (in the second tab)

​
Backend functions

Keep Backend function turned on. This allows Base44 to make secure requests to other services in the background without exposing your private information. Integrationbackendfunction Pn
For extra information about setting up backend functions check out our guide here.

​
Add API Key

Integrationkeys Pn
  1. Click add API key
  2. Enter the following:
FieldValue
NameOPENAI_API_KEY
DescriptionYour secret API key (in this case, for OpenAI,starts with sk-…)
How to Get Ithttps://platform.openai.com/account/api-keys

​
Step 4: Paste the integration prompt (“instruction set”)

Implementationguide Pn Copy and paste this exact block into the “integration prompt” field. This code is the recipe that tells Base44 how to make your integration work.  
The example in the code block below uses OpenAI’s image generation API. If you are integrating with another service, you will need to update the code to match the service’s API endpoint, authentication and request format.
# OpenAI Text to Image Integration

## 1. Overview
This integration generates images based on natural language prompts using OpenAI’s DALL·E model.

## 2. Environment Variables
```json
[
  {
    "name": "OPENAI_API_KEY",
    "description": "Your OpenAI secret API key (starts with sk-...)",
    "how_to_get": "https://platform.openai.com/account/api-keys"
  }
]
```

## 3. Backend Function (Deno)
```ts
Deno.serve(async (req) => {
  const OPENAI_API_KEY = Deno.env.get("OPENAI_API_KEY");
  const { prompt } = await req.json();

  if (!prompt) {
    return new Response(JSON.stringify({ error: "Missing prompt" }), {
      status: 400,
      headers: { "Content-Type": "application/json" }
    });
  }

  const response = await fetch("https://api.openai.com/v1/images/generations", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${OPENAI_API_KEY}`
    },
    body: JSON.stringify({ prompt })
  });

  const data = await response.json();

  if (!response.ok) {
    return new Response(JSON.stringify({ error: data }), {
      status: response.status,
      headers: { "Content-Type": "application/json" }
    });
  }

  return new Response(JSON.stringify(data), {
    status: 200,
    headers: { "Content-Type": "application/json" }
  });
});
```

## 4. Frontend Component (Optional)
```tsx
const generateImage = async (prompt) => {
  const res = await fetch("/functions/openai-image.js", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ prompt })
  });

  const result = await res.json();
  return result?.data?.[0]?.url || null;
};
```

## 5. Usage & Examples
- Prompt: “Generate an image of a futuristic flying car”  
- User types prompt → Backend calls OpenAI → Returns image URL

## 6. Research Summary & Resources
- [OpenAI Image Generation Docs](https://platform.openai.com/docs/api-reference/images/create)  
- API: `POST https://api.openai.com/v1/images/gene
Only edit the code if you are familiar with JavaScript/Deno. If you just want the integration to work as described, paste it exactly as shown.

​
If you do want to customize it, here’s what each main part does:

  • Read your API key → securely gets the key from your environment variables so it’s not exposed.
  • Accept a user request → waits for the prompt or input the user types.
  • Send the request to the API → calls the API endpoint (in this example, OpenAI’s image generation API).
  • Get the response → receives the API’s result (for OpenAI, that’s an image URL).
  • Return it to the app → sends the result back so it can be shown in chat or another interface.
For another platform, you would change the API endpoint, request format, and how the response is handled to match that service’s documentation.

​
Final step: save & test

  1. Click Save Integration
  2. Open a new app and type in chat: “Generate an image of a panda surfing a wave”
  3. Paste your API key when prompted
  4. The image will appear, ready to use or display

​
You just built a production-ready integration

  • ✅ You created a backend-powered Ready-Made integration
  • ✅ You structured and registered an API key
  • ✅ You used the official Base44 integration prompt format
  • ✅ You can now repeat this process for any external API

​
Want to publish it?

  • Set to Public during submission
  • If approved, it will be added to the Base44 Integration Catalog
  • You’ll earn 250 credits and help the whole community 🚀
This process works for any API-powered integration so you can create ready-made integrations for a wide range of platforms. 

​
A few quick fixes

  • Image not showing → check API key (in this example, for OpenAI, it must start with sk-)
  • “Missing prompt” error → enter a description of the image you want
  • “Invalid API key” error → create a new key in OpenAI
  • Integration missing from catalog → click save and check visibility
  • API error with OpenAI → wait a few minutes and try again