Connect Fieldwire to ChatGPT: Automate Field Reports & Project Tasks

If you need to connect Fieldwire to ChatGPT to automate daily field reports, manage project tasks, or streamline Request for Information (RFI) workflows, you need a Model Context Protocol (MCP) server. This server translates ChatGPT's function calls into Fieldwire's specific REST API operations.

If your team uses Claude, check out our guide on connecting Fieldwire to Claude or explore our broader architectural overview on connecting Fieldwire to AI Agents.

Giving a Large Language Model (LLM) read and write access to a specialized construction management platform is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into Fieldwire's highly specific payload structures, or you use a managed infrastructure layer.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Fieldwire, connect it natively to ChatGPT, and execute complex construction project workflows using natural language.

The Engineering Reality of the Fieldwire API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Fieldwire's API requires dealing with several domain-specific constraints.

If you decide to build a custom MCP server for Fieldwire, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Fieldwire:

Offline-First Conflict Resolution

Fieldwire is designed for mobile workers operating on job sites with intermittent connectivity. As a result, the API relies heavily on device-level timestamps for conflict resolution. When creating or updating entities like tasks or markups, the API often expects device_created_at and device_updated_at timestamps alongside standard payload data. A custom MCP server must instruct the LLM on how to generate these ISO 8601 timestamps accurately, or inject them at the routing layer, otherwise the API may reject updates due to strict conflict resolution rules (resolved_conflict flags).

Flattened Blueprints and Markups

In construction software, an image is rarely just an image. Blueprints (floorplans) in Fieldwire are layered with bubble_markups, multi_hyperlinks, and attachment_markups. A standard GET request for a floorplan does not return a single image containing all the annotations. Instead, you have to query the base image and the coordinate-mapped annotations separately. To send a composite view to a downstream service or an LLM, your integration must explicitly call endpoints like create_a_fieldwire_bubble_flatten to rasterize the layers into a single thumbnail. Building tool descriptions that teach an LLM this multi-step flattening process requires careful schema design.

Deeply Nested Hierarchies and IDs

Fieldwire relies on strictly enforced relational hierarchies. A task cannot simply exist in a vacuum - it belongs to a project, is categorized by a status_id, mapped to a location_id, and typed by a task_type_id. When ChatGPT attempts to create a task, it cannot pass a string like "In Progress" for status; it must first discover the correct UUID by listing the project's statuses. Your MCP server must expose discovery tools for all these relational mapping endpoints, or the LLM will hallucinate invalid UUIDs, leading to continuous 400 Bad Request errors.

How to Create the Fieldwire MCP Server

Truto eliminates the need to build and host custom integration infrastructure. By pointing Truto at your authenticated Fieldwire account, it dynamically generates an MCP server derived directly from Fieldwire's API documentation and OpenAPI specifications.

There are two ways to generate this server.

Method 1: Via the Truto UI

This is the fastest approach for testing and internal workflows.

1. Log into your Truto dashboard and navigate to the Integrated Accounts section.
2. Select your authenticated Fieldwire connection.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. You can filter by methods (e.g., only allow read operations) or tags (e.g., only expose tasks and rfis).
6. Click Generate and copy the resulting URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For production deployments - such as programmatically spinning up secure AI agent sessions for your end-users - you will generate the MCP server via Truto's REST API.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Fieldwire Project Manager Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["projects", "tasks", "rfis", "submittals"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response returns the server URL. This single endpoint handles protocol initialization, tool listing, JSON-schema mapping, and execution routing.

A factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Fieldwire API returns an HTTP 429, Truto passes that error directly back to the caller (ChatGPT) along with normalized ratelimit-limit, ratelimit-remaining, and ratelimit-reset headers. The caller is strictly responsible for implementing retry and backoff logic.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes less than a minute. You have two implementation paths depending on your operational model.

Approach A: Via the ChatGPT UI

If you are using ChatGPT Desktop or Web (Pro, Plus, Business, Enterprise, or Education tiers), you can add the server directly.

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the custom connectors section, click Add a new server.
4. Enter a name (e.g., "Fieldwire Agent").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately perform the initialization handshake and ingest the available Fieldwire tools.

Approach B: Via Manual Config File

If you are running a local agent environment, an automated pipeline, or a framework that requires local proxying, you can connect using the official @modelcontextprotocol/server-sse package in your configuration file.

{
  "mcpServers": {
    "fieldwire": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN_HERE"
      ]
    }
  }
}

Hero Tools for Fieldwire Operations

Truto automatically generates tools for every documented Fieldwire endpoint. Instead of overwhelming the LLM with hundreds of raw REST routes, it selectively exposes curated, schema-validated tools.

Here are the most critical "hero tools" for automating construction management workflows.

list_all_fieldwire_projects

Every Fieldwire operation requires a project_id. This tool lists all projects the authenticated user has access to, returning critical metadata like project names, timezone, and configuration flags.

"List all active Fieldwire projects on my account and find the ID for the 'Downtown Highrise' project."

list_all_fieldwire_project_tasks

Retrieves the task list for a specific project. This tool is vital for auditing open work, checking priorities, and assessing punch list progress.

"Fetch all priority 1 tasks for project ID 12345 that have not been completed yet."

create_a_fieldwire_project_task

Allows the LLM to generate new punch items, assign work, or log issues directly from chat. The agent can set priorities and assign tasks to specific users.

"Create a new Priority 1 task in project ID 12345 called 'Fix HVAC ducting on floor 4' and assign it to John Doe."

create_a_fieldwire_task_task_check_item

Tasks often require specific quality assurance checklists. This tool adds individual check items to an existing task, enforcing standard operating procedures.

"Add three check items to task ID 98765: 'Verify duct sealing', 'Check airflow pressure', and 'Inspect filter placement'."

