How to Configure the Base44 GitHub App Integration

According to a Gartner press release, 75% of new enterprise applications will be built using low-code or no-code technologies by 2026. However, developer operations teams still face a significant challenge when trying to link visual builder configurations with standard deployment workflows. The Stack Overflow Developer Survey shows that over 93% of developers rely on Git for version control, making repository-level synchronization a necessity for professional applications. Visual tools are highly effective for rapid prototyping and layout creation, but they must connect to repository infrastructure to fit into normal enterprise release processes.

The Base44 GitHub integration bridges the gap between no-code prompt building and traditional version control by syncing generated app files to a repository. This integration allows teams to establish a reliable connection between visual application building and stable source control. By syncing the underlying code files directly, developers can use GitHub features such as pull requests, repository backups, and automated actions. This setup requires a Base44 Builder plan or higher. Connecting the project to GitHub allows teams to transition from visual design to normal developer environments without manual file downloads.

To link your repository, the platform provides a step-by-step setup list. This setup establishes the connection through the GitHub App interface, granting Base44 permissions to read and write code to your chosen repository.

To connect your project, execute the following configuration steps:

1. Open the project inside the Base44 app editor.
2. Open your project dashboard page.
3. Click the GitHub icon located in the upper-right corner of the dashboard screen.
4. Select the Connect to GitHub option from the dropdown menu, then click Connect GitHub.
5. In the new browser window, follow the prompts to complete the one-click authorization via Base44 Builder app.
6. Choose the GitHub organization or personal account where you want to install the integration.
7. Select the specific repository you want to link, or choose to create a new repository directly from the setup window.
8. Click Install to authorize the integration and establish the connection.

Once authorized, you can access your repository by clicking the Go to Repository button in the editor panel. The integration is configured to push new changes automatically to the repository whenever you publish a new version of the app. This sync behavior is designed to be permanent.

When Base44 pushes code to your repository, it syncs styling, assets, and database schemas. The integration packages the visual builder state into structured files that map to standard code assets. Understanding the directory layout helps developers configure downstream builds and deployment pipelines.

Project Assets: Static files such as images, logos, and custom icons are placed in the assets directory of your repository. This step ensures that any files uploaded to the visual editor are kept in sync with the repository.

Visual Styling: Layout styles and interface configurations are exported into CSS or styled JSON configurations. Base44 translates visual styles into standard style code. This allows external tools or hosting engines to render the application interface exactly as it appeared in the builder dashboard.

Database Schemas: Database configurations and table structures are exported as JSON schemas. This representation lists the data fields, types, and relationships defined in your project. These schemas are highly important for configuring database instances during deployment, allowing you to replicate the database layout in staging or production environments.

Syncing these components enables teams to deploy the code to hosting environments, run local tests, or index the files using external workspace engines.

While Base44 supports syncing code back to the editor, two-way sync is fragile. Manual changes made directly to the repository can break visual layout parsing when Base44 imports the files back. Developers must understand this limitation to avoid breaking project configurations.

First, two-way sync only supports the main branch of your GitHub repository. The master branch is not supported. To sync changes from GitHub back to the Base44 editor, you must merge those changes into the main branch. Merging to other branches will not trigger the import sync.

Second, making manual edits to the repository files outside the Base44 visual editor is risky. The editor relies on specific JSON structures and comments to parse layout styles and component positions. If a developer manually refactors these files, the visual builder may fail to read the code, resulting in layout errors. Many teams recommend treating the integration primarily as a push-only sync for backups and deployment. It is best to avoid pushing external code changes back into the visual editor unless necessary.

Finally, connecting your project to GitHub changes how you revert versions. Once you connect GitHub, the built-in Base44 Version History is disabled for versions created before the connection. To restore an older version, you must rely on Git history and roll back commits in your repository rather than using the Base44 dashboard.

Persist and search your Base44 GitHub repository assets

Synchronize your GitHub repositories with organization-owned Fastio workspaces. Keep generated code version-controlled, searchable via Intelligence Mode, and queryable by agents. Start your 14-day free trial.

Start 14-Day Trial

Once your Base44 code is synced to GitHub, you need a shared space to coordinate assets, document workflows, and collaborate with your team. Relying on local desktop folders, raw Amazon S3 buckets, or consumer cloud storage introduces coordination issues.

Legacy Storage Tradeoffs:

