---
title: "Connect Fieldwire to Claude: Manage RFIs, Submittals & Floorplans"
slug: connect-fieldwire-to-claude-manage-rfis-submittals-floorplans
date: 2026-10-10
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Fieldwire to Claude using a managed MCP server to automate RFIs, submittals, and floorplan workflows without custom integration code."
tldr: "A complete technical guide to connecting Fieldwire to Claude via an MCP server. Learn how to handle Fieldwire's async media jobs, RFI state machines, and API rate limits."
canonical: https://truto.one/blog/connect-fieldwire-to-claude-manage-rfis-submittals-floorplans/
---

# Connect Fieldwire to Claude: Manage RFIs, Submittals & Floorplans


If your team needs to connect Fieldwire to Claude to automate RFI management, submittal reviews, or floorplan versioning, 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 natural language tool calls and Fieldwire's complex construction management APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [/connect-fieldwire-to-chatgpt-automate-field-reports-project-tasks/](https://truto.one/connect-fieldwire-to-chatgpt-automate-field-reports-project-tasks/) or explore our broader architectural overview on [/connect-fieldwire-to-ai-agents-track-construction-costs-bim-data/](https://truto.one/connect-fieldwire-to-ai-agents-track-construction-costs-bim-data/).

Giving a Large Language Model (LLM) read and write access to a specialized job site management system like Fieldwire is an engineering challenge. You have to handle API token lifecycles, map deeply nested JSON schemas to MCP tool definitions, and deal with Fieldwire's strict asynchronous media processing logic. Every time Fieldwire updates an endpoint or deprecates a resource, 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 Fieldwire, connect it natively to Claude Desktop, and execute complex construction workflows using natural language.

> Want to give your AI agents secure, authenticated access to Fieldwire 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 Fieldwire API

A [custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B APIs is painful. Fieldwire is built to manage heavy media (floorplans, 3D BIM models), offline-first mobile sync states, and strict construction workflows. Its API reflects that complexity.

If you decide to [build a custom Fieldwire 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:

**Strict Workflow State Machines for RFIs and Submittals**
Fieldwire enforces strict domain logic around its documentation. For example, transitioning a Request for Information (RFI) or a Submittal is not a simple `PATCH` request to update a `status` string. If an LLM tries to write `{"status": "answered"}` to the standard RFI update endpoint, the request will fail. Instead, you must use dedicated transition endpoints (e.g., `fieldwire_project_rfis_transition`), which require specific resolution payloads, watcher assignments, and valid state machine transitions (e.g., you cannot jump from `draft` directly to `closed` without passing through `open`). Your MCP tools must explicitly guide Claude to use these transition endpoints.

**Asynchronous Heavy Media and Job Polling**
Fieldwire manages massive files - high-resolution floorplans, OCR processing, and BIM models. Because these files take time to process, many endpoints do not return synchronous data. Operations like generating a form PDF, exporting a submittal, or flattening markups onto a floorplan return a `202 Accepted` status along with a job ID (`jid`). An LLM has no concept of polling intervals. You must design your MCP tools to handle async polling or instruct Claude to check back later using a specific job status endpoint.

**Offline-First Data Architecture (Device Timestamps and Tombstones)**
Because Fieldwire is designed for offline access on construction sites, its API is built around sync engines. You will encounter fields like `device_created_at`, `device_updated_at`, and `deleted_at` on almost every record. Soft deletes (tombstoning) are standard; deleting a task or a markup often just populates the `deleted_at` field rather than removing the row. When exposing tools to Claude, you must carefully define query schemas to filter out soft-deleted records by default, or the LLM will hallucinate insights based on trashed data.

**Strict Rate Limits Without Safety Nets**
Fieldwire enforces rate limits to protect its infrastructure. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Fieldwire API returns an HTTP `429 Too Many Requests`, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller - in this case, the LLM or your agent framework - is entirely responsible for detecting the 429 and executing its own backoff logic.

## How Truto's Managed MCP Server Fixes This

Instead of writing and maintaining custom API polling loops, state machine validation, and schema mapping for Fieldwire, you can use Truto. 

Truto automatically generates MCP tools directly from the Fieldwire integration's underlying documentation and schema definitions. Because this generation is dynamic, you never have to manually map an endpoint to a JSON-RPC format. Truto handles the OAuth token lifecycle and presents a secure, stateless URL that Claude can connect to instantly.

### Step 1: Generating the Fieldwire MCP Server

You can generate the MCP server URL in two ways: through the Truto UI for rapid prototyping, or programmatically via the Truto API for automated deployments.

**Method A: Via the Truto UI**
1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your active Fieldwire connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your configuration. You can filter the server to only allow specific methods (e.g., `read` only) or specific tags (e.g., `rfis`, `submittals`).
5. Copy the generated MCP Server URL.

**Method B: Via the Truto API**
For engineering teams building multi-tenant AI agents, you can generate MCP servers programmatically for each of your users' connected Fieldwire accounts.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Fieldwire Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["rfis", "submittals", "tasks", "floorplans"]
    },
    "expires_at": null
  }'
