Connect Hover to Claude: Sync 3D CAD Exports and Blueprint Jobs

If your team needs to connect Hover to Claude to automate 3D property models, measurement data syncing, or blueprint job creation, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Hover'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 ChatGPT, check out our guide on /connect-hover-to-chatgpt-manage-property-captures-and-measurements/ or explore our broader architectural overview on /connect-hover-to-ai-agents-automate-estimates-and-inspections/.

Giving a Large Language Model (LLM) read and write access to a specialized 3D modeling and property data ecosystem like Hover is an engineering challenge. You have to handle organization-level OAuth 2.0 token lifecycles, map massive CAD export JSON schemas to MCP tool definitions, and deal with Hover's asynchronous job states. Every time Hover updates an endpoint or adds a new measurement version, 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 Hover, connect it natively to Claude Desktop, and execute complex property measurement workflows using natural language.

The Engineering Reality of the Hover 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, the reality of implementing it against specialized B2B APIs is painful. Hover is built to manage physical property captures, complex 3D reconstructions, and multi-format exports. Its API reflects that physical-to-digital complexity.

If you decide to build a custom Hover MCP server, here are the specific integration challenges you will face:

Organization Tokens vs Acting Users Hover's access tokens are issued at the organization level, not the user level. However, many endpoints strictly require an acting user context to track who initiated a capture or requested an upgrade. This means nearly every write operation requires passing a current_user_id or current_user_email (which must belong to an admin user mapped from the users.list endpoint). An LLM has no context on how to fetch and inject this acting user ID. Your integration layer must abstract this mapping so Claude does not have to guess internal user IDs.

Asynchronous Artifact Generation Hover's data model follows a strict hierarchy: Job -> Model (Structure) -> Deliverable -> Artifact. When you create a job or a capture request, the 3D models and measurements are not immediately available. The system goes through states like uploading, processing, and complete. If you try to call list_all_hover_measurements_json or list_all_hover_esx_exports before a model's state is complete, the API will fail. An LLM cannot natively handle this state-machine polling. It needs explicitly defined tools that first check the job status via get_single_hover_job_by_id before attempting to pull CAD files.

Complex Blueprint and File Arrays Uploading a blueprint via the API is not a simple POST request. Endpoints like create_a_hover_blueprint require deeply nested arrays for job.file_attachments_attributes [].url to reference blueprint PDFs or DWG files. Furthermore, Hover supports different processing workflows (build_all vs specify_details), meaning the payload structure changes depending on the intent. Writing manual validation logic to parse an LLM's natural language request into these strict, nested array structures requires significant engineering overhead.

Hero Tools for Hover Automation

Truto automatically generates MCP tools based on the Hover API's documentation and resource schemas. Below are 6 high-leverage hero tools that unlock immediate value for construction, roofing, and insurance workflows.

get_single_hover_job_by_id

This is the foundational tool for Hover integrations. It returns everything about a single job: the address, customer info, capture session, and the associated 3D models (structures). You must use this tool to verify a model's state is complete before fetching measurement artifacts or CAD exports.

"Check the status of job ID 948123. If the model is complete, list the available deliverable types. If not, tell me its current state."

create_a_hover_capture_request

Initiates a Hover property capture by creating a draft job in your organization and sending an invitation (via email or SMS) to a designated user to perform the capture. Because Hover issues organization-level tokens, this tool requires you to specify the current_user_email to act on behalf of a specific admin.

"Create a capture request for a new job at 123 Main St, Austin TX. Send the capture invite to fieldtech@example.com, and log the request under my admin email admin@example.com."

create_a_hover_blueprint

Uploads a blueprint to reconstruct elevations into Hover jobs. This tool covers Hover's blueprint workflows, allowing you to pass external URLs for PDF, DWG, or DXF files. It eliminates manual data entry for estimators scaling from 2D plans to 3D models.

"Upload the blueprint PDF located at https://storage.example.com/plan_a.pdf. Use the build_all workflow to create a new job named 'Smith Residence New Build'."

list_all_hover_measurements_json

Retrieves detailed measurement data for a completed model in JSON format. This tool is critical for programmatic estimation, allowing Claude to extract exact square footages, linear feet of ridges, and pitch data to generate material lists.

"Get the full JSON measurements for model ID 445566. Calculate the total roof square footage and summarize the linear feet of step flashing needed."

list_all_hover_esx_exports

Downloads the Hover 3D model in Xactimate's proprietary ESX file format. This bridges the gap between field capture and insurance adjusting workflows, allowing Claude to pull the specific export URL needed for claims processing.

"Fetch the ESX export for model ID 778899 so I can attach it to our Xactimate claims software."

create_a_hover_deliverable_change_request

Upgrades a model's deliverable programmatically. For example, if a job was initially processed as 'Capture Only' (ID 7), this tool allows the agent to upgrade it to 'Roof Only' (ID 2) or 'Complete' (ID 3) based on changing project requirements.

"Upgrade the deliverable for model ID 112233 to 'Complete' (ID 3). Use my admin email for the current_user_email parameter to authorize the change."

For a complete list of available Hover tools, including their required parameters and JSON schemas, visit the Hover integration page.

Workflows in Action

When you give Claude access to Hover via an MCP server, you move beyond simple chat and into multi-step agentic workflows. Here are two concrete examples of how operations teams use these tools.

