Connect Hover to ChatGPT: Manage Property Captures and Measurements

If you want to connect Hover to ChatGPT so your AI agents can orchestrate 3D property captures, pull precise roof measurements, and automate contractor workflows, you need a Model Context Protocol (MCP) server. If your team uses Claude, check out our guide on connecting Hover to Claude or explore our broader architectural overview on connecting Hover to AI Agents.

Giving a Large Language Model (LLM) read and write access to Hover's ecosystem of 3D modeling and measurement APIs is a massive engineering challenge. You either spend weeks building, hosting, and maintaining a custom proxy to translate ChatGPT's JSON arguments into Hover'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 Hover, connect it natively to ChatGPT, and execute complex property capture workflows using natural language.

The Engineering Reality of the Hover API

Building an MCP server that works reliably with Hover goes beyond translating standard REST operations. Hover's API has several architectural quirks that will cause naive LLM agents to hallucinate or fail if not handled correctly by the underlying proxy.

The Org-Level Auth and Acting User Paradigm

Unlike many SaaS platforms where an OAuth token represents a specific user's identity, Hover's access tokens belong to the organization. This means standard CRUD endpoints lack the context of who is performing the action. To solve this, virtually every write endpoint and many read endpoints in the Hover API require you to explicitly pass a current_user_id or current_user_email representing an admin user. If your MCP server doesn't inject this context, ChatGPT will constantly hit validation errors, failing to execute tasks like creating capture requests or upgrading deliverables.

Asynchronous State Machines for 3D Artifacts

A standard LLM instinct is to create a job and immediately ask for its 3D measurements or CAD exports. Hover does not work this way. Reconstructing a house into a 3D model takes time. A model moves through multiple states (e.g., uploading, processing, complete). If ChatGPT calls list_all_hover_measurements_json before a model's state is complete, the API will throw an error. Your prompt engineering and tool descriptions must strictly dictate that the LLM checks the job state via get_single_hover_job_by_id before attempting to pull artifacts.

Multipart Form-Data and Complex Schemas

Creating a Hover job directly requires a complex multipart/form-data payload containing deep nested objects (e.g., job [location_line_1]). Standard LLM tool calling prefers flat JSON. Hover explicitly recommends using the Capture Request endpoints (create_a_hover_capture_request) instead of direct job creation for this exact reason. A robust MCP server abstracts this complexity by exposing the Capture Request workflow, keeping the LLM's required payload clean and deterministic.

Hover to ChatGPT Quickstart Guide

To get ChatGPT connected to Hover, you need to generate a self-contained MCP server URL that handles routing, authentication, and schema translation. Here is exactly how to do it using Truto.

What you need:

• A Truto account with API access.
• A Hover organization admin who can authorize the OAuth connection.
• A ChatGPT Plus, Pro, Team, or Enterprise account with Developer mode enabled.

Step 1: Connect Hover as an Integrated Account

Inside the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select Hover, and complete the OAuth flow. Truto handles securely storing the credentials and automatically refreshing the access token in the background so ChatGPT is never disrupted by an expired session.

Step 2: Generate the Hover MCP Server

Truto derives MCP tools dynamically from the API documentation. You can generate a dedicated MCP server scoped to your connected Hover account using either the UI or the API.

Method 1: Via the Truto UI

1. Navigate to the Integrated Account page for your Hover connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server (e.g., set allowed methods to "read" and "write").
5. Copy the generated MCP Server URL.

Method 2: Via the Truto API Alternatively, you can provision the server programmatically. Grab your integrated_account_id and make a POST request to Truto:

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": "Hover ChatGPT Integration",
    "config": {
      "methods": ["read", "write"],
      "tags": ["jobs", "capture_requests", "measurements"]
    }
  }'

The response will contain a url field like https://api.truto.one/mcp/<token>. This URL acts as the secure endpoint for ChatGPT to discover and call Hover tools.

Step 3: Connect the MCP Server to ChatGPT

You can connect the newly created MCP server to ChatGPT using the user interface or a manual config file.

Method A: Via the ChatGPT UI

