---
title: "Build with Base44"
description: "Use Inttegro with Base44 to turn a business workflow into a secure, working app."
canonical: "https://studio.inttegro.com/ai-builders/base44"
format: inttegro-machine-docs/v1
language: "Go"
sdk_version: "v11.0.1"
reader_profile: optional
reader_manifest: "https://studio.inttegro.com/machine/go/readers/index.json"
reader_identification: "Optional: declare your client only if known and your current-session capabilities; use reader_manifest for supplemental recommendations."
preamble_estimated_tokens: 600
model_token_report: "https://studio.inttegro.com/machine/token-report.json"
preamble_questions: 5
preamble_source: "general"
recommended_mcp_tools: ["design_integration","check_integration_readiness","get_integration_guide"]
estimated_tokens: 2274
token_estimate_method: "utf8_bytes_divided_by_4"
---

## Machine preamble

**Summary:** Use Inttegro with Base44 to turn a business workflow into a secure, working app. This Go representation uses the selected SDK's native names wherever Studio has a verified mapping.

### Five questions

#### Q1. When should the reader use Build with Base44?

Use this builder guide when that AI app builder is responsible for generating or extending the application.

#### Q2. What is authoritative on this page?

Use this page for orientation; follow its canonical SDK, guide, API, or MCP links for exact contracts.

#### Q3. What page-specific constraint matters most?

Keep API keys and live commerce calls in the builder’s protected server environment, never generated browser code.

#### Q4. Can Inttegro MCP materially help with this task?

Yes, when the reader has an authenticated MCP connection and the task needs live context, guided planning, or a supported operation. The strongest matches are `design_integration`, `check_integration_readiness`, `get_integration_guide`; their exact roles and boundaries are listed below.

#### Q5. How should the reader verify the answer and continue?

Inspect the generated server boundary, confirm secrets are not client-visible, run the documented end-to-end test, and verify authoritative commerce state.

### Recommended MCP assistance

Use these through an authenticated Inttegro MCP connection. This document remains the contract source.

