Prompt Library

I am building [product name] on the COUNT Partner API. Walk me through Partner OAuth app configuration with production-ready code in [language or framework].

## Prerequisites checklist
1. Create an OAuth app in COUNT Partners and copy clientId + clientSecret.
2. Register redirect URI exactly (character-for-character, no query params on the registered URI): [redirect uri]
3. Store secrets server-side only — never in frontend bundles or mobile apps.

## Environment variables
```bash
COUNT_API_BASE_URL=https://api.getcount.com
COUNT_CLIENT_ID=your-client-id
COUNT_CLIENT_SECRET=your-client-secret
COUNT_REDIRECT_URI=[redirect uri]
```

## OAuth routes (workspace apps)
| Step | Route |
|------|-------|
| Start consent | `GET /auth2/authorize-intiate` (legacy spelling — use exactly) |
| Exchange code | `POST /partners/grant-access-token` |
| Refresh token | `POST /partners/refresh-user-access-token` |

Firm / multi-client apps use `GET /auth2/firm/authorize-initiate` instead.

## Initiate URL (send the user here)
```
GET https://api.getcount.com/auth2/authorize-intiate?clientId={clientId}&redirectUri={encodeURIComponent(redirectUri)}&state={randomState}
```

Generate state with a CSPRNG and store it in the user's server session before redirecting:
```javascript
import crypto from 'node:crypto';

function createOAuthState() {
  return crypto.randomBytes(32).toString('hex');
}
```

## What I need from you
- Confirm my redirect URI registration steps in COUNT Partners.
- Generate the initiate redirect helper and session storage for state in [language or framework].
- List common misconfiguration errors (redirect mismatch, missing state validation, secret in client code).
- Point me to the Signature Generator tool if I need to verify HMAC before calling token routes.

Implement the full COUNT workspace OAuth authorization code flow in [language or framework] for redirect URI [redirect uri].

## Flow overview
1. User clicks **Connect to COUNT** in my app.
2. My server generates `state`, stores it, and redirects to authorize-intiate.
3. User approves on COUNT consent screen.
4. COUNT redirects to my callback with `?code=...&state=...`.
5. My server validates `state`, exchanges `code` for tokens (HMAC-signed, no Bearer).
6. I persist tokens server-side keyed by my user / tenant id.