1. In ChatGPT, open Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on.
3. Under Custom Connectors, click Add new server.
4. Name it "Hover (Truto)" and paste your Truto MCP URL into the Server URL field.
5. Click Save. ChatGPT will immediately connect, handshake, and ingest the available Hover tools.

Method B: Via Manual Config File If you are deploying a custom agent or running ChatGPT locally via the macOS desktop app (when supported), you can configure the connection using a JSON file. Use the Server-Sent Events (SSE) transport adapter:

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

Hover Hero Tools for AI Agents

By leveraging the integration's schemas, Truto auto-generates dozens of granular tools. Here are the highest-leverage operations for automating Hover workflows via ChatGPT.

Create a Capture Request

Tool name: create_a_hover_capture_request This tool initiates a property capture by creating a draft job and sending an SMS or email invitation to a homeowner or field rep to perform the capture using the Hover app.

"Send a capture request to John Doe at john.doe@example.com for the property at 123 Main St, Austin, TX. Set myself (user ID 98765) as the current_user_id."

Show Job Details

Tool name: get_single_hover_job_by_id This is the critical polling endpoint. It returns the entire payload for a job, including its address, customer data, and the state of its associated 3D models. Agents must use this to verify a model is "complete" before pulling measurements.

"Check the status of Hover job 40593. Tell me if the associated 3D model is in the 'complete' state yet."

Get JSON Measurements

Tool name: list_all_hover_measurements_json Extracts detailed structural measurements (e.g., roof square footage, siding area, window counts) for a given model_id in structured JSON format. This allows the LLM to perform mathematical calculations or populate external quoting engines.

"Pull the full_json measurements for model ID 88392. Summarize the total roof surface area and the total linear feet of ridges and hips."

Create Deliverable Change Request

Tool name: create_a_hover_deliverable_change_request Allows the AI agent to programmatically upgrade a model's deliverable tier - for example, upgrading a basic 'Capture Only' model to 'Complete' or 'Roof Only' based on a contractor's shifting requirements.

"Upgrade the deliverable for model ID 88392 to 'Complete' (deliverable ID 3). Use my user ID 98765 for the authorization."

Get Roof RWF (Roof Waste Factor)

Tool name: list_all_hover_roof_waste_factors A highly specialized endpoint that feeds structural measurements into Hover's algorithm to return a recommended roof waste percentage. The AI can pull the measurements, feed them into this tool, and generate highly accurate material estimates.

"Calculate the roof waste factor using 2500 roof_square_feet, 120 step_flashing_linear_feet, 150 rakes_linear_feet, 40 valleys_linear_feet, and 80 hips_linear_feet."

Blueprint Upload (Build All)

Tool name: create_a_hover_blueprint This tool allows the agent to submit a PDF, DWG, or DXF file (via URL) and instruct Hover to reconstruct all elevations found on the blueprint into 3D models.

"Upload the architectural plans at https://storage.com/plans.pdf to Hover as a new blueprint job named 'Smith Residence New Build'. Use the 'build_all' workflow."

For a complete list of endpoints, including webhook registration, user provisioning, and instant design image extraction, review the Hover integration page.

Workflows in Action

When you combine ChatGPT's reasoning capabilities with Truto's standardized Hover MCP tools, complex multi-step processes become natural language conversations.

Scenario 1: Dispatching a Capture and Tracking Status

A sales coordinator needs to initiate a site survey for a new prospect and monitor it until the 3D model is fully processed.

"Create a Hover capture request for a new lead, Sarah Connor (sarah@example.com), at 456 Elm St. Once sent, store the job ID. Check the job status and let me know if the model is complete yet."

1. ChatGPT calls create_a_hover_capture_request passing the address and homeowner details.
2. Hover returns the newly created job ID and capture request identifier.
3. ChatGPT calls get_single_hover_job_by_id using the job ID to inspect the state of the associated models.
4. The agent reports back to the user that the request was successfully sent, but the model is currently in the "draft" state awaiting customer capture.

