---
title: "Connect Aurora Solar to Claude: Automate Sales and Site Surveys"
slug: connect-aurora-solar-to-claude-automate-sales-and-site-surveys
date: 2026-07-08
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect Aurora Solar to Claude using a managed MCP server. Automate solar designs, site surveys, and sales proposals with AI without writing custom integration code."
tldr: "Building custom MCP servers for Aurora Solar means dealing with complex nested hierarchies, asynchronous job polling, and strict rate limits. Use Truto to generate a secure, managed MCP server to give Claude read and write access to projects, designs, and sales proposals instantly."
canonical: https://truto.one/blog/connect-aurora-solar-to-claude-automate-sales-and-site-surveys/
---

# Connect Aurora Solar to Claude: Automate Sales and Site Surveys


If you need to connect Aurora Solar to Claude to automate sales proposals, analyze solar designs, or trigger site surveys, 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 Aurora Solar's REST API. 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 [connecting Aurora Solar to ChatGPT](https://truto.one/connect-aurora-solar-to-chatgpt-manage-solar-designs-and-projects/) or explore our broader architectural overview on [connecting Aurora Solar to AI Agents](https://truto.one/connect-aurora-solar-to-ai-agents-scale-solar-ops-and-engineering/).

Giving a Large Language Model (LLM) read and write access to a sprawling enterprise ecosystem like Aurora Solar is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Aurora Solar's specific rate limits and asynchronous job patterns. Every time Aurora updates an endpoint, introduces a new pricing adder model, or deprecates a legacy design object, 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for Aurora Solar, connect it natively to Claude, and execute complex solar sales and engineering workflows using natural language.

## The Engineering Reality of the Aurora Solar 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 Aurora Solar's API is painful. You are not just integrating a standard REST API - you are interfacing with a complex, asynchronous platform designed for 3D modeling, financial quoting, and field operations.

If you decide to build a custom MCP server for Aurora Solar, you own the entire API lifecycle. Here are the specific challenges you will face:

**Asynchronous Job Polling**
Many of Aurora Solar's most critical endpoints - like converting an order to a project (`create_a_aurora_solar_project_creation_run`), triggering AI Roof modeling, or generating proposal PDFs - are asynchronous. The API returns a `202 Accepted` and a job ID. A standard MCP tool call expects a synchronous response. If you expose the raw endpoints to Claude, the LLM will struggle to implement the polling logic required to check the job status repeatedly until it succeeds. You have to build custom orchestration wrappers around these endpoints to handle the polling state.

**Deeply Nested Resource Hierarchies**
Aurora Solar's data model is highly relational and deeply nested. A `Tenant` has `Projects`. A `Project` has `Designs`. A `Design` has `Pricings`, `System Loss Settings`, and `Bill of Materials`. To get the estimated year-1 bill summary for a design, an LLM first needs to query projects, extract the specific project ID, query the designs for that project, extract the design ID, and finally query the design summary. If your MCP tools do not accurately reflect this hierarchy and enforce the required parameters (`tenant_id`, `project_id`, `design_id`), Claude will hallucinate identifiers or make malformed requests.

**Handling Rate Limits and 429 Errors**
Aurora Solar enforces API rate limits. When your AI agent attempts to process dozens of site surveys or loop through massive arrays of design components, it is easy to trigger a `429 Too Many Requests` response. Truto handles this cleanly by passing the error back to the caller while normalizing the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. **Truto does not retry, throttle, or apply backoff on rate limit errors.** This is a deliberate architectural decision: the caller (your agent framework or Claude) is responsible for reading the `ratelimit-reset` header and applying its own retry and backoff logic, ensuring the AI maintains context of exactly why a delay is occurring.

## How to Generate an Aurora Solar MCP Server with Truto

Instead of handwriting complex schemas for Aurora Solar's API, Truto uses a documentation-driven approach to generate tools dynamically. Truto reads the resource definitions and documentation records (which contain the descriptions and JSON schemas for query and body parameters) of a connected integration and converts them into an MCP-compliant JSON-RPC 2.0 endpoint.

Each MCP server is scoped to a single integrated account and secured by a cryptographic token. You can create this server either via the Truto UI or programmatically via the API.

### Method 1: Creating the MCP Server via the Truto UI

If you are setting this up for a single workspace or internal testing, the UI is the fastest path.

