---
title: "Connect Procore to ChatGPT: Manage RFIs, Project Budgets, and Punch Items"
slug: connect-procore-to-chatgpt-manage-rfis-project-budgets-and-punch-items
date: 2026-10-13
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Procore to ChatGPT using Truto's auto-generated MCP servers. Automate RFIs, track project budgets, and manage punch items."
tldr: "Connect Procore to ChatGPT via a Model Context Protocol (MCP) server to orchestrate RFIs, daily logs, and budgets. This guide covers setup, API nuances, and tool-calling workflows."
canonical: https://truto.one/blog/connect-procore-to-chatgpt-manage-rfis-project-budgets-and-punch-items/
---

# Connect Procore to ChatGPT: Manage RFIs, Project Budgets, and Punch Items


If you need to connect Procore to ChatGPT to automate construction management workflows, track project budgets, or orchestrate RFI and Punch Item lifecycles, you need a [Model Context Protocol (MCP) server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Procore's complex REST APIs. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/).

If your team uses Claude, check out our guide on [connecting Procore to Claude](https://truto.one/connect-procore-to-claude-control-daily-logs-crews-and-project-webhooks/) or explore our broader architectural overview on [connecting Procore to AI Agents](https://truto.one/connect-procore-to-ai-agents-automate-checklists-sub-jobs-and-rfi-flows/).

Giving a Large Language Model (LLM) read and write access to a [heavy, hierarchical system like Procore](https://truto.one/connect-ai-agents-to-netsuite-sap-via-mcp-the-2026-architecture-guide/) is a significant engineering challenge. You have to handle rigid contextual scoping, massive nested payloads, and strict rate limits. Every time an agent hallucinates a parameter or misses a required header, the operation fails. 

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

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Procore API

A [custom MCP server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Procore's highly specific API is exceptionally painful. 

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

### Mandatory Hierarchical Scoping
Unlike flat SaaS platforms where you can simply query `/users` or `/tickets`, almost every Procore endpoint requires contextual scoping via a `project_id` or `company_id`. Some endpoints require this in the query string, others in the payload body, and others via the mandatory `Procore-Company-Id` HTTP header. If you are building custom MCP tools, you must write schema parsers that explicitly teach the LLM to fetch the `project_id` first, and then inject it into subsequent requests. Truto handles this automatically by explicitly marking these IDs as required fields in the dynamically generated [JSON Schema for each tool](https://truto.one/best-unified-api-for-llm-function-calling-ai-agent-tools-2026/).

### Strict Rate Limiting and Truto's Passthrough Approach
Procore enforces aggressive concurrency limits and rate limits on API consumption. A common mistake when building agentic workflows is assuming the integration layer will magically absorb these limits. 

**Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Procore API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your AI agent, LLM framework, or ChatGPT) is entirely responsible for reading these headers and executing its own retry and backoff logic. 

### Polymorphic and Deeply Nested Payloads
When an LLM attempts to create a Punch Item or an RFI, it isn't just sending a string. Procore requires complex nested objects (e.g., trade IDs, location IDs, punch item managers, distribution members). If your MCP server does not provide a flawless, heavily annotated JSON schema to the LLM, the model will hallucinate the payload structure and fail the request. Truto derives these schemas directly from Procore's documentation and resources, ensuring the LLM knows exactly what nested objects are required.

## Procore to ChatGPT Quickstart Guide

If you want the fastest path from a fresh Truto account to ChatGPT calling the Procore API, follow these steps. Deeper architecture and security details live in the sections below.

**What you need:**
- A Truto account with API access.
- A Procore user account or Service Account with the necessary permissions to approve the OAuth consent.
- A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

### Step 1: Connect Procore as an Integrated Account

In the Truto dashboard, navigate to **Integrated Accounts -> New Integrated Account**, select Procore, and execute the OAuth flow. Truto will securely store the refresh token and automatically refresh access tokens shortly before they expire. ChatGPT will never have to deal with an expired credential.

### Step 2: Generate a Procore MCP Server

You can generate an MCP server for this specific Procore connection using either the Truto UI or the API.

**Method A: Via the Truto UI**
1. Navigate to the integrated account page for your Procore connection in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., name, allowing only `read` methods, or filtering by `rfis` tags).
5. Copy the generated MCP server URL. Treat this URL like a secret.

**Method B: Via the API**
You can programmatically scope an MCP endpoint to the account by sending a POST request to Truto:

```bash
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": "Procore for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["rfis", "projects", "budgets"]
    }
  }'
```

The response will return a `url` field formatted as `https://api.truto.one/mcp/<token>`. This single URL handles routing, authentication, and tool generation.

### Step 3: Connect the MCP Server to ChatGPT

Now, provide the MCP server URL to your client. You can do this through the ChatGPT UI or via a manual configuration file for custom clients.

**Method A: Via the ChatGPT UI**
1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode**.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "Procore via Truto") and paste the Truto MCP URL into the Server URL field.
5. Click Save. ChatGPT will immediately connect, perform the protocol handshake, and list the available Procore tools.

**Method B: Via Manual Config File (for CLI / Custom Clients)**
If you are running a custom client or using the MCP CLI, you can connect to the Server-Sent Events (SSE) endpoint using the official MCP package:

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

## Hero Tools for Procore Automation

Truto exposes the entirety of the Procore API as tools, but you should restrict your MCP server to only the resources your agent actually needs. Here are the highest-leverage hero tools for construction workflows.

### list_all_procore_company_projects
This tool lists the Procore projects associated with a company. Because almost every other tool requires a `project_id`, this is the foundational mapping tool the LLM must call first to resolve a project name to an ID.

**Contextual usage:** The LLM will use the `search` or filtering parameters to find a specific project, extract its integer ID, and hold it in context for subsequent operations.

> "Find the project ID for the 'Downtown Tower Expansion' project under my company." 

### list_all_procore_rfis
Retrieves a list of all Requests for Information (RFIs) within a specific project. It returns rich metadata including status, assignees, and the specific questions asked.

**Contextual usage:** Highly useful for triage. The LLM can request this list using `filters [status]=open` or `filters [overdue]=true` to generate daily summary reports.

> "List all open and overdue RFIs for project ID 84729 and summarize the pending questions for the project manager."

### update_a_procore_rfi_by_id
Allows the agent to modify a specific RFI. It can update the status, reassign the RFI, or modify the subject.

**Contextual usage:** Used after the agent analyzes a user's intent to resolve or escalate an RFI. The LLM must pass the `project_id`, the `id` of the RFI, and the updated `rfi` payload object.

> "Update RFI number 42 on the Downtown Tower project. Change its status to 'Resolved' and update the subject to include ' [CLOSED]'."

### create_a_procore_punch_item
Generates a new Punch Item on a project. This requires a complex payload including the name, description, priority, and due date.

**Contextual usage:** Ideal for field teams dictating notes. The LLM parses the natural language description, structures the JSON schema perfectly, and submits the defect to Procore.

> "Create a new high-priority punch item for project 84729. Title: 'Exposed wiring in Lobby'. Description: 'Electrical conduit is exposed near the main elevator bank on floor 1. Needs immediate capping.' Due date is tomorrow."

### list_all_procore_budget_details
Retrieves the highly granular Procore Budget Detail Report for a specific project and budget view. 

**Contextual usage:** The LLM can use this to answer complex financial queries. It returns cost codes, billers, and the current locked status of the budget.

> "Pull the budget details for the Downtown Tower project using budget view ID 12. Check if the budget is locked, and list the top three highest cost types."

### create_a_procore_sub_job
Creates a new Sub Job in Procore, allowing teams to break down costs and scope into smaller, trackable segments.

**Contextual usage:** When an agent is asked to restructure a project plan, it can create a sub job by passing the `project_id` and a `sub_job` payload containing the `name` and `code`.

> "Create a new sub job for project 84729. The name should be 'Phase 2 - Electrical Fit-out' and use the code 'PH2-ELEC'."

To view the complete inventory of Procore tools, schemas, and required parameters, visit the [Truto Procore Integration Page](https://truto.one/integrations/detail/procore).

## Workflows in Action

Here is how an LLM utilizes these tools in sequence to execute multi-step operations.

### Scenario 1: Field Defect to Punch Item Creation

A site superintendent dictates a defect into ChatGPT while walking the site. ChatGPT must resolve the project context and create the structured item.

> "I'm at the Downtown Tower site. The drywall on the east wall of the lobby is cracked. Log a high-priority punch item for this, due by Friday."

**Execution Steps:**
1.  **Tool Call:** `list_all_procore_company_projects` (searching for "Downtown Tower").
2.  **Result:** The server returns `project_id: 84729`.
3.  **Tool Call:** `create_a_procore_punch_item` (passing `project_id: 84729`, `punch_item.name: "Cracked drywall on east wall"`, `punch_item.priority: "High"`).
4.  **Result:** The punch item is created in Procore, returning the new item ID to the user.

```mermaid
sequenceDiagram
    participant User as User
    participant Agent as ChatGPT Agent
    participant MCP as Truto MCP Server
    participant Procore as Procore API

    User->>Agent: "Log a high-priority punch item for<br>Downtown Tower..."
    Agent->>MCP: Call list_all_procore_company_projects<br>(search: Downtown Tower)
    MCP->>Procore: GET /projects?search=...
    Procore-->>MCP: project_id: 84729
    MCP-->>Agent: Returns project data
    Agent->>MCP: Call create_a_procore_punch_item<br>(project_id: 84729, payload: ...)
    MCP->>Procore: POST /projects/84729/punch_items
    Procore-->>MCP: 201 Created (Item ID: 9912)
    MCP-->>Agent: Returns success confirmation
    Agent-->>User: "Punch item #9912 created successfully."
```

### Scenario 2: RFI Triage and Budget Check

A project manager asks ChatGPT to investigate outstanding RFIs and ensure the project budget is not locked before approving changes.

> "Pull all overdue RFIs for the Midtown Complex project. Also, check if that project's budget is currently locked."

**Execution Steps:**
1.  **Tool Call:** `list_all_procore_company_projects` (searching for "Midtown Complex" to get the `project_id`).
2.  **Tool Call:** `list_all_procore_rfis` (passing the `project_id` and `filters [overdue]=true`).
3.  **Tool Call:** `list_all_procore_budget` (passing the `project_id` to check the `locked` boolean status).
4.  **Result:** ChatGPT synthesizes the data and replies: "You have 3 overdue RFIs regarding electrical routing. The budget is currently unlocked, so cost impacts can still be processed."

```mermaid
flowchart TD
    A["User Prompt<br>Check overdue RFIs and Budget"] --> B["ChatGPT Agent"]
    B -->|"1. Get Project ID"| C["Tool:<br>list_all_procore_company_projects"]
    C --> D["Project ID resolved"]
    D -->|"2. Fetch RFIs"| E["Tool:<br>list_all_procore_rfis<br>(filters: overdue)"]
    D -->|"3. Fetch Budget"| F["Tool:<br>list_all_procore_budget"]
    E --> G["Compile Final Response"]
    F --> G
    G --> H["Deliver to User"]
```

## Security and Access Control

Handing an LLM unrestricted access to your construction management platform is a massive security risk. Truto's MCP servers provide strict guardrails that are evaluated dynamically on every request.

*   **Method Filtering:** When generating the server, configure `config.methods` to `["read"]` if you only want the agent to query budgets and read RFIs, preventing any accidental mutations.
*   **Tag Filtering:** Group tools by passing `config.tags` like `["rfis", "punch_items"]`. The server will dynamically drop any tools related to payroll, users, or webhooks, ensuring the agent stays within its permitted operational scope.
*   **Extra Authentication (`require_api_token_auth`):** For enterprise deployments where the MCP URL might be visible in config files, enabling this flag forces the client to pass a valid Truto API token in the `Authorization` header. URL possession alone is no longer enough to invoke tools.
*   **Automatic Expiration (`expires_at`):** You can bind a time-to-live to the server. Truto enforces this via an edge-based distributed expiration layer, ensuring the server instantly stops responding once the timestamp is reached, making it ideal for temporary contractor access or ephemeral agent sessions.

Stop wrestling with undocumented API quirks, strict rate limits, and nested JSON schemas. Truto handles the protocol translation, API normalization, and security constraints so your engineers can focus on building intelligent agent behaviors.

> Ready to connect your AI agents to Procore? Start generating secure, managed MCP servers with Truto today.
>
> [Talk to us](https://truto.one/book-a-demo/)