canonical: https://jentic.com/apis/bidsketch.com/bidsketch

# Bidsketch API

Bidsketch is a proposal software platform that helps consultants, agencies, and freelancers produce branded proposals quickly. The REST API exposes clients, proposals, proposal sections, fees, templates, and webhooks across 39 endpoints, allowing agents to draft proposals from templates, edit sections and fees, monitor proposal stats, and trigger webhooks on signature events. Authentication uses an HTTP token-based scheme with the API key passed in the Authorization header. Most endpoints are scoped per client and per proposal, with .json suffixes on the paths.

## For AI agents

Create branded proposals from templates, edit sections and fees, and track signature events through the Bidsketch proposal platform.

## Scope

Does not handle e-signature legal workflows, contract redlining, or accounting - use for proposal generation, sections, and fees only.

## Capabilities

- Create a proposal from an existing template with one API call
- Edit proposal opening, body, and closing sections individually
- Add and update fees on a proposal with line-item granularity
- Manage clients and link them to their proposals
- Pull proposal statistics for tracking conversion across the pipeline
- Subscribe to webhooks for signature and proposal lifecycle events
- Reuse templates to keep proposal style consistent across the team

## Use cases

### Template-Driven Proposal Generation

Generate consistent, branded proposals at scale by calling POST `/templates/{id}/proposals.json` with a client identifier. Bidsketch clones the template, links the new proposal to the client, and exposes section and fee endpoints for any per-proposal customisation. Agencies that send dozens of proposals per week reduce drafting time from hours to minutes per proposal.

Example prompt: POST `/templates/123/proposals.json` with client_id 456 to spin up a new proposal, then PUT a custom fee line.

### Proposal Pipeline Tracking

Surface proposal status and conversion rate inside a sales dashboard by calling GET `/proposals/stats.json.` The endpoint returns aggregate stats - proposals sent, viewed, signed - across the workspace, so consultants and agency owners can spot bottlenecks without exporting CSVs from the Bidsketch UI.

Example prompt: Pull `/proposals/stats.json` and surface the win rate for the current quarter on the agency dashboard.

### Client Library Sync from CRM

Keep the Bidsketch client list in sync with an external CRM such as HubSpot or Pipedrive by calling /clients.json on each customer create or update event. Then proposals generated for that client are linked automatically, removing duplicate data entry between systems.

Example prompt: POST /clients.json for every newly created HubSpot contact tagged 'prospect' and store the returned Bidsketch client id.

### AI Agent Proposal Drafter

An AI agent acting as a proposal drafter for a freelancer can take a brief in natural language, pick the right Bidsketch template, instantiate the proposal, and customise the body and fees - all through Jentic. The Bidsketch token stays in your Jentic One instance so the agent never sees the raw credential, and the agent works against a small, intent-discoverable subset of the 39 endpoints.

Example prompt: Search Jentic for 'create a proposal from template', execute `/templates/{id}/proposals.json` with the client id, then add the agreed fee via `/proposals/{proposal_id}/fees.json.`

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/clients.json` | List clients |
| POST | `/clients.json` | Create a client |
| POST | `/proposals.json` | Create a proposal |
| GET | `/proposals/stats.json` | Get proposal statistics |
| POST | `/templates/{id}/proposals.json` | Create a proposal from a template |
| POST | `/proposals/{proposal_id}/fees.json` | Create a fee on a proposal |

## Key resources

- **Clients** — Manage clients and link them to their proposals
- **Proposals** — Create, update, and delete proposals; pull stats
- **Sections** — Edit opening, body, and closing sections within a proposal
- **Fees** — Add, update, and remove fee line items on a proposal
- **Templates** — Use templates to instantiate consistent proposals
- **Webhooks** — Subscribe to proposal lifecycle events

## Why Jentic

- **Setup:** Wiring the Bidsketch API by hand means passing its API token on every call and building each JSON-suffixed client, proposal, and fee path yourself. Through Jentic you install once, import Bidsketch from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Bidsketch puts the proposal and template id in the URL path (`/proposals/{proposal_id}/fees.json`, `/templates/{id}/proposals.json`), so a rule can pin your agent to one proposal or one template. You choose the operations it may call, so creating proposals or adding fees is not included unless you add them.
- **Credential handling:** Your Bidsketch API token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a proposal from a template' or 'list clients', and Jentic returns the matching Bidsketch operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **PandaDoc API** — PandaDoc is a larger document automation platform covering proposals, contracts, and e-signature workflows.
- **HubSpot CRM Contacts API** — HubSpot manages the prospect pipeline; Bidsketch handles the proposal once a deal is qualified.
- **Stripe API** — Stripe collects the payment for an accepted Bidsketch proposal.

## FAQ

### What authentication does the Bidsketch API use?

Bidsketch uses an apiKey scheme on the Authorization header, with the value being the user's API token from the Bidsketch account settings. Through Jentic, the token is stored encrypted in the your Jentic One instance and injected at execution time so the agent never sees the raw token.

### Can I create a proposal from a template via the Bidsketch API?

Yes. POST `/templates/{id}/proposals.json` with the target client id creates a new proposal cloned from the chosen template. The response returns the new proposal id which you can then customise via the section and fee endpoints.

### How do I add a fee to a proposal?

POST `/proposals/{proposal_id}/fees.json` with the fee body to add a line item, PUT `/proposals/{proposal_id}/fees/{fee_id}.json` to update it, and DELETE the same path to remove it. GET `/proposals/{proposal_id}/fees.json` returns the full fee list for the proposal.

### How do I create a proposal from a template through Jentic?

Search Jentic for 'create a proposal from template', load `/templates/{id}/proposals.json`, and execute with the client id and template id. With the SDK: pip install jentic, then SearchRequest, LoadRequest, ExecutionRequest in an async flow.

### Are there webhooks for proposal events?

Yes - Bidsketch exposes webhook management endpoints so your application can be notified when a proposal is viewed, signed, or rejected. Configure the webhook URL via the API and keep the receiving endpoint reachable so events are processed in real time.

### Can I limit what my agent is allowed to do with the Bidsketch API?

Yes. Because you self-host Jentic One, your own rules decide which Bidsketch operations and credentials the agent can use, so it can only create proposals, edit sections, or add fees if you allow those operations. Bidsketch puts the proposal and template id directly in the URL path, such as `/proposals/{proposal_id}/fees.json` and `/templates/{id}/proposals.json`, so a rule can pin the agent to a single proposal or template. Anything you do not grant, like creating proposals or adding fee line items, stays off limits to the agent.