Connect CompanyCam to ChatGPT: Manage projects and site visuals

If you need to connect CompanyCam to ChatGPT to automate site documentation, manage project lifecycles, or orchestrate field checklists, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and CompanyCam's REST 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.

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

Giving a Large Language Model (LLM) read and write access to a field-first documentation platform like CompanyCam is a massive engineering challenge. You have to handle complex relational data payloads, map dynamic content types to MCP tool definitions, and deal with polymorphic media uploads. Every time the vendor adds a new project attribute or updates a schema, your custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the CompanyCam API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against CompanyCam's specific API quirks is exceptionally painful.

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

Asynchronous Checklist Templates

CompanyCam relies heavily on checklists to standardize field work. However, when you instantiate an advanced checklist from a template on a project, the API responds asynchronously. The checklist is returned immediately but with an is_populating: true flag, meaning its field tree is not yet available. If your AI agent immediately tries to update fields or assign users to a checklist it just created, the API will reject the request. Your MCP server or agent logic must be smart enough to handle this async job state and poll or wait before mutating the checklist.

Two-Step Binary Upload Pipelines

LLMs are great at generating text, but when a user asks ChatGPT to "upload a photo to the Smith project," you hit a wall. CompanyCam requires a multi-step upload process for local binary files: you must first call uploads.create to generate a short-lived presigned S3 URL, compute the base64-encoded MD5 checksum of the bytes, PUT the bytes to S3, and finally call project_photos.create with the resulting upload_id. Designing MCP tools that instruct an LLM on how to orchestrate this binary upload flow - or hiding that complexity behind a proxy wrapper - requires significant custom logic.

Strict Cursor Pagination Semantics

CompanyCam enforces strict cursor-based pagination across almost all list endpoints (projects, photos, checklists). Unlike offset pagination where an LLM can easily guess page=2, cursor tokens are opaque strings. LLMs notoriously struggle with passing cursor strings back natively without hallucinating or modifying them. Truto's dynamically generated MCP tools automatically inject explicit schema instructions for the next_cursor property, strictly instructing the LLM to pass the token back exactly as received, preventing pagination loops and hallucinated parameters.

CompanyCam to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the CompanyCam API, follow these steps.

What you need:

• A Truto account with API access.
• A CompanyCam account (manager or admin role recommended for full access).
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available (or a local MCP client for testing).

Step 1: Connect CompanyCam as an Integrated Account

In the Truto dashboard, open Integrated Accounts -> New Integrated Account, pick CompanyCam, and run the OAuth flow. Truto securely stores the refresh token and refreshes access tokens shortly before they expire. Your AI agent never has to deal with expired credentials or OAuth refresh loops.

Step 2: Generate a CompanyCam MCP Server

Once connected, you need to generate the MCP server URL. This URL is scoped specifically to the connected CompanyCam account and contains a cryptographic token for routing and authentication. You can do this via the Truto UI or the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your CompanyCam connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name, allowed methods like read or write, specific tags).
5. Click save and copy the generated MCP server URL.

Method B: Via the API You can programmatically generate the server URL by making a POST request. First, grab your integrated_account_id from the dashboard or via the /integrated-account endpoint.

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": "CompanyCam for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["projects", "photos", "checklists"]
    }
  }'

The response contains a url field resembling https://api.truto.one/mcp/<token>. Treat this URL like a secret - it carries both routing instructions and authentication.

Step 3: Register the MCP Server

Now, connect this URL to your AI client.

Method A: Via the ChatGPT UI

1. In ChatGPT, click your profile picture and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP support is behind this flag).
3. Under MCP servers / Custom connectors, add a new server.
4. Name: "CompanyCam (Truto)"
5. Server URL: Paste the Truto MCP URL you generated in Step 2.
6. Save. ChatGPT will immediately connect, perform the JSON-RPC handshake, and discover the CompanyCam tools.

(Note: If you are using Claude Desktop instead, navigate to Settings -> Integrations -> Add MCP Server, paste the URL, and click Add.)

Method B: Via Manual Config File (for local clients or Cursor) If you are using a local agent framework or an editor like Cursor, you can register the server using the standard MCP SSE transport command in your configuration file (e.g., claude_desktop_config.json or cursor MCP settings).

{
  "mcpServers": {
    "companycam-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_TOKEN_HERE>"
      ]
    }
  }
}

Security and Access Control

Exposing an enterprise system like CompanyCam to an autonomous AI agent requires strict guardrails. Truto provides four native security mechanisms directly on the MCP server config:

• Method Filtering (config.methods): Restrict the server to safe operations. Setting methods: ["read"] ensures the LLM can only query data (e.g., list projects, get photos) and cannot create, update, or delete records, regardless of its prompt instructions.
• Tag Filtering (config.tags): Scope the agent's context to specific domains. For example, tags: ["projects"] will expose only project-related tools, hiding user administration or billing tools entirely.
• API Token Auth (require_api_token_auth): When set to true, possessing the MCP URL is no longer enough. The client must also pass a valid Truto API token in the Authorization header, adding a strict secondary layer of authentication.
• Expiration (expires_at): Set a TTL (Time-To-Live) on the MCP server. Useful for granting temporary access to contractors or short-lived AI agent tasks. Once expired, the server URL instantly revokes access and cleans up all associated tokens.

Hero Tools for CompanyCam

Truto automatically generates tools from CompanyCam's documented API resources. Below are the highest-leverage tools exposed to your AI agent for project and visual management.