1. Local directories isolate files on individual computers, preventing team members and automated agents from accessing them.
2. Raw S3 buckets require complex access policies and lack a visual collaboration interface or search tools.
3. Standard Google Drive or Dropbox folders do not support real-time version tracking for concurrent agent access.

The Fastio Solution: Fastio provides an intelligent workspace platform where humans and software agents collaborate on the same files. By uploading your GitHub repository files into a Fastio workspace, you can coordinate your development.

When you enable Intelligence Mode on a Fastio workspace, files are automatically indexed for semantic search, citation-backed chat, and auto-summarization. Teams can use the AI agent Ripley to query code files and search project directories using natural language. Fastio hybrid search combines exact full-text matching with semantic retrieval, allowing you to find variables or layout styles by their name or meaning.

Fastio also provides Metadata Views, which allow you to turn workspace files into a queryable data grid. Instead of reading files manually, you describe the fields you want extracted in natural language. The AI designs a schema using fields like Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time. It then populates a spreadsheet grid. Differentiate Metadata Views from Intelligence Mode: Metadata Views serve as the structured extraction layer for files. For more details on metadata extraction, visit the Fastio Metadata Views page.

Additionally, Fastio workspaces maintain a detailed version history for every file. If an agent writes an update or modifies a configuration incorrectly, you can restore previous versions. All operations are written to an append-only audit log, ensuring a complete record of changes.

For development teams building automation around Base44 code, Fastio offers a Model Context Protocol server. Software agents can connect to your workspace programmatically using Streamable HTTP at https://mcp.fast.io/mcp or legacy SSE at https://mcp.fast.io/sse. This allows agents to read and write files, search workspaces, and ask Ripley.

The following Python script shows how to upload a published repository file into a Fastio workspace and list that folder through the REST API. Create an API key in Settings > Devices & Agents > API Keys, or with POST https://api.fast.io/current/user/auth/key/. Authenticated calls send Authorization: Bearer {api_key}. Small-file uploads use multipart/form-data. Folder listings are cursor-paginated.

import os
import requests

#config: Fastio API configuration details
API_BASE_URL = "https://api.fast.io/current"
API_KEY = "your_scoped_api_key"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def upload_file(workspace_id, file_path, folder_id="root"):
    """Upload a local file into a Fastio workspace folder."""
    url = f"{API_BASE_URL}/upload/"
    name = os.path.basename(file_path)
    with open(file_path, "rb") as handle:
        chunk = handle.read()
    data = {
        "name": name,
        "size": str(len(chunk)),
        "action": "create",
        "instance_id": workspace_id,
        "folder_id": folder_id,
    }
    files = {"chunk": (name, chunk)}
    response = requests.post(url, headers=headers, data=data, files=files)
    if response.status_code == 201:
        return response.json()
    raise Exception(f"Failed to upload file: {response.text}")

def list_workspace_folder(workspace_id, parent_id="root", cursor=None):
    """List a folder in a Fastio workspace."""
    url = f"{API_BASE_URL}/workspace/{workspace_id}/storage/{parent_id}/list/"
    params = {
        "sort_by": "name",
        "sort_dir": "asc",
        "page_size": 100,
    }
    if cursor:
        params["cursor"] = cursor
    response = requests.get(url, headers=headers, params=params)
    if response.status_code == 200:
        return response.json()
    raise Exception(f"Failed to list files: {response.text}")

#run: upload a schema file, then list the workspace root
workspace_id = "1234567890123456789"
uploaded = upload_file(workspace_id, "schemas.json")
print("Upload id:", uploaded.get("id"), "file id:", uploaded.get("new_file_id"))

listing = list_workspace_folder(workspace_id)
pagination = listing.get("pagination", {})
print("has_more:", pagination.get("has_more"))
print("next_cursor:", pagination.get("next_cursor"))

A GitHub Action can run the same upload after Base44 publishes to the repository. Teams can then ask Ripley about the ingested files in the workspace and review the append-only audit log for each change.

Ownership and Handoff: During setup, an agent account can create the workspace, configure files, and establish schemas. Once the workspace is ready, the agent can initiate an ownership transfer, sending a claim link to a human administrator. Every organization runs on a paid subscription, starting with a 14-day free trial that requires a credit card. Fastio offers plans for every scale: Starter $29/mo, Business $99/mo, and Growth $299/mo. For details, refer to the pricing tiers and the storage for agents page.