---
title: "Connect Fulcrum to Claude: Manage App Forms and User Access"
slug: connect-fulcrum-to-claude-manage-app-forms-and-user-access
date: 2026-10-07
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Fulcrum to Claude. Automate field data collection, run SQL queries, and manage user access using AI."
tldr: "Connect Fulcrum to Claude using Truto's managed MCP servers. This guide covers API realities, setup via UI/API, configuring Claude Desktop, and executing field ops workflows with AI."
canonical: https://truto.one/blog/connect-fulcrum-to-claude-manage-app-forms-and-user-access/
---

# Connect Fulcrum to Claude: Manage App Forms and User Access

**Fulcrum in Claude, in about a minute.** The best way to connect Fulcrum to Claude is Elaichi: connect Fulcrum to Elaichi once, then add Elaichi to Claude as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect Fulcrum.** Connect Fulcrum once in Elaichi. Claude never gets more access than you have.
3. **Add Elaichi to Claude.** In Claude, open Customize, then Connectors, press Add and paste https://api.elaichi.ai/mcp. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=fulcrum) · [Fulcrum on Elaichi](https://elaichi.ai/connectors/fulcrum/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=fulcrum)

*Building Fulcrum into your own product? The guide below is for you.*

---

If your team needs to connect Fulcrum to Claude to automate field data collection, provision contractor access, or run complex SQL queries against inspection records, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between Claude's tool calls and Fulcrum's REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. 

If your team uses ChatGPT, check out our guide on [/connect-fulcrum-to-chatgpt-query-data-and-run-sql-analysis/](https://truto.one/connect-fulcrum-to-chatgpt-query-data-and-run-sql-analysis/) or explore our broader architectural overview on [/connect-fulcrum-to-ai-agents-sync-field-media-and-pdf-reports/](https://truto.one/connect-fulcrum-to-ai-agents-sync-field-media-and-pdf-reports/).

Giving a Large Language Model (LLM) read and write access to a specialized field operations platform like Fulcrum is an engineering challenge. You have to handle API token lifecycles, map massive nested JSON schemas to MCP tool definitions, and deal with Fulcrum's domain-specific data constraints. Every time Fulcrum updates an endpoint or deprecates a field type, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Fulcrum, connect it natively to Claude Desktop, and execute complex field management workflows using natural language.

> Want to give your AI agents secure, authenticated access to Fulcrum and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Fulcrum API

A custom MCP server is a self-hosted integration layer. While [the open MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B APIs is painful. Fulcrum is built to manage offline-first mobile data collection, geospatial records, and complex relational databases. Its API reflects that complexity.

If you decide to build a [custom Fulcrum MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), here are the specific integration challenges you will face:

**Nested Form Schemas and Data Destruction Risks**
In Fulcrum, an app (or "form") is not a flat SQL table. It is defined by a deeply nested `elements` array containing field definitions, validation rules, and conditional logic. When you update a form via the API, you must pass the entire representation of the form. Omitting existing elements in your PUT request will result in immediate data loss, as the API assumes you intend to delete those fields. An LLM has no inherent context for this risk. Your MCP server must strictly enforce schema parity and prevent destructive partial updates.

**Opaque Form Values and Spatial Context**
When you interact with Fulcrum records, the actual data is stored inside a `form_values` object. The keys in this object are not friendly human-readable strings like "Inspection Date" - they are system-generated alphanumeric IDs (e.g., `8f3a`). If Claude wants to create a record, it cannot simply guess the payload structure. Your MCP server must dynamically map the human-readable labels to these internal keys. Additionally, records require spatial context. You must handle coordinate validation for latitude/longitude pairs or well-formed GeoJSON geometries.

**Rate Limits and Upstream Propagation**
Fulcrum strictly limits API request velocity to protect its infrastructure. When building an integration, it is critical to understand how these limits are handled. It is important to note that Truto does not retry, throttle, or absorb rate limit errors. If the Fulcrum API returns an HTTP 429 Too Many Requests, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit data into standard IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). Your AI agent or client architecture is fully responsible for reading these headers and implementing its own exponential backoff logic.

## How to Create the Fulcrum MCP Server

To bridge Claude and Fulcrum, you need to spin up an MCP server. Truto handles the dynamic tool generation, token hashing, and JSON-RPC 2.0 protocol handling behind the scenes. You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

This is the fastest method for internal tooling or quick proof-of-concept deployments.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Fulcrum account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can restrict the server to specific HTTP methods (like `read` only) or specific tool tags.
5. Copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`

### Method 2: Via the Truto API

If you are building a multi-tenant SaaS application where you need to deploy AI agents for your end-users, you will provision MCP servers programmatically.

Send a POST request to `/integrated-account/:id/mcp` with your desired configuration constraints.

```typescript
const response = await fetch(
  'https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: "Fulcrum Field Ops Agent",
      config: {
        methods: ["read", "write"],
        tags: ["forms", "records", "users"]
      }
    })
  }
);