## Step 1 — Start authorization (server route)
```javascript
// Express example: GET /connect/count
app.get('/connect/count', (request, response) => {
  const state = crypto.randomBytes(32).toString('hex');
  request.session.countOAuthState = state;

  const params = new URLSearchParams({
    clientId: process.env.COUNT_CLIENT_ID,
    redirectUri: process.env.COUNT_REDIRECT_URI,
    state,
  });

  response.redirect(`https://api.getcount.com/auth2/authorize-intiate?${params}`);
});
```

## Step 2 — Callback handler
```javascript
// GET /oauth/callback/count
app.get('/oauth/callback/count', async (request, response) => {
  const { code, state } = request.query;

  if (!code || state !== request.session.countOAuthState) {
    return response.status(400).send('Invalid OAuth callback');
  }

  const body = JSON.stringify({ code, grantType: 'authorization_code' });
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const signature = signCountRequest({
    method: 'POST',
    path: '/grant-access-token',
    timestamp,
    body,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const tokenResponse = await fetch(`https://api.getcount.com/partners/grant-access-token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-client-id': process.env.COUNT_CLIENT_ID,
      'x-timestamp': timestamp,
      'x-signature': signature,
    },
    body,
  });

  const tokens = await tokenResponse.json();
  // Persist tokens.accessToken, tokens.refreshToken, tokens.workspaceId securely
  response.redirect('/settings/integrations?connected=count');
});
```

## Step 3 — Token response shape
```json
{
  "accessToken": "eyJhbGciOi...",
  "refreshToken": "eyJhbGciOi...",
  "accessTokenExpiresAt": "2026-06-06T12:00:00.000Z",
  "refreshTokenExpiresAt": "2026-07-06T12:00:00.000Z",
  "workspaceId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "workspaceName": "Acme Books"
}
```

## Error cases to handle
- User denied consent → callback arrives without `code`.
- `state` mismatch → reject (possible CSRF).
- Token exchange 401 → verify HMAC base string uses path `/grant-access-token` (no `/partners` prefix).

Implement this end-to-end in [language or framework], including tests for state validation and token persistence.

Implement COUNT Partner API HMAC-SHA256 request signing in [language]. This must work for token exchange, refresh, and all data endpoints.

## Base string format
```
METHOD:path:timestamp:bodyHash
```

- `path` is relative to `/partners` — sign `/customers`, not `/partners/customers`.
- `timestamp` is Unix seconds; send the same value in `x-timestamp` (±300s clock skew allowed).
- `bodyHash` is SHA-256 hex of the **exact** JSON body for POST/PUT/PATCH, or empty string for GET/DELETE.

## Reference implementation (Node.js)
```javascript
import crypto from 'node:crypto';

function sha256Hex(value) {
  return crypto.createHash('sha256').update(value ?? '').digest('hex');
}

function signCountRequest({ method, path, timestamp, body, clientSecret }) {
  const upperMethod = method.toUpperCase();
  const bodyHash = ['POST', 'PUT', 'PATCH'].includes(upperMethod) ? sha256Hex(body) : '';
  const baseString = `${upperMethod}:${path}:${timestamp}:${bodyHash}`;
  return crypto.createHmac('sha256', clientSecret).update(baseString).digest('hex');
}
```

## Headers on every request
```http
x-client-id: <clientId>
x-timestamp: <unix seconds>
x-signature: <hex HMAC of base string>
Authorization: Bearer <workspace access token>   # required on data endpoints only
Content-Type: application/json                   # when sending a body
```

## Worked example — list customers (GET)
```javascript
const timestamp = Math.floor(Date.now() / 1000).toString();
const signature = signCountRequest({
  method: 'GET',
  path: '/customers',
  timestamp,
  body: '',
  clientSecret: process.env.COUNT_CLIENT_SECRET,
});

const response = await fetch(`https://api.getcount.com/partners/customers?limit=10`, {
  headers: {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    Authorization: `Bearer ${accessToken}`,
  },
});
```

## Worked example — grant access token (POST, no Bearer)
```javascript
const body = JSON.stringify({ code: authCode, grantType: 'authorization_code' });
const timestamp = Math.floor(Date.now() / 1000).toString();
const signature = signCountRequest({
  method: 'POST',
  path: '/grant-access-token',
  timestamp,
  body,
  clientSecret: process.env.COUNT_CLIENT_SECRET,
});
```

Port this to [language], add unit tests with a known base string, and wire it into my HTTP client middleware.

Implement automatic COUNT Partner access token refresh in [language or framework].

## When to refresh
- Proactively: schedule refresh ~5 minutes before `accessTokenExpiresAt`.
- Reactively: retry once after 401 from a data endpoint.

## Refresh request (HMAC-signed, no Bearer)
```http
POST https://api.getcount.com/partners/refresh-user-access-token
Content-Type: application/json
x-client-id: <clientId>
x-timestamp: <unix seconds>
x-signature: <HMAC of POST:/refresh-user-access-token:timestamp:bodyHash>

{
  "grantType": "refresh_token",
  "refreshToken": "<stored refresh token>"
}
```

## Node.js example
```javascript
async function refreshCountTokens({ refreshToken }) {
  const body = JSON.stringify({ grantType: 'refresh_token', refreshToken });
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const signature = signCountRequest({
    method: 'POST',
    path: '/refresh-user-access-token',
    timestamp,
    body,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const response = await fetch(`https://api.getcount.com/partners/refresh-user-access-token`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-client-id': process.env.COUNT_CLIENT_ID,
      'x-timestamp': timestamp,
      'x-signature': signature,
    },
    body,
  });

  if (!response.ok) throw new Error(`Refresh failed: ${response.status}`);
  return response.json(); // new accessToken + possibly rotated refreshToken
}
```

## Persistence rules
- Encrypt refresh tokens at rest.
- Replace stored tokens atomically when refresh returns new values.
- If refresh fails with 401, mark the connection as `needs_reconnect` and send the user through OAuth again.

Build this as a reusable token manager with locking so concurrent API calls don't trigger duplicate refreshes.

Implement COUNT **firm OAuth** for a multi-client integration in [language or framework].

## When to use firm OAuth
Use this when my product serves an accounting firm and needs access to **many client workspaces** under one firm authorization — not a single workspace connect.

## Initiate (firm route — note spelling)
```
GET https://api.getcount.com/auth2/firm/authorize-initiate?clientId={clientId}&redirectUri={redirectUri}&state={state}
```

## After token exchange
Firm tokens may span multiple workspaces. Before calling Partner API data routes for a specific client:
1. List authorized workspaces.
2. Set the active workspace for subsequent calls.

```javascript
// Pseudocode — use MCP COUNT_list_workspaces / COUNT_set_active_workspace
// or equivalent Partner API routes your integration exposes
async function withWorkspace(workspaceId, callback) {
  await setActiveWorkspace(workspaceId);
  return callback();
}
```

## Implementation deliverables
- Firm OAuth initiate + callback routes (mirror workspace flow but use firm authorize-initiate).
- Workspace picker UI so the user chooses which client workspace to work in.
- Server-side mapping: firm user → selected workspaceId → stored tokens.
- Explain differences from single-workspace OAuth in my codebase comments.

Build the full flow and document how my app switches between client workspaces safely.

Add a polished **Connect to COUNT** experience to [app or page description].

## UX copy (user-facing)
- Button label: **Connect to COUNT** or **Sign in with COUNT**
- Pre-connect explainer: "We connect to your COUNT workspace to [read invoices / sync transactions / etc.]. You can disconnect anytime in Settings."
- Product name always **COUNT** (all caps).

## Server routes to implement
| Route | Purpose |
|-------|---------|
| `GET /connect/count` | Generate state, redirect to authorize-intiate |
| `GET /oauth/callback/count` | Validate state, exchange code, store tokens |
| `POST /disconnect/count` | Delete stored tokens for this user |

## Connect button (React example)
```jsx
function ConnectToCountButton() {
  return (
    <a
      href="/connect/count"
      className="inline-flex items-center gap-2 rounded-lg bg-brand-500 px-4 py-2 text-sm font-semibold text-white"
    >
      Connect to COUNT
    </a>
  );
}
```

## Callback error handling
```javascript
if (!request.query.code) {
  // User cancelled consent
  return response.redirect('/settings/integrations?error=denied');
}
if (request.query.state !== request.session.countOAuthState) {
  return response.redirect('/settings/integrations?error=invalid_state');
}
```

## Settings disconnect
```javascript
app.post('/disconnect/count', requireLogin, async (request, response) => {
  await deleteStoredTokens(request.user.id);
  response.redirect('/settings/integrations?disconnected=count');
});
```

Implement the UI, routes, and error toasts. Include loading/disconnected/connected states in settings.

Before calling Partner API routes in my app, verify OAuth is configured and tokens are valid for the current user/tenant.

## Check stored tokens (server-side)
```javascript
function countConnectionStatus(stored) {
  if (!stored?.accessToken) return { ok: false, reason: 'not_connected' };
  if (new Date(stored.accessTokenExpiresAt) <= new Date()) {
    return { ok: false, reason: 'access_token_expired' };
  }
  return {
    ok: true,
    workspaceId: stored.workspaceId,
    workspaceName: stored.workspaceName,
  };
}
```

## Probe with a signed GET (proves HMAC + Bearer work)
```javascript
const response = await countPartnerFetch('/customers?limit=1', {
  method: 'GET',
  accessToken: stored.accessToken,
});
```

Report:
1. Connected or not, and workspace id/name if connected.
2. Whether refresh or re-OAuth is needed (`POST /partners/refresh-user-access-token` or redirect to `/connect/count`).
3. Any signing errors (path must omit `/partners` prefix in the HMAC base string).

Before any other COUNT workspace work through MCP, verify the connection is live.

## Check auth
```
COUNT_auth_status
```

Report:
- Whether credentials and workspace tokens are configured.
- Whether re-authentication is required (`count login` or remote MCP OAuth).
- Active workspace name/id if multi-workspace.

Stop if unauthorized and tell me the exact reconnect step.

Help me connect a bank account to COUNT using the **Connections API** and Plaid Hosted Link in [language or framework].

## Important constraint
Bank login requires a **human in a browser**. API calls alone cannot complete Plaid Link — mint a URL, open it for the user, then poll until complete.

## Step 1 — Mint connect link
```http
POST https://api.getcount.com/partners/connections/connect-link
Authorization: Bearer <accessToken>
x-client-id: ...
x-timestamp: ...
x-signature: ...   # sign POST:/connections/connect-link:timestamp:bodyHash (empty body if no JSON)
```

```javascript
const timestamp = Math.floor(Date.now() / 1000).toString();
const signature = signCountRequest({
  method: 'POST',
  path: '/connections/connect-link',
  timestamp,
  body: '',
  clientSecret: process.env.COUNT_CLIENT_SECRET,
});

const { data } = await countFetch('/connections/connect-link', { method: 'POST', timestamp, signature });
// data.linkToken, data.hostedLinkUrl
```

## Step 2 — Open Hosted Link for the user
```javascript
// Redirect or open a new tab — user completes Plaid in browser
response.redirect(data.hostedLinkUrl);
// Store data.linkToken server-side tied to this user/session for polling
```

## Step 3 — Poll complete-connect-link
```http
POST https://api.getcount.com/partners/connections/connect-link/complete
Content-Type: application/json

{ "linkToken": "link-sandbox-xxxxxxxx" }
```

```javascript
async function pollConnectComplete(linkToken) {
  for (let attempt = 0; attempt < 60; attempt++) {
    const body = JSON.stringify({ linkToken });
    const result = await signedPost('/connections/connect-link/complete', body);
    if (result.data.status === 'completed') return result.data.connection;
    if (result.data.status === 'exited') throw new Error('User exited Plaid without connecting');
    await sleep(2000); // status === 'pending'
  }
  throw new Error('Hosted Link timed out — mint a fresh connect-link');
}
```

## Step 4 — Verify
```http
GET https://api.getcount.com/partners/connections
```

Implement the full server flow with UI states: **Connecting…**, **Waiting for bank login**, **Connected**, **Cancelled**. Handle link token expiry (mint a fresh link after a few hours).

The bank connection for **[institution name]** (connection id **[connection uuid]**) needs re-authentication. Implement reconnect using Plaid update mode.

## Step 1 — Confirm connection status
```http
GET https://api.getcount.com/partners/connections/[connection uuid]
```

## Step 2 — Mint reconnect link (Plaid only)
```http
POST https://api.getcount.com/partners/connections/[connection uuid]/reconnect-link
```

```javascript
const { data } = await signedPost(`/connections/${connectionId}/reconnect-link`);
// data.linkToken, data.hostedLinkUrl — same polling pattern as initial connect
response.redirect(data.hostedLinkUrl);
```

## Step 3 — Poll complete (reuse connect-link/complete)
```javascript
await pollConnectComplete(storedLinkToken);
```

## Step 4 — Confirm sync resumed
Reload the connection and show `status` + `lastSyncAt` to the user.

Build the reconnect banner UI ("Your [institution name] connection needs attention → Reconnect") and wire it to this flow.

Audit every bank-feed connection for this COUNT workspace and tell me which need action.

## List connections
```http
GET https://api.getcount.com/partners/connections
Authorization: Bearer <accessToken>
x-client-id / x-timestamp / x-signature
```

Or via MCP: `COUNT_list_connections`, then `COUNT_get_connection` for details.

## Report format (one row per connection)
| Institution | Status | Last sync | Accounts | Recommendation |
|-------------|--------|-----------|----------|----------------|
| ... | active / error | ISO timestamp | mask list | OK / reconnect / revoke |

## Decision rules
- **Stale lastSyncAt** (> 48h) → suggest reconnect-link.
- **status errored** → POST `/connections/{uuid}/reconnect-link` (Plaid only).
- **Duplicate institutions** → flag for manual review.

If MCP-connected, run the tools and paste a summary table. If custom integration, show the signed GET example and parsing code in [language].

## Goal
Bill a customer for products or services and email them the invoice in one pass.

## Build this in my codebase (Partner API — not MCP)
Bill a customer for products or services and email them the invoice in one pass.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/invoices
- /reference/customers

## Steps
1. Resolve the customer (and any product) names to UUIDs.
2. Create the invoice in draft state.
3. Approve the draft invoice — this posts the revenue journal.
4. Send the invoice to the customer by email.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Mark an invoice paid by matching it to a deposit that already landed in the bank feed.

## Build this in my codebase (Partner API — not MCP)
Find the deposit transaction from [customer name] around [date] for [amount], and apply it as payment against invoice [invoice number or reference].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions
- /reference/invoices

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Offset a customer credit memo against one or more of their open invoices.

## Build this in my codebase (Partner API — not MCP)
Apply the open credit memo for [customer name] against their oldest open invoice, up to the credit balance.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/invoices
- /reference/credit-memo

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
List every overdue invoice and re-send reminders to the customers.

## Build this in my codebase (Partner API — not MCP)
List every overdue invoice, and for each one, re-send it to the customer with a short payment reminder message.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/invoices

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Automate a repeating bill for a subscription or retainer customer.

## Build this in my codebase (Partner API — not MCP)
Set up a monthly recurring invoice for [customer name] for [products/services and amounts], starting [date]. Leave it paused until I confirm it looks right.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/recurring-invoice-templates
- /reference/customers

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Record a new bill from a vendor with its line items and due date.

## Build this in my codebase (Partner API — not MCP)
Enter a bill from [vendor name] dated [date] for [line items and amounts], due [due date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/bills
- /reference/vendors

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Move a draft bill through approval so it is ready to pay.

## Build this in my codebase (Partner API — not MCP)
Approve the [vendor name] bill dated [date] for [amount] so it is ready to pay.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/bills

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Offset an outstanding vendor credit against a bill from the same vendor.

## Build this in my codebase (Partner API — not MCP)
Apply the open vendor credit memo from [vendor name] against their [amount] bill dated [date], up to the credit balance.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/bills

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Find an approved bill and apply a matching bank payment to it.

## Build this in my codebase (Partner API — not MCP)
Find an approved bill and apply a matching bank payment to it.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/bills
- /reference/transactions

## Steps
1. List approved bills for the vendor.
2. Load the bill detail and confirm the amount due and currency.
3. Find an existing unreconciled expense transaction to apply, or create one if the payment is new.
4. Apply the transaction to the bill.
5. Reload the bill to confirm the paid amount updated.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Find bank transactions missing a category and assign the right account to each.

## Build this in my codebase (Partner API — not MCP)
Find bank transactions missing a category and assign the right account to each.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Link a single bank transaction to the bill or invoice it settles.

## Build this in my codebase (Partner API — not MCP)
Match the [amount] transaction on [date] to the [bill/invoice] for [vendor or customer name].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions
- /reference/bills
- /reference/invoices

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Break one bank transaction into multiple category lines before applying part of it to a bill or invoice.

## Build this in my codebase (Partner API — not MCP)
Split the [amount] transaction on [date] into [category A] for [amount A] and [category B] for [amount B].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
List reviewed transactions that are not yet marked reconciled, for a bank reconciliation pass.

## Build this in my codebase (Partner API — not MCP)
List transactions on [account name] between [start date] and [end date] that have been reviewed but are not yet reconciled, and summarize them by category.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Hide transactions that should not appear in the books, such as duplicates or personal charges.

## Build this in my codebase (Partner API — not MCP)
Find duplicate or personal transactions on [account name] from [date range] and exclude them from the books. Show me the list before excluding anything.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/transactions

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Reconcile a bank account through a statement end date and confirm the ending balance.

## Build this in my codebase (Partner API — not MCP)
Complete a bank reconciliation for [account name] through [statement end date] with an ending balance of [amount]. List any unmatched transactions before finishing.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reconciliations
- /reference/transactions

## Steps
1. Load the bank account and transactions for the period.
2. Start a reconciliation for the statement end date.
3. Review cleared vs. uncleared items with me.
4. Complete the reconciliation once the ending balance matches.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Begin a reconciliation and summarize what still needs to clear.

## Build this in my codebase (Partner API — not MCP)
Start a reconciliation for [account name] for [month] and tell me which reviewed transactions are still uncleared and what the difference is from the statement ending balance of [amount].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reconciliations
- /reference/transactions

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Link an uploaded expense receipt to the bank transaction it belongs to.

## Build this in my codebase (Partner API — not MCP)
Match the [amount] receipt from [vendor name] dated [date] to the corresponding bank transaction.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/expense-receipts
- /reference/transactions

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
List every receipt waiting for a bank match and suggest likely transactions.

## Build this in my codebase (Partner API — not MCP)
List all unmatched expense receipts from [date range], and for each one suggest the most likely bank transaction to match it to. Ask me to confirm before matching.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/expense-receipts
- /reference/transactions

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Post a balanced manual journal entry, for example a month-end accrual or correction.

## Build this in my codebase (Partner API — not MCP)
Post a journal entry dated [date] for [description]: debit [account name] for [amount], credit [account name] for [amount].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/journal-entries
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Build out missing bank and category accounts, then bulk-import a batch of historical transactions.

## Build this in my codebase (Partner API — not MCP)
Build out missing bank and category accounts, then bulk-import a batch of historical transactions.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/chart-of-accounts
- /reference/transactions
- /reference/reports

## Steps
1. Confirm which workspace to set up.
2. Inventory existing bank/cash and category accounts.
3. Look up the correct account sub-type for each account you need to create.
4. Create all missing bank, credit card, and category accounts first.
5. Resolve vendor/customer/account names from the source data to UUIDs.
6. Preflight each import batch, then bulk-import transactions ~25 rows at a time, retrying only failed rows.
7. Spot-check a sample of imported rows, then run a P&L for the imported period.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Add a single new bank, credit card, income, or expense account.

## Build this in my codebase (Partner API — not MCP)
Create a new [account type] account called [account name] in the chart of accounts.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Create or select a budget, fill in planned amounts, publish it, then compare actuals against it.

## Build this in my codebase (Partner API — not MCP)
Set up a [monthly/yearly] budget for [period] using last year as a guide, publish it once I approve the numbers, then show me actual vs. budget by account for [period].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/budgets
- /reference/reports

## Steps
1. Check for an existing draft budget or Overall Budget before creating a new one.
2. Create a draft budget if none exists for the period.
3. Export the budget grid to see the account/period structure.
4. Resolve account names to UUIDs, preflight the payload, then load planned amounts in batches.
5. Publish the budget once amounts are final.
6. Review actual vs. budget by account and period in the published grid, optionally drilling into a P&L.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Pull a budget grid out for offline editing, then write the edited amounts back.

## Build this in my codebase (Partner API — not MCP)
Export the [budget name] budget grid so I can review the numbers, then once I give you the edited amounts, load them back in as a draft and let me know when it is ready to publish.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/budgets

## Steps
1. List budgets or create a new draft for the planning period.
2. Export the budget grid with account UUIDs and period columns.
3. Resolve any account names to UUIDs from the edited data.
4. Preflight and import the edited amounts in batches.
5. Publish the budget once amounts are final.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Copy an existing published budget as a starting point for next year.

## Build this in my codebase (Partner API — not MCP)
Duplicate the [budget name] budget for [new period], adjust amounts where I specify, and leave it as a draft until I approve.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/budgets

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Produce a trial balance as of a given date.

## Build this in my codebase (Partner API — not MCP)
Generate a trial balance as of [date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reports

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Produce an income statement for a date range.

## Build this in my codebase (Partner API — not MCP)
Generate a profit and loss report from [start date] to [end date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reports

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Produce assets, liabilities, and equity as of a given date.

## Build this in my codebase (Partner API — not MCP)
Generate a balance sheet as of [date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reports

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Run trial balance, P&L, and balance sheet for the same closing period.

## Build this in my codebase (Partner API — not MCP)
Generate a trial balance, profit and loss, and balance sheet for [period end date]. Summarize key totals and flag any obvious anomalies.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/reports

## Steps
1. Generate a trial balance as of the period end.
2. Generate a P&L for the period.
3. Generate a balance sheet as of the period end.
4. Summarize totals and call out anything that looks off.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
List recent or upcoming pay periods for the workspace.

## Build this in my codebase (Partner API — not MCP)
Show me the pay periods for [date range], including their status.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Produce the payroll journal report for a specific pay period, for posting or review.

## Build this in my codebase (Partner API — not MCP)
Generate the payroll journal report for the pay period ending [date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Batch-update regular hours, PTO, overtime, or reimbursements for employees in an open pay period.

## Build this in my codebase (Partner API — not MCP)
For the pay period ending [date], set [employee name] to [hours] regular hours and [hours] PTO.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Record billable or non-billable hours against a project for a person.

## Build this in my codebase (Partner API — not MCP)
Log [hours] for [person name] on [date] against the [project name] project, described as [description].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/time-entries
- /reference/people
- /reference/projects

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Review logged hours on a project for a given period, for billing or utilization review.

## Build this in my codebase (Partner API — not MCP)
List all time entries logged against [project name] for [date range], and total the hours.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/time-entries
- /reference/projects

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Set up a new project for a customer to track tasks and time against.

## Build this in my codebase (Partner API — not MCP)
Create a new project called [project name] for [customer name].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/projects
- /reference/customers

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Create a task under an existing project.

## Build this in my codebase (Partner API — not MCP)
Add a task called [task name] to the [project name] project, due [date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/tasks
- /reference/projects

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Add a new customer with contact and billing details.

## Build this in my codebase (Partner API — not MCP)
Create a new customer called [customer name], with billing address [address] and contact email [email].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/customers

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Add a new vendor before entering bills against them.

## Build this in my codebase (Partner API — not MCP)
Create a new vendor called [vendor name] with contact email [email].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/vendors

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Create many customers from a list or spreadsheet in one workflow.

## Build this in my codebase (Partner API — not MCP)
Import the attached customer list into COUNT in batches. Preflight each batch, resolve duplicates, and show me a summary of created vs. skipped records.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/customers

## Steps
1. Preflight the customer payload for each batch.
2. Bulk-create customers in batches of ~25 rows.
3. Retry only failed rows and summarize results.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Add an item to the catalog for use on invoices.

## Build this in my codebase (Partner API — not MCP)
Create a [product/service] called [name] priced at [amount], categorized as [income account or category].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/products-and-services

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Change the price or description on an existing catalog item.

## Build this in my codebase (Partner API — not MCP)
Update the [product name] product to [new price] and description [new description].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/products-and-services

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Pull cash, AR, AP, and profitability totals for a quick pulse check.

## Build this in my codebase (Partner API — not MCP)
Give me a workspace health snapshot: cash, accounts receivable, accounts payable, and profitability for [period].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/workspace-stats

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Record the starting balance when onboarding a new bank or equity account.

## Build this in my codebase (Partner API — not MCP)
Set the opening balance on [account name] to [amount] as of [date].

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/opening-balance
- /reference/chart-of-accounts

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
List authorized workspaces and set the active one for subsequent tool calls.

## Build this in my codebase (Partner API — not MCP)
List every workspace this connection can access, then switch to [workspace name] for the rest of this session.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Aggregate P&L across authorized client workspaces (remote MCP only).

## Build this in my codebase (Partner API — not MCP)
Generate a firm-wide profit and loss report for [date range] across all authorized client workspaces.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
Aggregate balance sheet across authorized client workspaces (remote MCP only).

## Build this in my codebase (Partner API — not MCP)
Generate a firm-wide balance sheet as of [date] across all authorized client workspaces.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- [Partner API reference](/reference)

## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.

## Goal
A chained close-the-books check: workspace snapshot, open AP/AR review, uncategorized transaction scan, and a closing-period trial balance.

## Build this in my codebase (Partner API — not MCP)
A chained close-the-books check: workspace snapshot, open AP/AR review, uncategorized transaction scan, and a closing-period trial balance.

Implement using the **COUNT Partner REST API** (`https://api.getcount.com/partners/...`), with:
- **HMAC signing** on every request (`x-client-id`, `x-timestamp`, `x-signature`)
- **Bearer access token** on data endpoints (from OAuth — see OAuth & API Integration prompts)
- Official request/response shapes from the API reference (do not invent field names)

## API reference sections
- /reference/workspace-stats
- /reference/bills
- /reference/invoices
- /reference/transactions
- /reference/reports

## Steps
1. Pull a workspace snapshot for cash, AR, AP, and profitability.
2. Review draft or unpaid vendor bills.
3. Review overdue or open customer invoices.
4. Scan for uncategorized or unreconciled bank transactions.
5. Run a trial balance (or P&L) for the closing period.
## Example signed request helper (Node.js)
```javascript
async function countPartnerFetch(path, { method = 'GET', accessToken, body } = {}) {
  const timestamp = Math.floor(Date.now() / 1000).toString();
  const bodyString = body ? JSON.stringify(body) : '';
  const signature = signCountRequest({
    method,
    path, // relative to /partners, e.g. "/customers"
    timestamp,
    body: bodyString,
    clientSecret: process.env.COUNT_CLIENT_SECRET,
  });

  const headers = {
    'x-client-id': process.env.COUNT_CLIENT_ID,
    'x-timestamp': timestamp,
    'x-signature': signature,
    ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
    ...(bodyString ? { 'Content-Type': 'application/json' } : {}),
  };

  return fetch(`https://api.getcount.com/partners${path}`, {
    method,
    headers,
    ...(bodyString ? { body: bodyString } : {}),
  });
}
```

## Rules
- This is a **custom integration** — write production code in my stack, not MCP tool calls.
- Confirm with me before destructive writes (create, update, delete, send, approve, pay).
- Use the SDKs & Templates starter (/sdks) if helpful — OAuth and signing are pre-wired.
- If a route or field is unclear, say which reference page you need rather than guessing.