---
title: "Connect Hover to Claude: Sync 3D CAD Exports and Blueprint Jobs"
slug: connect-hover-to-claude-sync-3d-cad-exports-and-blueprint-jobs
date: 2026-11-04
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "Learn how to connect Hover to Claude using a managed MCP server. Automate 3D property models, blueprint uploads, and CAD exports with AI agent tool calling."
tldr: "Connect Hover to Claude via Truto's managed MCP server to automate 3D measurements, blueprint uploads, and CAD exports. Generate tools dynamically with zero infrastructure overhead."
canonical: https://truto.one/blog/connect-hover-to-claude-sync-3d-cad-exports-and-blueprint-jobs/
---

# 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](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [/connect-hover-to-chatgpt-manage-property-captures-and-measurements/](https://truto.one/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/](https://truto.one/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.

> Want to give your AI agents secure, authenticated access to Hover and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Hover API

A custom MCP server is a self-hosted integration layer. While the open [MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) 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](https://truto.one/integrations/detail/hover).

## 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](https://truto.one/connect-wix-to-claude-automate-blogs-bookings-and-messaging/). 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.

```mermaid
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`:

```bash
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`:

```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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) 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](https://truto.one/connect-shiftcare-to-claude-sync-billing-payments-and-compliance/).
*   **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.

> Ready to automate Hover and 100+ other B2B SaaS platforms? Let's talk about Truto's Managed MCP.
>
> [Talk to us](https://truto.one/book-a-demo/)