- [`design_integration`](https://studio.inttegro.com/machine/go/inttegro-mcp/tools.md#design_integration) — read-only integration guidance. Elicits the integration goal, AI app builder, server runtime, SDK preference, and checkout approach, then returns a platform-aware build and test plan without accepting credentials.
- [`check_integration_readiness`](https://studio.inttegro.com/machine/go/inttegro-mcp/tools.md#check_integration_readiness) — read-only integration guidance. Audits platform secret storage, server-runtime compatibility, idempotency, errors, state verification, checkout returns, and messaging consent without receiving source code or credentials.
- [`get_integration_guide`](https://studio.inttegro.com/machine/go/inttegro-mcp/tools.md#get_integration_guide) — read-only integration guidance. Returns a focused implementation sequence and canonical Studio links for authentication, checkout, orders, catalog, messaging, idempotency, or testing.

## Document content

# Build with Base44

[Base44](https://base44.com/) can turn a business workflow into an app with
sign-in, data, roles, and a published customer or team experience. Connect
Inttegro MCP so its AI can plan
against the real Inttegro capabilities, then let a protected backend function
perform each live action.

[Open Base44](https://base44.com/) · [Read the Base44 documentation](https://docs.base44.com/)

:::warning MCP helps Base44 build the app

The MCP connection is available to Base44's AI chat while you build. It does not
become part of the published app. Live customer actions must use a backend
function or a reviewed custom integration.

:::

## Connect Inttegro MCP

Custom MCP connections require a Base44 Builder plan or higher.

1. Open your profile menu, then go to **Settings → MCP connections**.
2. Select **Add custom MCP**.
3. Name the connection `Inttegro` and enter `https://mcp.inttegro.com`.
4. Choose OAuth and complete Inttegro sign-in. If your account instead uses a
   dedicated bearer token, add it through the protected custom-header control;
   never paste it into the app chat.
5. Select **Test & add**, then confirm the connection is enabled.

Follow Base44's official [custom MCP setup](https://docs.base44.com/documentation/account-and-billing/setting-up-a-custom-mcp)
for the current account controls.

## Paste this into Base44

Start in **Plan** or **Discuss** mode. This keeps Base44 focused on the business
journey before it begins changing the app.

### Prompt

> **Copyable prompt:**
>
> **What I want to accomplish**Build \[describe what a customer or team member should be able to accomplish]
> for \[describe the business and its users]. Preserve the app's existing visual
> language, roles, permissions, and data.**Plan with Base44 before building**
>
> 1. Inspect the current app, its people and roles, entities, pages, functions,
>    integrations, and existing workflows.
> 2. Use the connected Inttegro MCP. Call `design_integration` for the outcome
>    above, then inspect only the operation references returned by the plan.
> 3. Ask me one concise round of questions for business decisions you cannot
>    learn from the app or Inttegro. Never ask me to paste a credential into chat.
> 4. Show me the recommended user journey, who may perform each action, the data
>    Base44 owns, the data Inttegro owns, failure states, and acceptance checks.
>    Wait for approval before editing the app.
>
> **Build the approved journey**
>
> - Put every live Inttegro request in a Base44 backend function. The browser may
>   invoke that function through Base44, but it must never call Inttegro with a
>   secret.
> - Store `INTTEGRO_API_KEY` in **Dashboard → Secrets** and read it only inside
>   the backend function. Never place it in chat, frontend code, app entities,
>   logs, or a response.
> - Base44 functions use Deno. Call the exact Inttegro operation by HTTPS unless
>   the installed official SDK explicitly supports this runtime; do not invent a
>   request shape or add a browser-side SDK.
> - Authorize each function for the signed-in person's role. Accept only the
>   fields that person is allowed to control, and derive protected values on the
>   server.
> - Use a stable idempotency key for every mutation. After a redirect, timeout,
>   or uncertain result, look up the Inttegro resource before trying a new action.
> - Keep Inttegro as the source of truth for its resources. Store only the IDs and
>   business context the Base44 app genuinely needs.
>
> **Test it as real people would use it**Run `check_integration_readiness`, exercise the complete journey in Preview,
> and use **Act as a user** to test every relevant role. Test the happy path, an
> invalid submission, a rejected operation, and an uncertain network result.
> Inspect function logs for exposed credentials or customer details. Fix every
> failure, then tell me the one secret to configure and the one action required
> to publish.

Base44's [quick-start guide](https://docs.base44.com/Getting-Started/Quick-start-guide)
explains planning, role-based testing, preview, and publishing.

## What Base44 should create

- a clear customer or team journey built around the stated outcome;
- one narrow backend function for each Inttegro workflow;
- role checks and input validation before every Inttegro action;
- complete loading, success, empty, retryable, and terminal-error states;
- stable idempotency keys for actions that change data; and
- authoritative lookup after redirects or uncertain results.

Base44's [backend functions](https://docs.base44.com/developers/backend/resources/backend-functions/overview)
run outside the browser and can use protected environment values. Its
[third-party API guide](https://docs.base44.com/developers/references/sdk/getting-started/third-party-apis)
shows the intended function-to-API boundary.

## Keep the credential in Secrets

Add `INTTEGRO_API_KEY` from the app dashboard rather than through AI chat. After
Base44 generates the function, inspect the code and verify that the secret is
read only in the function and never included in its result.

For a larger workspace, an administrator can instead create a reviewed
[custom integration](https://docs.base44.com/documentation/integrations/using-custom-integrations)
from an Inttegro OpenAPI contract. Expose only the operations the apps require,
keep the authorization header protected, and still enforce each app user's
permissions before invoking it.

## Before publishing

Test with disposable Inttegro data, inspect the browser network panel to confirm
that it calls only the Base44 boundary, and review the backend-function logs.
Publish only after each role sees the right actions and no credential, customer
contact, or unnecessary business detail crosses into the browser.