const mcpServer = await response.json();
console.log(mcpServer.url); // The endpoint to pass to Claude
```

## How to Connect the MCP Server to Claude

Once you have your Truto MCP server URL, you need to register it with your AI client so the model can discover and execute the Fulcrum tools.

### Method A: Via the Claude UI (or ChatGPT Developer Mode)

For browser-based interfaces that support custom remote MCP connectors (like Claude Team/Enterprise or ChatGPT Developer Mode):

1. In your AI client, navigate to **Settings -> Integrations** (or **Connectors**).
2. Click **Add MCP Server** or **Add Custom Connector**.
3. Paste the Truto MCP URL generated in the previous step.
4. Click **Save** or **Add**. The client will immediately handshake with the Truto server, exchange protocol versions, and list all available Fulcrum tools.

### Method B: Via Claude Desktop Config File

For local development using Claude Desktop, you will map the server using Server-Sent Events (SSE) via the official MCP CLI proxy.

Open your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS) and add the following configuration:

```json
{
  "mcpServers": {
    "fulcrum-ops": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_TRUTO_MCP_TOKEN"
      ]
    }
  }
}
```

Restart Claude Desktop. The application will initialize the SSE transport, parse the JSON Schema for the Fulcrum API, and inject the tools into Claude's context window.

## Fulcrum Hero Tools for Claude

Truto dynamically derives MCP tools directly from the underlying API documentation and integration schemas. Here are the highest-leverage tools available for Fulcrum.

### list_all_fulcrum_forms

Returns the metadata and structural schema for your Fulcrum forms (apps). Because Fulcrum records rely on system-generated field keys, calling this tool is the critical first step for an LLM to understand what data it can collect or query.

> "Fetch the schemas for all active forms in our Fulcrum organization. I need to know the exact field IDs used in the 'Daily Safety Briefing' app."

### list_all_fulcrum_records

Retrieves the actual field data collected by your team. You can filter the results by form, project, bounding box, or date ranges. The LLM handles the pagination cursors automatically via Truto's standardized response envelopes.

> "Pull all records submitted for the 'Turbine Audit' form in the last 48 hours. Summarize any records where the inspector flagged critical damage."

### create_a_fulcrum_record

Submits new data into a Fulcrum form. The LLM must supply the `form_id` and the nested `form_values` object containing the data mapped to the correct alphanumeric keys. It can optionally include latitude, longitude, or full GeoJSON geometries.

> "Create a new record in the 'Site Incident' form. Set the incident type to 'Weather Delay', log the latitude as 34.0522 and longitude as -118.2437, and set the status to Open."

### create_a_fulcrum_query

Executes a read-only SQL query directly against your Fulcrum organization's data. This is a massive leverage point for AI agents, allowing them to bypass complex pagination by writing native SQL (`SELECT * FROM "Safety Audits" WHERE _created_at > '2023-01-01'`) and executing it via HTTP POST.

> "Run a SQL query against our Fulcrum data to find the top 5 field inspectors who have submitted the most 'Quality Assurance' records this month. Return the results in a markdown table."

### list_all_fulcrum_users

Lists the users inside your Fulcrum organization. This tool is essential for mapping names to user IDs when you need to assign records, grant project access, or audit system governance.

> "List all active users in our Fulcrum instance and identify anyone who currently holds the 'Account Owner' role."

### fulcrum_memberships_change_permissions

Updates a user's access rights. You can grant or revoke permissions to specific layers, forms, or projects by submitting arrays of resource IDs.

> "Take user ID 8a7b6c5d and add them to the 'Texas Wind Farm' project. Make sure they have read and write permissions for the associated project forms."

To view the complete inventory of available resources, endpoints, and JSON schemas, visit the [Fulcrum integration page](https://truto.one/integrations/detail/fulcrum).

## Workflows in Action

Here is how an AI agent uses the MCP server to autonomously execute complex field operations workflows.

### Workflow 1: Dynamic Field Data Auditing

**Persona:** QA Manager  
**Prompt:** "Find the 'Bridge Inspection' form, figure out what the field ID is for 'Structural Integrity Rating', and then run a SQL query to find all records from this week where the rating was below 3. Summarize the inspector notes for those failures."

**Execution Steps:**
1. Claude calls `list_all_fulcrum_forms` to retrieve the schema for the "Bridge Inspection" form and parses the `elements` array to find the alphanumeric key for "Structural Integrity Rating" (e.g., `a1b2`).
2. Claude constructs a SQL payload and calls `create_a_fulcrum_query` to query the backend: `SELECT _record_id, a1b2 AS rating, c3d4 AS notes FROM "Bridge Inspection" WHERE _created_at >= '2023-10-01' AND a1b2 < 3`.
3. Claude parses the returned SQL rows and generates a natural language summary of the failed inspections and their associated notes.

```mermaid
sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Fulcrum as Fulcrum API

    User->>Claude: "Find failing bridge inspections..."
    Claude->>Truto: Call list_all_fulcrum_forms
    Truto->>Fulcrum: GET /api/v2/forms
    Fulcrum-->>Truto: Form Schemas (JSON)
    Truto-->>Claude: Tool Result (elements mapped)
    
    Claude->>Truto: Call create_a_fulcrum_query (SQL payload)
    Truto->>Fulcrum: POST /api/v2/query
    Fulcrum-->>Truto: SQL Result Rows
    Truto-->>Claude: Tool Result (rows)
    
    Claude-->>User: "Found 3 failing inspections. Here are the notes..."
