---
title: "Connect BQE CORE to Claude: Automate Billing and Resource Schedules"
slug: connect-bqe-core-to-claude-automate-billing-and-resource-schedules
date: 2026-10-31
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect BQE CORE to Claude using a managed MCP server. This guide covers setup, secure authentication, and real-world workflows for automating time tracking, resource scheduling, and billing operations."
tldr: "Connect BQE CORE to Claude using Truto's managed MCP server to automate professional services workflows. This technical guide covers generating the server, connecting it to Claude, and orchestrating billing and resourcing workflows."
canonical: https://truto.one/blog/connect-bqe-core-to-claude-automate-billing-and-resource-schedules/
---

# Connect BQE CORE to Claude: Automate Billing and Resource Schedules


If you need to connect BQE CORE to Claude to automate time entry processing, balance resource schedules, manage project billing, or execute complex financial reporting, 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 LLM tool calls and BQE CORE's REST APIs. You can either construct and maintain this integration layer 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 [connecting BQE CORE to ChatGPT](https://truto.one/connect-bqe-core-to-chatgpt-manage-projects-time-and-expenses/) or explore our broader architectural overview on [connecting BQE CORE to AI Agents](https://truto.one/connect-bqe-core-to-ai-agents-sync-sales-leads-and-workforce-ops/).

Giving a Large Language Model (LLM) read and write access to a sprawling Professional Services Automation (PSA) platform like BQE CORE is a strict engineering challenge. You have to handle API token lifecycles, map incredibly dense relational JSON schemas to MCP tool definitions, and deal with BQE's specific resource validation logic. Every time an endpoint changes, 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 BQE CORE, connect it natively to Claude, and execute complex professional services workflows using natural language.

> Want to give your AI agents secure, authenticated access to BQE CORE and 100+ other B2B SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the BQE CORE API

A custom MCP server is a self-hosted integration middleware. While the open MCP standard provides a predictable way for models to discover tools over [JSON-RPC 2.0](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/), the reality of implementing it against BQE CORE's API exposes several domain-specific hurdles. BQE CORE manages the financial and operational lifeblood of professional services firms. Its API reflects that strict compliance and relational complexity.

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

**JSON Patch for Partial Updates**
BQE CORE relies heavily on JSON Patch (RFC 6902) for partial modifications via its `partial_update` endpoints. You cannot simply send a JSON object with the fields you want to change. Instead, you must pass the record's current `version` string (requiring a preliminary GET request) and a `Document` array defining the exact operations. For example, updating an account name requires `{"op": "replace", "path": "/name", "value": "New Name"}`. An LLM will almost certainly hallucinate this structure unless the MCP tool schema is rigorously defined to enforce the JSON Patch specification.

**Deep Relational Dependencies**
Operations in BQE CORE are highly relational. Creating a `time_entry` or an `expense_entry` requires valid IDs for the `activityId` (or `expenseId`), the `projectId`, and the `resourceId`. An LLM cannot just use names; it must execute chain-of-thought workflows to look up the project ID, fetch the specific resource ID of the consultant, verify the activity code, and then assemble the payload. Your MCP server must expose discrete, searchable list tools to facilitate this ID resolution before any write operations occur.

**Pagination Constraints and Expansion**
BQE CORE dictates strict pagination rules. Standard requests return up to 1000 records per page, but if you use the `expand` query parameter to fetch nested properties, the limit drops hard to 100 records per page. Your MCP tools must provide explicit instructions to the LLM on how to use `page=<number>,<size>` syntax, and how to safely navigate pagination cursors without modifying them.

**Rate Limits and 429 Handling**
BQE CORE enforces rate limits that will quickly trigger HTTP 429 responses if an AI agent aggressively loops through records. Truto does not retry, throttle, or apply backoff on rate limit errors. When BQE CORE returns a 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The caller (your LLM client or agent orchestration layer) is strictly responsible for interpreting these headers and executing retry/backoff logic.

## How to Generate the BQE CORE MCP Server

Rather than hand-coding [JSON-RPC handlers](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) and managing OAuth tokens, you can use Truto to dynamically generate an MCP server derived directly from BQE CORE's API documentation and your connected tenant account.

There are two ways to generate this server.

### Method 1: Via the Truto UI