list_all_fieldwire_project_rfis

Retrieves all Requests for Information on a project. This allows ChatGPT to audit open questions, track pending responses from architects, and monitor due dates.

"List all open RFIs for project ID 12345 that are past their due date."

create_a_fieldwire_project_rfi

Generates a new RFI. This is a high-leverage tool that allows field workers to dictate a question into a mobile interface connected to an AI agent, which then structures the data and creates the official RFI in Fieldwire.

"Create a new RFI for project ID 12345. The question is 'Does the revised structural plan allow for moving load bearing column C4 two feet west?'. Set the due date for next Friday."

list_all_fieldwire_project_submittals

Fetches project submittals to track the approval status of materials, shop drawings, and equipment specs.

"Check the status of the 'Custom Elevator Cab' submittal on project ID 12345. Has the architect approved it yet?"

For the complete list of available tools, query schemas, and response formats, refer to the Fieldwire integration page.

Workflows in Action

Individual tools are useful, but the true power of an MCP server lies in the LLM's ability to chain multiple API calls together to accomplish complex goals.

Here are two real-world workflows demonstrating how ChatGPT navigates Fieldwire's relational data model.

Scenario 1: Daily Site Report and Task Dispatch

A site superintendent wants to review critical issues from the morning walkthrough and assign corrective actions.

"Find the 'Westside Campus' project. Look up all open priority 1 tasks. Create a new task to 'Repair drywall damage in Lobby B', assign it to the same user handling the other drywall tasks, and add a check item to 'Paint to match existing color'."

Step-by-step execution:

1. The agent calls list_all_fieldwire_projects to locate the UUID for "Westside Campus".
2. It calls list_all_fieldwire_project_tasks filtering for priority 1.
3. The LLM analyzes the returned payload to find a task related to drywall and extracts the assignee_id.
4. It calls create_a_fieldwire_project_task with the extracted project_id, the new task name, and the discovered assignee_id.
5. Using the resulting task_id, it calls create_a_fieldwire_task_task_check_item to add the painting requirement.

sequenceDiagram
    participant User as User
    participant Agent as ChatGPT (MCP Client)
    participant Truto as Truto MCP Server
    participant Upstream as Fieldwire API

    User->>Agent: "Find project, check tasks, create new punch item"
    Agent->>Truto: call tool: list_all_fieldwire_projects
    Truto->>Upstream: GET /api/v3/projects
    Upstream-->>Truto: project data
    Truto-->>Agent: JSON context
    Agent->>Truto: call tool: list_all_fieldwire_project_tasks
    Truto->>Upstream: GET /api/v3/projects/{id}/tasks
    Upstream-->>Truto: tasks payload
    Truto-->>Agent: JSON context
    Agent->>Truto: call tool: create_a_fieldwire_project_task
    Truto->>Upstream: POST /api/v3/projects/{id}/tasks
    Upstream-->>Truto: 201 Created (task_id)
    Truto-->>Agent: JSON context
    Agent->>Truto: call tool: create_a_fieldwire_task_task_check_item
    Truto->>Upstream: POST /api/v3/projects/{id}/tasks/{task_id}/check_items
    Upstream-->>Truto: 201 Created
    Truto-->>Agent: JSON context
    Agent-->>User: "Task created and assigned. Checklist added."

Scenario 2: RFI Generation and Blueprint Review

A project manager needs to log a discrepancy between the architectural plans and the site conditions.

"Check the open RFIs on the 'Downtown Highrise' project to see if anyone has asked about the plumbing chase on floor 12. If not, create a new RFI asking for clarification on the pipe routing."

Step-by-step execution:

1. The agent calls list_all_fieldwire_projects to resolve the project UUID.
2. It calls list_all_fieldwire_project_rfis and parses the list of questions.
3. Detecting no existing inquiries about the floor 12 plumbing chase, the agent decides to proceed.
4. It calls create_a_fieldwire_project_rfi with the project UUID, formatting the question intelligently based on standard RFI practices.
5. The agent returns the new RFI number and status to the user.

Security and Access Control

Exposing an enterprise construction management platform to an autonomous AI agent requires strict guardrails. Truto's MCP architecture enforces security at the infrastructure layer, independent of the LLM's prompt instructions.

• Method Filtering (methods): You can restrict the MCP server token to specific HTTP verbs. Setting methods: ["read"] ensures the agent can query tasks and RFIs but physically cannot create, update, or delete records, regardless of user prompts.
• Tag Grouping (tags): Fieldwire's vast API surface is categorized in Truto. By passing tags: ["rfis"], you generate a specialized server that only exposes RFI-related endpoints, preventing the agent from accidentally modifying accounting data or user roles.
• Secondary Authentication (require_api_token_auth): By default, the MCP server URL acts as a bearer token. For higher security, enabling this flag requires the client to pass a valid Truto API token in the headers, adding an explicit identity check.
• Ephemeral Servers (expires_at): You can assign an ISO datetime to automatically terminate the MCP server. This is critical for generating temporary AI agent sessions for contractors or temporary workflow runs.
• Zero Integration Code: Truto maps the flat JSON-RPC input namespace intelligently to Fieldwire's query and body schemas, enforcing required properties at the boundary before the request ever touches the upstream API.

Wrap-Up

Building an intelligent agent that can navigate the realities of construction software - offline sync tokens, flattened blueprints, and strictly enforced task hierarchies - used to require a dedicated integrations team. By utilizing an auto-generated MCP server, you abstract away the API boilerplate entirely.

Your engineers can focus on prompt engineering, agent orchestration, and business logic, while Truto handles the OAuth token lifecycle, protocol translation, and strict boundary security.

Connecting Fieldwire to ChatGPT transforms it from a static database into an active participant in your project management workflows.