create_a_company_cam_project

Creates a new project or updates an existing one if a project with the same name and address already exists (find-or-update logic). Essential for initializing a job site before attaching media or checklists.

"I need to start a new job in CompanyCam. Create a project called 'Downtown Roof Repair' at 123 Main St, Austin, TX. If it already exists, just make sure the status is set to active."

create_a_company_cam_project_photo

Uploads a photo to a specific project. It accepts metadata like captured timestamps, descriptions, and jobsite coordinates. If supplying an external image, the LLM can pass a public photo.uri which CompanyCam will download natively.

"Upload this roof inspection image URL to the 'Downtown Roof Repair' project. Add the description 'Shingle damage on the north side' and tag it as 'inspection'."

list_all_company_cam_photos

Queries photos across the entire company or a specific project. This tool supports complex filtering, allowing the agent to find specific visual evidence based on tags, dates, or creator IDs.

"Find all photos taken in the last 7 days tagged with 'safety hazard' across all active projects."

create_a_company_cam_project_advanced_checklists_from_template

Instantiates an advanced checklist on a project using a predefined company template. Because this populates asynchronously, the LLM receives an is_populating: true flag and a job ID to track.

"Start a 'Pre-Install Safety Audit' checklist on the Smith residence project using template ID 88392."

get_single_company_cam_project_advanced_checklist_by_id

Fetches the deep, nested structure of an advanced checklist, including its sections, individual fields, live completion progress, and URLs for any photos or videos attached as evidence to specific checklist items.

"Get the details of checklist ID 99281 on the Smith project and tell me which specific safety questions have not been completed yet."

create_a_company_cam_project_document

Attaches non-photo documents (PDFs, text files, permits) to a project. Like photos, this fires asynchronous processing webhooks upon completion.

"Attach this building permit PDF URL to the active project for 456 Elm Street."

To view the complete inventory of available tools and their JSON schemas, visit the CompanyCam integration page.

Workflows in Action

Here is how these MCP tools combine to automate real-world CompanyCam workflows using natural language.

Workflow 1: Site Inspection & Photographic Evidence

Persona: Field Engineer / Quality Assurance

"Start a new site inspection for 'Plaza Remodel' at 789 Broadway. If the project isn't there, create it. Then, upload this image URL showing the exposed wiring, tag it 'critical', and attach the 'Electrical Rough-in' checklist template to the project."

1. The agent calls create_a_company_cam_project passing the name and address. The API utilizes find-or-update logic and returns the project_id.
2. The agent calls create_a_company_cam_project_photo using the project_id, the provided image URL, and the tag array ["critical"].
3. The agent calls list_all_company_cam_advanced_checklist_templates to search for a template matching "Electrical Rough-in" to get its ID.
4. The agent calls create_a_company_cam_project_advanced_checklists_from_template to attach the checklist to the project.

Result: The user gets a confirmation that the project is active, the critical evidence is logged, and the compliance checklist is queued for the field team to complete.

sequenceDiagram
  participant User as User Prompt
  participant Agent as AI Agent (ChatGPT)
  participant MCP as Truto MCP Server
  participant CC as CompanyCam API

  User->>Agent: "Start inspection, upload photo, add checklist"
  Agent->>MCP: "Call create_a_company_cam_project"
  MCP->>CC: "POST /v2/projects"
  CC->>MCP: "Returns project_id: 1001"
  Agent->>MCP: "Call create_a_company_cam_project_photo"
  MCP->>CC: "POST /v2/projects/1001/photos"
  CC->>MCP: "Returns photo URL data"
  Agent->>MCP: "Call create_a_company_cam_project_advanced_checklists_from_template"
  MCP->>CC: "POST /v2/projects/1001/advanced_checklists"
  CC->>MCP: "Returns is_populating: true"
  Agent->>User: "Inspection created, photo logged, checklist attached."

Workflow 2: Project Handoff & Audit

Persona: Project Manager

"Check the 'Smith Residence' project. I need to know if the final walk-through checklist is complete. If it is, pull the latest 3 photos tagged 'completed' and generate a summary report."

1. The agent calls list_all_company_cam_project_search_results with the query "Smith Residence" to get the project_id.
2. The agent calls list_all_company_cam_project_advanced_checklists to find the active checklists on that project and identify the one named "Final Walk-through".
3. The agent calls get_single_company_cam_project_advanced_checklist_by_id to inspect the nested field tree and verify that all required items have answers and completion timestamps.
4. If complete, the agent calls list_all_company_cam_project_photos filtering by the project ID and the tag "completed", requesting a limit of 3.
5. The agent synthesizes the checklist status and photo URLs into a natural language handoff summary.

Result: The Project Manager receives a verified status report with direct links to photographic evidence, saving them from manually hunting through the CompanyCam UI.

Handling Rate Limits and Resiliency

When orchestrating aggressive multi-step tool calls, AI agents can easily hit third-party API rate limits. It is critical to understand how this is handled architecturally.

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

Connect CompanyCam to Your AI Agents Today

Building a custom integration to manage CompanyCam's async templates, binary uploads, and strict pagination requires weeks of engineering effort. Maintaining it as the API evolves requires even more.

By leveraging Truto, you can generate a secure, authenticated MCP server dynamically from existing API documentation. With built-in method filtering, tag scoping, and automatic JSON schema enhancement for pagination, your AI agents get exactly the context they need to operate safely and effectively.

Stop wrestling with API boilerplate and start automating field operations.