For administrators and non-developers, the UI provides a fast path to server generation.

1. Navigate to the **Integrated Accounts** page in the Truto dashboard.
2. Select your connected BQE CORE account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., restrict allowed methods to `read` only, or filter by specific tags like `billing`).
6. Copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/a1b2c3d4e5f6...`.

### Method 2: Via the Truto API

For developers building automated agent deployments, you can provision MCP servers programmatically. This endpoint validates the configuration, generates a secure cryptographic token backed by Cloudflare KV, and returns a ready-to-use URL.

**POST** `/integrated-account/:id/mcp`

```typescript
{
  "name": "BQE CORE Billing Agent MCP",
  "config": {
    "methods": ["read", "create", "update"],
    "tags": ["projects", "time_entries", "invoices"]
  },
  "expires_at": "2026-12-31T23:59:59Z"
}
```

The API returns the server URL containing the secure token. This URL encapsulates the BQE CORE tenant connection and all allowed tool schemas.

## How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional code. The URL itself handles authentication and schema delivery.

### Method 1: Via the Claude UI

If you are using Claude's web interface or ChatGPT:

1. In ChatGPT: Go to **Settings → Apps → Advanced settings** and enable **Developer mode**. Under MCP servers, click Add, name it "BQE CORE", and paste the URL. 
2. In Claude (Enterprise/Team): Go to **Settings → Integrations → Add MCP Server**, paste the URL, and click Add.

The LLM will immediately hit the JSON-RPC `initialize` and `tools/list` endpoints, loading the BQE CORE operations.

### Method 2: Via Claude Desktop Configuration File

If you are building local agents or using Claude Desktop, you configure the server manually via the `claude_desktop_config.json` file. Truto MCP servers communicate via Server-Sent Events (SSE).

```json
{
  "mcpServers": {
    "bqe-core-managed": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```

Restart Claude Desktop. The agent is now securely connected to your BQE CORE instance.

## Hero Tools for BQE CORE

Truto automatically generates tools for every documented BQE CORE resource. Here are the highest-leverage tools available for AI agents, specifically curated for Professional Services operations.

### 1. List All Projects (`list_all_bqe_core_projects`)

This is the foundational discovery tool. The agent uses this to fetch project IDs, contract types, and manager IDs, which are strictly required for downstream allocations and billing.

> "Fetch a list of all active BQE CORE projects. Return the project names, their internal IDs, and the associated client IDs. If there are more than 100, page through the results."

### 2. Create a Time Entry (`create_a_bqe_core_time_entry`)

Automates the logging of consultant hours. The LLM must pass the required `activityId`, `projectId`, and `resourceId` along with the date and hours.

> "Log a new time entry for resource ID 8892 against project ID 451. The date is today, the activity ID is 12 (Consulting), and the duration is 4.5 hours. Add the description 'System architecture review'."

### 3. List Resource Schedules (`list_all_bqe_core_resource_schedules`)

Crucial for capacity planning. Allows the agent to query upcoming resource allocations, ensuring teams aren't double-booked before creating new assignments.

> "Retrieve the resource schedules for next week. Group the output by resource ID and sum up the total allocated hours to identify who has remaining capacity."

### 4. Create an Expense Entry (`create_a_bqe_core_expense_entry`)

Allows the agent to parse receipts (using Claude's vision capabilities) and immediately log the structured data into BQE CORE as a compliant expense.

> "I have attached a receipt for a flight. Create a BQE CORE expense entry for $450 against project ID 992. The resource ID is 8892 and the expense ID (category) is 44."

### 5. Partial Update Project (`bqe_core_projects_partial_update`)

Enables precision updates using JSON Patch syntax, preventing the LLM from accidentally overwriting unrelated fields by doing full PUT replacements.

> "Update the status of project ID 451. First fetch the project to get its current 'version' string. Then use the partial update tool to replace the '/status' path with the value 'Completed'."

### 6. Create an Invoice (`create_a_bqe_core_invoice`)

Executes the final billing motion. The agent can draft standard invoices after verifying that time and expenses have been logged and approved.

> "Draft a new invoice for client ID 332. The invoice date should be today, and the invoice amount should be $12,500. Generate an invoice number using our standard prefix sequence."

For the complete schema definitions and the full inventory of BQE CORE tools—including endpoints for allocations, budgets, RFIs, and vendors—refer to the [BQE CORE integration page](https://truto.one/integrations/detail/bqecore).

## Workflows in Action

[AI agents](https://truto.one/connect-bqe-core-to-ai-agents-sync-sales-leads-and-workforce-ops/) excel when they chain multiple MCP tools together to complete cross-functional workflows. Here are two real-world sequences for BQE CORE.

### Scenario 1: Automated Time and Expense Parsing

Field consultants often email summaries of their hours and attach receipts. An agent can process this inbox and map it directly to BQE CORE.

> "Read the latest email from Sarah detailing her site visit. Find the project ID for 'Alpha Implementation', log 6 hours of consulting time for yesterday, and parse the attached hotel receipt to create an expense entry for her."

**Execution Steps:**
1. The agent calls `list_all_bqe_core_projects` with a filter to find the ID for "Alpha Implementation".
2. The agent calls `list_all_bqe_core_employees` to look up Sarah's `resourceId`.
3. The agent calls `create_a_bqe_core_time_entry` using the discovered `projectId`, `resourceId`, and a standard `activityId` for consulting.
4. The agent extracts the total ($320) from the hotel receipt and calls `create_a_bqe_core_expense_entry`.

*Result:* The user gets a confirmation that both the timecard and the expense report were successfully logged, fully audited with IDs.

### Scenario 2: Resourcing and Invoice Generation

A project manager needs to finalize a sprint and push out billing, ensuring no allocations are left pending.

> "Check the resource schedules for project 'Delta Migration' for the month of October. If all scheduled hours match the logged time entries, generate a final invoice for the client."

```mermaid
sequenceDiagram
    participant Claude as Claude (Agent)
    participant BQE as BQE CORE MCP
    
    Claude->>BQE: list_all_bqe_core_projects (Find 'Delta Migration')
    BQE-->>Claude: Returns projectId 782, clientId 104
    Claude->>BQE: list_all_bqe_core_resource_schedules (Filter by projectId 782)
    BQE-->>Claude: Returns scheduled allocations
    Claude->>BQE: list_all_bqe_core_time_entries (Filter by projectId 782)
    BQE-->>Claude: Returns actual logged hours
    Note over Claude: Agent reconciles scheduled vs logged hours
    Claude->>BQE: create_a_bqe_core_invoice (clientId 104, calculated amount)
    BQE-->>Claude: Invoice generated (ID: INV-889)
```

**Execution Steps:**
1. The agent uses `list_all_bqe_core_projects` to resolve the string name "Delta Migration" into an ID.
2. It queries `list_all_bqe_core_resource_schedules` to get the baseline expected hours.
3. It queries `list_all_bqe_core_time_entries` to verify the actual logged work.
4. Upon verifying the match, it executes `create_a_bqe_core_invoice` for the parent client ID.

*Result:* The PM receives a summary stating the hours reconciled perfectly, and Invoice INV-889 has been drafted.

## Security and Access Control

Giving AI models write access to financial and PSA data requires strict boundaries. Truto MCP servers enforce security at the architectural level:

*   **Method Filtering:** Configure the server with `config.methods: ["read"]` to strictly limit the LLM to GET/LIST operations, preventing it from ever creating invoices or modifying time entries.
*   **Tag Filtering:** Use `config.tags` to scope the AI's access to specific operational silos (e.g., expose the `time_tracking` tools but hide the `general_journals` and `payments` tools).
*   **Additional Authentication Layer:** Enable `require_api_token_auth` to force the MCP client to pass a valid Truto API session token. This ensures that simply possessing the MCP URL is not enough to execute tools.
*   **Time-To-Live (TTL):** Set an `expires_at` timestamp for temporary agents or contractor access. Cloudflare KV and durable alarms automatically destroy the server and its authentication data the second the TTL expires.

## Moving Forward

Connecting BQE CORE to Claude via a managed MCP server transforms natural language into executable financial and operational workflows. Instead of manually cross-referencing project IDs and wrestling with JSON Patch syntax for partial updates, your agents can dynamically traverse the BQE CORE API schema safely and securely.

By leveraging Truto to handle token lifecycles, schema mapping, and tool curation, your engineering team can stop maintaining middleware and start building high-value, AI-native professional services workflows.