---
title: "Connect Wiwink to ChatGPT: Manage Proposals, Contacts & Signatures"
slug: connect-wiwink-to-chatgpt-manage-proposals-contacts-signatures
date: 2026-06-19
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Wiwink to ChatGPT using a managed MCP server. Automate proposals, signatures, and contact management without custom integration code."
tldr: Connect Wiwink to ChatGPT using Truto's managed MCP servers. Bypass complex signature workflows and nested API routing to give your AI agents secure read and write access.
canonical: https://truto.one/blog/connect-wiwink-to-chatgpt-manage-proposals-contacts-signatures/
---

# Connect Wiwink to ChatGPT: Manage Proposals, Contacts & Signatures


If your team uses Wiwink to manage business proposals, field installations, and digital signatures, giving an AI agent read and write access to that ecosystem is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/), or you use a managed infrastructure layer to handle the boilerplate. If your team uses Claude, check out our guide on [connecting Wiwink to Claude](https://truto.one/connect-wiwink-to-claude-sync-works-installers-product-inventory/), or explore our broader architectural overview on [connecting Wiwink to AI Agents](https://truto.one/connect-wiwink-to-ai-agents-handle-forms-leads-customer-data/).

This guide breaks down exactly how to use Truto to generate a secure, managed Wiwink MCP server, connect it natively to ChatGPT, and execute complex workflows - like generating proposals and routing digital signatures - using natural language.

## The Engineering Reality of the Wiwink 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 vendor APIs is painful. You aren't just sending simple CRUD requests. You are orchestrating complex, multi-step state machines across Wiwink's data model.

If you decide to [build a custom Wiwink MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), you own the entire API lifecycle. Here are the specific integration challenges that break standard assumptions when working with Wiwink:

### The Multi-Stage Signature Lifecycle
Creating a digital signature request in Wiwink is not a single API call. It is a strictly ordered sequence. You must first call the `signatures` endpoint to create the base record. Then, you must upload the raw binary PDF to the `signature-documents` endpoint. Next, you must append signers via the `signers` endpoint. Finally, you execute a state change to the `signature-sends` endpoint. If an LLM attempts to send a signature before the document hash is verified or signers are attached, the API rejects it. Your MCP server must explicitly guide the LLM through this exact sequence, exposing separate tools for each phase while maintaining the reference ID.

### Relational Sideloading Traps
Wiwink relies heavily on relational lookups. If an LLM asks for a list of "works" or "countries", standard list endpoints return shallow objects holding foreign keys (`country_id`, `status_id`). To prevent the AI from making hundreds of sequential N+1 queries to resolve these IDs, you must instruct the LLM to utilize Wiwink's `with []` array query parameter. This allows the API to sideload related entities in a single pass. Building the JSON schemas to support and explain this dynamic array parameter to an LLM requires tedious, manual schema maintenance.

### Rate Limits and the 429 Reality
Wiwink enforces rate limits on intensive operations like bulk record retrieval or binary uploads. When a threshold is hit, the upstream API returns an HTTP 429 Too Many Requests error. **Truto does not retry, throttle, or apply backoff on rate limit errors.** Instead, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. When building AI agents, your client logic (or the LLM itself) is entirely responsible for reading these headers, pausing execution, and applying exponential backoff. If your agent ignores the 429, the tool call fails and the LLM will hallucinate a success response.

## Generating a Managed Wiwink MCP Server

Instead of building custom schema mappers and handling OAuth flows from scratch, you can use Truto to dynamically generate a Wiwink MCP server. 

Truto derives [auto-generated MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) directly from the integration's documented API endpoints. The generated MCP server is scoped to a specific authenticated Wiwink tenant and requires zero extra client-side infrastructure. You can generate this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

If you are setting this up for internal team use, the UI is the fastest path.

1. Navigate to your **Integrated Accounts** page in the Truto dashboard.
2. Select your connected Wiwink account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure your filters (e.g., restrict to `read` methods or specific tags like `proposals`).
6. Copy the generated MCP Server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are dynamically provisioning ChatGPT access for your own SaaS users, you should generate the MCP server programmatically. 

Send an authenticated `POST` request to `/integrated-account/:id/mcp`. You can pass configuration filters in the payload to strictly define what the LLM is allowed to do.

```typescript
// POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp
// Authorization: Bearer <TRUTO_API_KEY>

{
  "name": "Wiwink ChatGPT Assistant",
  "config": {
    "methods": ["read", "write"], // Allow both queries and mutations
    "tags": ["crm", "works", "signatures"] // Limit scope to specific domains
  },
  "expires_at": "2026-12-31T23:59:59Z"
}
```

The API returns a fully qualified URL containing a cryptographic hash. This URL handles protocol routing, authentication mapping, and schema translation.

```json
{
  "id": "mcp_srv_987654",
  "name": "Wiwink ChatGPT Assistant",
  "url": "https://api.truto.one/mcp/f8e7d6c5b4a3..."
}
```

## Connecting the Wiwink MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with your ChatGPT environment. The MCP protocol handles the handshake - ChatGPT will call the `initialize` and `tools/list` RPC methods to discover the available Wiwink tools.

### Method A: Via the ChatGPT UI (Custom Connectors)

For ChatGPT Plus, Pro, Enterprise, or Education users with Developer mode enabled:

1. Open ChatGPT and go to **Settings → Apps → Advanced settings**.
2. Ensure **Developer mode** is toggled on.
3. Under **MCP servers / Custom connectors**, click **Add new server**.
4. Enter a name (e.g., "Wiwink via Truto").
5. Paste the Truto MCP URL into the **Server URL** field.
6. Click **Save**.

ChatGPT will immediately connect, fetch the Wiwink API definitions, and surface them to the model.

### Method B: Via Manual Config (For Claude Desktop or Local Agents)

If you are testing locally or using Claude Desktop, you must configure an SSE (Server-Sent Events) transport via a configuration file. Update your `claude_desktop_config.json` (or equivalent agent config) to route requests through the official MCP SSE server package.

```json
{
  "mcpServers": {
    "wiwink_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/f8e7d6c5b4a3..."
      ]
    }
  }
}
```

## Hero Tools for Wiwink Automation

Wiwink provides a massive API surface. When you connect via Truto, dozens of proxy endpoints are mapped into LLM tools automatically. Here are the highest-leverage operations for a ChatGPT agent working within Wiwink.

### `list_all_wiwink_works`
Works form the operational core of Wiwink. This tool returns a paginated list of active jobs, filtering by customer, status, or date range. It supports relational sideloading so the AI can pull down customer data in the same request.

> "Find all Wiwink works created this week where the status ID is 3. Make sure to pass 'customer' and 'status' in the with [] array so we can see the full client details without making extra requests."

### `create_a_wiwink_proposal`
Generates a new business proposal tied to a specific customer record. This initiates the quote - to - cash lifecycle. The LLM must supply the `customer_id` and can pre-fill sub-amounts, tax data, and internal comments.

> "Draft a new proposal for customer ID 8910. Set the sub_amount to 4500.00 and add a comment indicating this is for the Q3 enterprise server installation."

### `list_all_wiwink_contacts`
Queries the CRM side of Wiwink. Useful for resolving email addresses or phone numbers to internal `contact_id` values before generating forms, forms, or proposals.

> "Search our Wiwink contacts for anyone matching the email domain '@acmecorp.com'. Return their names, IDs, and current trade_name."

### `get_single_wiwink_installer_by_id`
Retrieves the detailed profile of an installation contractor, including their regional assignment, corporate name, and contact details. This is heavily utilized when routing physical work orders.

> "Pull the profile for Wiwink installer ID 44. I need their phone number and their registered state_id to see if they are eligible for the upcoming job in Texas."

### `create_a_wiwink_signature_document`
The critical second step in the digital signature flow. Once the AI has created a base signature record, it uses this tool to upload the actual raw document file. The tool handles the binary encoding and returns the `crc32` and `md5` checksum metadata.

> "Take the base64 encoded PDF string I generated and upload it as a signature document to signature ID 912. Confirm the file size and checksum once successful."

### `create_a_wiwink_signature_send`
The final execution trigger for a signature sequence. Once the document and signers are staged, this tool officially dispatches the signing request via email or SMS, locking the document from further edits.

> "The document and signers are attached to signature ID 912. Trigger the signature send process and give me the sent_at timestamp so I can log it."

For the complete inventory of available tools, required properties, and JSON schemas, visit the [Wiwink integration page](https://truto.one/integrations/detail/wiwink).

## Workflows in Action

Giving ChatGPT access to these tools transforms it from a chatbot into a specialized operations coordinator. Here is how complex Wiwink sequences execute in practice.

### Workflow 1: The Automated Proposal and Signature Dispatch

Sales operations teams waste hours manually typing proposals and routing compliance PDFs. An AI agent can automate this entirely.

> "Find the contact record for 'sarah@acmecorp.com'. Generate a new Wiwink proposal for $15,000 for her account. Then, initiate a new signature request for the standard SLA agreement, attach the PDF, and send it to her email."

1. **`list_all_wiwink_contacts`**: The agent searches by email to resolve Sarah's `id` and `customer_id`.
2. **`create_a_wiwink_proposal`**: The agent issues the mutation to create the proposal for $15,000, storing the returned `proposal_id`.
3. **`create_a_wiwink_signature`**: The agent initializes a blank signature record.
4. **`create_a_wiwink_signature_document`**: The agent uploads the generated SLA agreement to the signature record.
5. **`create_a_wiwink_signer`**: The agent adds Sarah's contact info to the routing queue.
6. **`create_a_wiwink_signature_send`**: The agent dispatches the contract.

```mermaid
sequenceDiagram
    participant User
    participant Agent as ChatGPT
    participant Wiwink as Wiwink API

    User->>Agent: "Draft proposal & send SLA for sarah@..."
    Agent->>Wiwink: list_all_wiwink_contacts(email='sarah@acmecorp.com')
    Wiwink-->>Agent: Returns contact_id: 42
    Agent->>Wiwink: create_a_wiwink_proposal(customer_id: 42, amount: 15000)
    Wiwink-->>Agent: Returns proposal_id: 104
    Agent->>Wiwink: create_a_wiwink_signature(type: 'contract')
    Wiwink-->>Agent: Returns signature_id: 88
    Agent->>Wiwink: create_a_wiwink_signature_document(signature_id: 88, RAW_BODY)
    Agent->>Wiwink: create_a_wiwink_signer(signature_id: 88, send_to: 'sarah...')
    Agent->>Wiwink: create_a_wiwink_signature_send(signature_id: 88)
    Wiwink-->>Agent: Status: Sent
    Agent-->>User: "Proposal 104 created. SLA sent for signature."
```

### Workflow 2: Work Routing and Installer Assignment

Field operations require matching available contractors to specific jobs based on region and expertise.

> "Review Wiwink work order ID 502. Check which state it belongs to. Then find an installer in that same state and assign them to the work order."

1. **`get_single_wiwink_work_by_id`**: The agent fetches the work order, explicitly passing `with ['customer']` to retrieve the associated address and `state_id`.
2. **`list_all_wiwink_installers`**: The agent filters the installer directory using the target `state_id`.
3. **`create_a_wiwink_work_installer`**: The agent synchronizes the chosen installer to the work order, locking in the assignment.

The user gets back a confirmed dispatch report without ever logging into the Wiwink portal.

## Security and Access Control

Exposing an ERP - level system to an LLM requires strict boundary setting. Truto's MCP architecture enforces governance at the protocol level:

*   **Method Filtering:** Limit your agent to safe actions by passing `methods: ["read"]` during server generation. This disables `create`, `update`, and `delete` tools entirely.
*   **Tag Filtering:** Restrict access by business domain. Passing `tags: ["crm"]` allows the agent to read contacts and customers but prevents access to financial proposals or signatures.
*   **Require API Token Auth:** By default, possessing the MCP URL grants access. For production environments, enable `require_api_token_auth: true` to force the client to pass a valid Truto session token, ensuring zero anonymous usage.
*   **Automatic Expiration:** Use the `expires_at` field to grant temporary access. Ideal for external contractors or one - off automation pipelines - when the TTL hits, the underlying KV store drops the token, and the MCP server goes dark.

## Moving Fast with Unified Infrastructure

Building AI features against monolithic enterprise APIs like Wiwink used to mean months of schema wrangling, OAuth maintenance, and rate limit debugging. By routing your integration through a dynamic MCP layer, you shift that burden entirely.

Truto's documentation-driven architecture ensures that your ChatGPT agent always has the exact, up-to-date schema for every Wiwink endpoint, complete with strict typing and relational sideloading hints. You write the prompts; the infrastructure handles the protocol.

> Stop building custom API wrappers for your AI agents. Partner with Truto to instantly generate managed MCP servers for Wiwink and 150+ other SaaS platforms.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)