sequenceDiagram
  autonumber
  participant User as User
  participant ChatGPT as "ChatGPT Agent"
  participant Truto as "Truto MCP Server"
  participant Hover as "Hover API"

  User->>ChatGPT: "Create a capture request for Sarah Connor..."
  ChatGPT->>Truto: call tool: create_a_hover_capture_request
  Truto->>Hover: POST /api/v2/capture_requests
  Hover-->>Truto: Capture request created (job_id: 101)
  Truto-->>ChatGPT: Return job metadata
  ChatGPT->>Truto: call tool: get_single_hover_job_by_id(id: 101)
  Truto->>Hover: GET /api/v2/jobs/101
  Hover-->>Truto: Job details (state: draft)
  Truto-->>ChatGPT: Return model state
  ChatGPT-->>User: "Request sent. Job 101 is currently in 'draft' state."

Scenario 2: Automated Roof Waste Estimation

An estimator wants to calculate the exact waste factor for a completed roof measurement to generate an accurate material order.

"Look up the measurements for model ID 99201. Extract the roof square footage, step flashing, rakes, valleys, and hips. Pass those metrics into the Roof Waste Factor algorithm and tell me the recommended waste percentage."

1. ChatGPT calls list_all_hover_measurements_json for model ID 99201.
2. The agent parses the returned JSON payload, extracting the exact linear feet and area integers from the roof_facets and ridges_hips arrays.
3. ChatGPT calls list_all_hover_roof_waste_factors, injecting those precise measurements as query parameters.
4. The agent presents the final algorithm-recommended waste percentage to the estimator.

Scenario 3: Bulk Blueprint Processing

A project manager receives a batch of architectural PDFs and needs to convert them into Hover jobs without manual data entry.

"I have a new housing development blueprint at https://files.example.com/lot-42.pdf. Create a Hover blueprint job named 'Lot 42 - Riverside' using the build_all workflow. Use my ID 55432 as the acting user."

1. ChatGPT calls create_a_hover_blueprint.
2. The agent maps the provided URL to the job.file_attachments_attributes [].url array and hardcodes the workflow parameter to build_all.
3. Truto formats the multipart payload correctly and submits it to Hover.
4. The agent confirms the blueprint has been queued for processing and returns the new Job ID.

Security and Access Control

When deploying AI agents in enterprise environments, security is non-negotiable. Truto's MCP servers provide granular controls to limit what ChatGPT can do inside your Hover organization.

• Method filtering: Enforce read-only access by configuring the MCP server with methods: ["read"]. This prevents the LLM from accidentally deleting jobs or spending money on deliverable upgrades.
• Tag filtering: Restrict the agent's scope to specific domains using tags: ["measurements", "jobs"]. This prevents the LLM from accessing user administration endpoints.
• Extra Authentication (require_api_token_auth): For strict environments, Truto allows you to require a valid API token in the HTTP Authorization header of the MCP connection, ensuring that possession of the MCP URL alone is not enough to execute tools.
• Time-to-live (expires_at): You can generate temporary MCP servers with an exact expiration date, perfect for granting a contractor's AI agent short-term access to a specific property portfolio.

Handling Hover API Rate Limits

Large models execute tasks rapidly. When ChatGPT chains together multiple requests - like listing 50 jobs and then querying the details for each one - you will inevitably encounter API rate limits.

Truto operates as a transparent proxy. It does not silently absorb rate limit errors, apply exponential backoff, or implement infinite retries on your behalf. When the Hover API rejects a request due to volume, Truto immediately passes that HTTP 429 status code back to ChatGPT via the MCP result object.

Crucially, Truto normalizes Hover's rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). This predictable format allows your custom agent framework, or ChatGPT itself, to read the reset time and properly pause execution, ensuring your automation remains robust without locking up system threads.

Automate Property Captures Intelligently

Connecting Hover to ChatGPT unlocks massive operational efficiency for construction, insurance, and solar companies. By leveraging Truto's managed MCP servers, you bypass the friction of multipart form-data parsing, binary artifact retrieval, and complex acting-user authentication schemas. Instead of wrestling with custom integration code, your engineering team can focus entirely on prompt engineering and workflow design, turning raw 3D measurements into actionable business logic in seconds.