1. Log into your Truto dashboard and navigate to the integrated account page for your Aurora Solar connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can assign a human-readable name, filter the allowed methods (e.g., read-only access), restrict tools by tags, and set an optional expiration date.
5. Click Save and **copy the generated MCP server URL**. You will need this to connect Claude.

### Method 2: Creating the MCP Server via the Truto API

If you are building a product that deploys AI agents for your customers, you can [generate MCP servers programmatically](https://truto.one/how-to-generate-mcp-servers-for-your-saas-users-2026-architecture-guide/). 

Make an authenticated `POST` request to the `/integrated-account/:id/mcp` endpoint. Truto will validate that the integration is AI-ready, verify your configuration filters, provision the server in secure edge storage, and return a unique URL.

```typescript
const response = await fetch('https://api.truto.one/integrated-account/<AURORA_ACCOUNT_ID>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_TRUTO_API_KEY>',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Aurora Solar Sales Agent",
    config: {
      methods: ["read", "write"], 
      tags: ["sales", "projects"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const data = await response.json();
console.log(data.url); // e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...
```

The resulting token URL is fully self-contained. It encodes the authentication logic and routing required to map Claude's JSON-RPC requests directly to the proxy APIs that communicate with Aurora Solar.

## How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude requires zero additional coding. You can configure it via the Claude Desktop UI or by directly modifying the configuration file.

### Method 1: Connecting via the Claude Desktop UI

Anthropic recently added a straightforward UI for managing remote MCP connections.

1. Open Claude Desktop.
2. Navigate to **Settings -> Integrations -> Add MCP Server**.
3. Enter a name for the connection (e.g., "Aurora Solar").
4. Paste the Truto MCP URL you generated in the previous step.
5. Click **Add**.

Claude will immediately ping the server, invoke the `tools/list` protocol method, and dynamically load the available Aurora Solar operations into its context window.

### Method 2: Connecting via Manual Configuration File

For automated deployments or advanced setups, you can inject the server directly into the Claude Desktop configuration JSON file.

Open your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add an SSE (Server-Sent Events) transport definition:

```json
{
  "mcpServers": {
    "aurora-solar": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/<YOUR_SECURE_TOKEN>"
      ]
    }
  }
}
```

Restart Claude Desktop. The application will initialize the connection and the Aurora Solar tools will be ready to use.

## Hero Tools for Aurora Solar

Truto maps Aurora Solar's endpoints into clear, descriptive tools. Here are the highest-leverage tools available for your AI agents when managing solar workflows.

### List All Tenant Projects

Retrieves a paginated list of solar projects for the tenant. This is almost always the first step in an AI workflow, allowing the agent to look up an address or project ID before diving into designs.

> "Find the project ID for the solar installation at 123 Main Street and tell me its current status."

### Get Single Design Request

Retrieves the detailed status of a design request, including latitude, longitude, and any rejection reasons from the design team. Useful for monitoring the pipeline of requested 3D models.

> "Check the status of design request `req-8472`. If it was rejected by the designer, what was the reason?"

### Accept Design Request

Advances an EagleView or standard design request to `accepted` status, which triggers the generation of a new 3D design within the referenced project. This allows an AI agent to programmatically approve preliminary data and move the project into the modeling phase.

> "Accept the pending design request for the Smith project so the system generates the initial 3D model."

### List Design Summaries

Retrieves the core summary of an Aurora Solar design, including solar arrays, components, and estimated energy production. This is the critical tool for analyzing the technical viability of a proposed system.

> "Pull the design summary for design ID `des-991` and tell me the total estimated energy production and the number of modules used."

### Generate Web Proposal URL

Generates a fresh, shareable Web Proposal URL for an Aurora Solar design (the customer-facing Aurora Sales Mode link). Any previously generated URL is immediately expired, ensuring the customer sees the latest version.

> "Generate a new web proposal link for the latest design on the Johnson project so I can email it to them."

### Create Site Survey

Creates a new site survey record tied to a project. This initiates the operational phase where field technicians gather electrical data, roof conditions, and mounting plane details.

> "Create a new site survey for project ID `proj-442` and flag it as ready for the field team to schedule."

For a complete list of endpoints, JSON schemas, and required parameters, review the [Aurora Solar integration page](https://truto.one/integrations/detail/aurorasolar).

## Workflows in Action

Connecting Claude to Aurora Solar unlocks complex, multi-step orchestration. Instead of clicking through the Aurora web interface, users can simply state their intent, and Claude will string together the correct sequence of proxy API calls.

### Workflow 1: From Design Review to Sales Proposal

Sales representatives frequently need to check if a design has sufficient energy offset before sending a proposal link to a homeowner. 

> "Check the design summary for the Martinez project (design ID: `dsgn-774`). If the estimated energy production covers at least 95% of their usage, generate a new web proposal link so I can share it with them."

**How Claude executes this:**
1. Calls `list_all_aurora_solar_design_summaries` using the provided `design_id` to retrieve the technical specs and energy production data.
2. Evaluates the returned JSON payload against the user's 95% offset requirement.
3. If the criteria are met, calls `create_a_aurora_solar_web_proposal_generate_url`.
4. Returns the fresh sales proposal link to the user.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Aurora as Aurora Solar API

    User->>Claude: Check dsgn-774 offset, generate proposal if > 95%
    Claude->>MCP: tools/call list_all_aurora_solar_design_summaries
    MCP->>Aurora: GET /tenants/{id}/designs/dsgn-774/summary
    Aurora-->>MCP: Design summary JSON
    MCP-->>Claude: Returns energy production data
    Claude->>Claude: Evaluates offset > 95%
    Claude->>MCP: tools/call create_a_aurora_solar_web_proposal_generate_url
    MCP->>Aurora: POST /tenants/{id}/designs/dsgn-774/web_proposal/generate_url
    Aurora-->>MCP: New URL generated
    MCP-->>Claude: Returns https://proposal-link...
    Claude-->>User: Provides the proposal link
```

### Workflow 2: Triaging Design Requests and Triggering Site Surveys

Project managers need to keep pipelines moving. If a design request is stalling, they can use Claude to force it forward and queue the operational work.

> "Check the status of the EagleView design request `ev-req-002`. If it is pending, accept it. Once it is accepted, create a site survey for the parent project."

**How Claude executes this:**
1. Calls `get_single_aurora_solar_design_requests_eagleview_by_id` to check the current `design_status`.
2. Notes the status is pending, and extracts the `project_id` from the payload.
3. Calls `create_a_aurora_solar_accept` with the request ID to advance the state and trigger 3D model generation.
4. Calls `create_a_aurora_solar_tenant_site_survey` using the extracted `project_id` to queue the field operations work.
5. Reports back to the user that the model is generating and the survey is logged.

## Security and Access Control

Exposing an enterprise solar platform to an autonomous AI agent requires tight access control. Truto's MCP architecture provides multiple layers of security to limit the blast radius of LLM actions.

*   **Method Filtering:** You can configure the MCP token to restrict the server to specific HTTP methods. Passing `methods: ["read"]` during server creation guarantees Claude can only execute GET and LIST operations, making it impossible for a hallucinating agent to accidentally delete a project or alter a bill of materials.
*   **Tag Filtering:** By passing `tags: ["sales"]`, you can limit the available tools to a specific domain. The AI agent will only see tools related to proposals and orders, completely hiding deep engineering endpoints like DC optimizer settings or system loss arrays.
*   **API Token Authentication Layer:** By default, anyone with the MCP URL can access the server. Setting `require_api_token_auth: true` adds a mandatory secondary layer. The client connecting to the server must also provide a valid Truto API token in the Authorization header, preventing leaked URLs from being exploited.
*   **Automatic Server Expiration:** Setting an `expires_at` timestamp creates an ephemeral server. Truto's underlying infrastructure schedules an automatic cleanup job that permanently destroys the server credentials and token routing data at the exact time specified, which is ideal for temporary contractor access or single-run automated jobs.

## Start Automating Aurora Solar

Building a custom integration between an LLM and Aurora Solar forces your engineering team to manage complex polling loops, decode deeply nested payloads, and manually parse rate limit headers. It turns your developers into API babysitters.

Truto abstracts this away entirely. By generating a secure, documentation-driven MCP server, you can give Claude immediate, native access to Aurora Solar's operations. The AI agent understands the tools, Truto handles the routing and translation, and your team can focus on designing workflows instead of writing integration code.

> Want to give your AI agents secure access to Aurora Solar? Partner with Truto to instantly generate managed MCP servers for hundreds of B2B SaaS platforms.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)