```

### Workflow 2: Automated Contractor Onboarding

**Persona:** Field Operations Admin  
**Prompt:** "We just hired Jane Smith as an external surveyor. Look up her user profile in Fulcrum, find the 'Surveyors' group, and grant her group access to the 'Land Assessment' and 'Environmental Impact' forms."

**Execution Steps:**
1. Claude calls `list_all_fulcrum_users` to find Jane Smith's internal user ID.
2. Claude calls `list_all_fulcrum_groups` to find the exact group ID for "Surveyors".
3. Claude calls `list_all_fulcrum_forms` to find the form IDs for "Land Assessment" and "Environmental Impact".
4. Claude calls `fulcrum_groups_change_permissions` passing the group ID and the specific `change.add` payloads to grant form access to the newly identified resources.

## Security and Access Control

When giving AI agents read and write access to your primary field data platform, you must enforce strict boundaries. Truto MCP servers provide multiple layers of configuration to limit the blast radius of autonomous tool execution:

*   **Method Filtering:** By passing `config.methods: ["read"]` during server creation, you completely disable the generation of state-mutating tools like `create_a_fulcrum_record` or `fulcrum_forms_bulk_delete`. The LLM physically cannot execute a write operation.
*   **Tag Filtering:** You can isolate agent access by business domain. Setting `config.tags: ["users", "memberships"]` restricts the server to governance endpoints, preventing the agent from reading field data records.
*   **Extra API Token Auth:** Setting `require_api_token_auth: true` means possession of the MCP URL is not enough to execute a tool. The client must also pass a valid Truto API token in the `Authorization` header, linking the execution to a specific authenticated team member.
*   **Ephemeral Servers:** By providing an `expires_at` ISO datetime, the server self-destructs at a specific time. The distributed key-value store automatically invalidates the token, and background alarms clean up the database records, ensuring contractors or automated jobs do not retain perpetual access.

## The True Cost of Building Integrations

Building a custom MCP server for a complex system like Fulcrum is entirely possible, but you are signing up to maintain that infrastructure forever. You have to handle rate limit propagation, token lifecycles, nested schema flattening, and ongoing endpoint migrations.

Managed MCP servers decouple your AI product's agent logic from the grunt work of third-party API integration. By auto-generating documentation-driven tools and routing them through a standardized protocol, your engineering team can focus on prompt engineering and workflow orchestration instead of fixing broken API connectors.