Workflow 1: Estimator Blueprint Automation

Estimators deal with a high volume of 2D plans that need to be modeled for accurate bidding. Claude can orchestrate the upload and status tracking.

"Upload this set of blueprints (https://files.example.com/lot42.pdf) as a new Hover job called 'Lot 42 Subdivision'. Use the build_all workflow. Then check the job status and let me know when it moves to processing."

1. create_a_hover_blueprint: Claude submits the URL, job name, and workflow parameter, tagging the correct current_user_email.
2. get_single_hover_job_by_id: Claude takes the newly returned Job ID and queries it to confirm the upload succeeded and the state has progressed to uploading or processing.

Result: The estimator saves 15 minutes of manual file handling and UI navigation. Claude confirms the job is in Hover's processing queue.

Workflow 2: Automated Material Takeoffs

Once a field technician completes a capture, production teams need exact measurements to order materials. Claude can pull the data and calculate the order.

"Check the status of job ID 884422. If the roof model is complete, pull the JSON measurements and calculate the total squares of shingles needed, adding a 10% waste factor."

1. get_single_hover_job_by_id: Claude fetches the job to ensure the state of the structure is complete and grabs the model_id.
2. list_all_hover_measurements_json: Claude fetches the raw measurement data for that specific model_id.
3. Internal Calculation: Claude parses the JSON, finds roof_facets.area, converts square feet to roofing squares (divide by 100), and applies the 10% waste factor.

Result: The user gets an immediate, math-checked material takeoff derived directly from Hover's 3D capture, ready to be sent to the supplier.

sequenceDiagram
    participant User as End User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Hover as Hover API

    User->>Claude: "Check job 884422 and calculate roofing squares"
    Claude->>MCP: Call get_single_hover_job_by_id(id=884422)
    MCP->>Hover: GET /api/v2/jobs/884422
    Hover-->>MCP: Job State (Complete), Model ID: 9911
    MCP-->>Claude: Job Details JSON
    Claude->>MCP: Call list_all_hover_measurements_json(model_id=9911)
    MCP->>Hover: GET /api/v2/models/9911/measurements.json
    Hover-->>MCP: Measurements Data
    MCP-->>Claude: Measurement JSON
    Claude-->>User: "You need 32 squares of shingles (including 10% waste)."

Building the MCP Server

Truto manages the OAuth lifecycle and dynamically generates tool schemas based on the Hover API documentation. You can spin up an MCP server for Hover in two ways.

Method 1: Via the Truto UI

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Hover account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (name, allowed methods, tags, and expiry).
5. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For teams building programmatic AI agent platforms, you can generate MCP servers on the fly via the REST API. Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Hover Estimator Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["jobs", "measurements"]
    }
  }'

The API will return a JSON object containing the secure url. This URL is all your client needs to connect.

Connecting to Claude

Once you have your Truto MCP URL, connecting it to an MCP client is straightforward. The URL contains a cryptographic token that handles authentication - no extra headers are needed unless configured otherwise.

Method 1: Via the Claude UI (Desktop/Web)

If you are using Claude's native application or a supported enterprise UI:

1. Open Settings -> Integrations -> Add MCP Server (or Settings -> Connectors -> Add in ChatGPT).
2. Paste the Truto MCP URL.
3. Click Add. Claude will immediately call the tools/list protocol method and discover all available Hover tools.

Method 2: Via Manual Config File (claude_desktop_config.json)

For developers using the Claude Desktop app locally, you can wire up the server by editing your configuration file. Because Truto MCP servers operate over HTTPS using Server-Sent Events (SSE), you use the official MCP SSE client.

Add this to your claude_desktop_config.json:

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

Restart Claude Desktop. The Hover tools will now appear as an available integration.

Security and Access Control

Giving an AI agent access to your production Hover environment requires strict guardrails. Truto's MCP architecture provides several layers of security to prevent unauthorized data access or destructive actions.

• Method Filtering: Restrict an MCP server to read-only operations by passing methods: ["read"]. The agent will be able to fetch jobs and measurements but physically cannot create blueprints or upgrade deliverables.
• Tag Filtering: Scope the server to specific domains. Pass tags: ["jobs"] to ensure the agent only sees tools related to job tracking, hiding user administration or billing endpoints.
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer sufficient. The connecting client must also pass a valid Truto API token in the Authorization header, ensuring only authenticated internal systems can invoke tools.
• Automatic Expiry: Use the expires_at property to grant temporary access. If you are spinning up an agent to run a batch analysis of week-old captures, set the server to self-destruct after 24 hours.

Handling Rate Limits

Automated workflows can generate significant API traffic. It is important to note that Truto does not retry, throttle, or apply backoff logic on rate limit errors. When the upstream Hover API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the calling agent.

To help your agents gracefully recover, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your AI agent or framework is responsible for reading these headers and implementing its own retry or backoff logic before calling the tool again.

Summary

Connecting Hover to Claude via a custom MCP server means wrestling with organization-level tokens, asynchronous job states, and massive CAD data payloads. By leveraging Truto's managed MCP architecture, you offload the authentication, schema mapping, and infrastructure maintenance.

With dynamic, documentation-driven tool generation, your agents get immediate, secure access to Hover's native API, allowing your estimators and field teams to automate 3D modeling workflows through natural language.