```

The API returns a secure, cryptographically hashed token URL:

```json
{
  "id": "mcp_abc123",
  "name": "Claude Fieldwire Agent",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

### Step 2: Connecting the Server to Claude

Claude Desktop supports direct integration with MCP servers over HTTP/SSE. You can connect the server via the Claude UI or by manually editing the configuration file.

**Method A: Via the Claude UI**
1. Open Claude Desktop.
2. Navigate to **Settings** -> **Integrations** -> **Add MCP Server**.
3. Paste the `https://api.truto.one/mcp/...` URL provided by Truto.
4. Click **Add**. Claude will instantly execute a protocol handshake, pull the available Fieldwire tools, and display them in the interface.

**Method B: Via Manual Config File**
If you prefer to manage your environment as code, you can inject the Truto MCP server directly into Claude's configuration file.

*   **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
*   **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

Update the configuration to utilize the official Model Context Protocol SSE runner to proxy the HTTP requests:

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

Restart Claude Desktop. The application will initialize the connection, and Claude will now be aware of the Fieldwire API.

## Hero Tools for Fieldwire Automation

When connected, Claude gains access to hundreds of Fieldwire operations. However, solving real construction management problems requires understanding the highest-leverage tools. Here are the core hero tools Claude uses to orchestrate Fieldwire.

### list_all_fieldwire_project_rfis

This tool retrieves the full list of Requests for Information for a specific project. It includes crucial metadata such as the RFI's current status, due date, assignee, question content, and attached media. Because Fieldwire heavily utilizes pagination, the tool automatically injects `limit` and `next_cursor` arguments, allowing Claude to traverse large datasets without losing context.

> "Claude, list all the RFIs in project ID '12345' that are currently marked as 'open' and extract the specific questions being asked by the sub-contractors."

### fieldwire_project_rfis_transition

Instead of attempting to force a standard update on an RFI status, this custom tool navigates Fieldwire's strict RFI workflow state machine. It requires the target state (`to_state`), the project ID, and the RFI ID. The underlying schema guides Claude to provide necessary payloads, such as answers or reviewer notes, required to successfully move the RFI to the next phase.

> "Claude, transition RFI ID '9876' in project '12345' to 'answered'. Use the answer text: 'The structural steel beam needs to be reinforced with plates as per the revised drawing 4A.'"

### list_all_fieldwire_project_submittals

This tool queries the submittals registry for a project. Submittals (such as shop drawings or material data) are heavily regulated documents. The tool schema allows Claude to filter by assignee, watcher, spec section, or date ranges, returning complex objects containing revision numbers, submittal types, and assignment trees.

> "Claude, pull all submittals for project '12345' assigned to John Doe that are currently in the 'pending_review' state. Summarize their titles and due dates."

### fieldwire_project_submittals_transition

Similar to RFIs, submittals follow a rigid lifecycle (draft, requested, pending_review, pending_approval, pending_close, closed, or void). This tool advances a submittal, optionally allowing Claude to reassign the document to a new reviewer and trigger email notifications in one atomic operation.

> "Claude, transition submittal ID '5555' to 'pending_approval' and reassign the review to Jane Smith. Add a message stating the shop drawings look acceptable but require final architect sign-off."

### list_all_fieldwire_project_floorplans

Retrieves the foundational architectural drawings for a project. The schema returns version metadata, active sheet counts, and image URLs. This tool is vital when Claude needs to cross-reference tasks, RFIs, or markups against specific physical locations on the job site.

> "Claude, list all active floorplans for project '12345'. I need to find the specific ID for the 'Level 3 Electrical Layout' so we can assign new tasks to that sheet."

### create_a_fieldwire_project_task

This tool generates actionable work items within Fieldwire. It accepts rich payloads, including the task name, priority, status ID, assignees, and the project ID. Claude can use this to automatically dispatch work derived from answered RFIs or failed submittals.

> "Claude, create a new high-priority task in project '12345' named 'Verify steel plate reinforcement on Level 3'. Assign it to user ID '999' and set the status to 'open'."

To view the complete schema definitions and the full list of available tools, visit the [Fieldwire integration page](https://truto.one/integrations/detail/fieldwire).

## Workflows in Action

Giving Claude access to Fieldwire tools is only half the battle. The real value comes when Claude sequences these tools to execute complex, multi-step construction administration workflows.

### Scenario 1: Resolving RFIs and Dispatching Work

**The Prompt:**
> "Review all open RFIs for project ID '94821'. If you find the RFI regarding the 'HVAC duct collision on Level 2', transition it to answered using the text 'Proceed with rerouting the duct 12 inches lower as per the mechanical engineer's email'. Then, immediately create a high-priority task for the foreman (user ID '102') to execute this rerouting on site."

**The Execution Flow:**

```mermaid
sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Upstream as Fieldwire API

    Claude->>Truto: call list_all_fieldwire_project_rfis<br>(project_id: "94821")
    Truto->>Upstream: GET /api/v3/projects/94821/rfis
    Upstream-->>Truto: Return RFI list
    Truto-->>Claude: JSON array of RFIs

    Note over Claude: Claude filters for 'HVAC duct collision'<br>and extracts RFI ID '5501'

    Claude->>Truto: call fieldwire_project_rfis_transition<br>(project_id: "94821", rfi_id: "5501", to_state: "answered", answer: "...")
    Truto->>Upstream: POST /api/v3/projects/94821/rfis/5501/transition
    Upstream-->>Truto: Return transitioned RFI
    Truto-->>Claude: Success

    Claude->>Truto: call create_a_fieldwire_project_task<br>(project_id: "94821", name: "Reroute HVAC duct...", priority: 3, owner_user_id: "102")
    Truto->>Upstream: POST /api/v3/projects/94821/tasks
    Upstream-->>Truto: Return new task ID
    Truto-->>Claude: Success
```

**1. Identify Target Data:** Claude calls `list_all_fieldwire_project_rfis` and parses the response to locate the specific RFI ID based on the natural language description.
**2. State Transition:** Claude calls `fieldwire_project_rfis_transition`, passing the exact answer text and navigating the API's strict workflow requirements.
**3. Task Dispatch:** Without missing a beat, Claude extracts the context from the RFI and uses `create_a_fieldwire_project_task` to assign the physical labor to the correct user in the field.

### Scenario 2: Auditing Submittals and Exporting Evidence

**The Prompt:**
> "Find all submittals assigned to me in project ID '94821' that are currently 'pending_approval'. For each one, queue a PDF export so I have a clean physical copy for the architect. Let me know the Job IDs for the exports so I can check on them later."

**The Execution Flow:**

```mermaid
sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Upstream as Fieldwire API

    Claude->>Truto: call list_all_fieldwire_project_submittals<br>(project_id: "94821", status: "pending_approval")
    Truto->>Upstream: GET /api/v3/projects/94821/submittals?status=pending_approval
    Upstream-->>Truto: Return pending submittals
    Truto-->>Claude: JSON array of submittals

    Note over Claude: Claude loops through submittals<br>IDs '101' and '102'

    Claude->>Truto: call create_a_fieldwire_submittal_export_pdf<br>(project_id: "94821", submittal_id: "101")
    Truto->>Upstream: POST /api/v3/projects/94821/submittals/101/export_pdf
    Upstream-->>Truto: 202 Accepted (jid: "job_alpha")
    Truto-->>Claude: Return jid

    Claude->>Truto: call create_a_fieldwire_submittal_export_pdf<br>(project_id: "94821", submittal_id: "102")
    Truto->>Upstream: POST /api/v3/projects/94821/submittals/102/export_pdf
    Upstream-->>Truto: 202 Accepted (jid: "job_beta")
    Truto-->>Claude: Return jid
```

**1. Filter Submittals:** Claude queries the submittal endpoint, utilizing the schema's built-in query parameters to isolate items requiring immediate attention.
**2. Handle Async Jobs:** Claude calls `create_a_fieldwire_submittal_export_pdf` for each item. Because the LLM schema accurately reflects the API's behavior, Claude expects a Job ID (`jid`) rather than an immediate PDF download URL.
**3. Report Status:** Claude outputs the `jid` references to the user, advising them that the exports are processing in the background and can be polled later.

## Security and Access Control

When providing LLMs with access to critical construction management systems, enforcing the principle of least privilege is mandatory. Truto provides several [architectural layers to lock down your Fieldwire MCP server](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/):

*   **Method Filtering (`config.methods`):** Restrict the server to safe operations. For example, setting `"methods": ["read"]` ensures Claude can list tasks, read RFIs, and view floorplans, but physically cannot create, update, or delete records in Fieldwire.
*   **Tag Filtering (`config.tags`):** Limit the scope of the server to specific operational domains. By passing `"tags": ["rfis"]`, you ensure the LLM can only interact with RFI-related endpoints, blinding it to financials, project attributes, or user management APIs.
*   **Time-To-Live (`expires_at`):** Generate ephemeral servers for short-lived automation scripts or contractor access. Once the ISO datetime passes, the backend automatically purges the token and infrastructure routing, rendering the URL dead.
*   **Require API Token Auth (`require_api_token_auth`):** For enterprise environments where MCP URLs might be exposed in configuration repositories, this flag requires the caller to pass a valid Truto API token in the authorization header, adding a strict secondary identity layer.

## Moving Past Manual Construction Administration

Connecting Claude to Fieldwire transforms the LLM from a passive chat interface into an active construction administration agent. Instead of humans copy-pasting answers into RFI web forms, manually updating task statuses based on email chains, or clicking through menus to export submittals, Claude can orchestrate these workflows directly against the Fieldwire API.

By leveraging a managed MCP server, you bypass the friction of building custom state machine validation, async polling logic, and OAuth lifecycles. You get a secure, filtered, instantly-usable connection that allows your team to focus on building structures, not maintaining integration code.