Skip to main content

TurboQuote SDK

Agent Skill

Let an agent scaffold this for you

Install the TurboDocx Quickstart Skill and let Claude Code, Cursor, Copilot, Codex, or any agent that speaks the Agent Skills standard install the SDK, wire it into your app, and write a working TurboQuote integration end-to-end.

Skill countView on GitHubFull install guide →
bash — turbodocx
$npx skills add TurboDocx/quickstart
# then, inside your agent:›/turbodocx-sdk turboquote

The official TurboDocx TurboQuote SDK for Node.js and browser applications. Build quoting and CPQ (configure-price-quote) workflows: create and send quotes, manage line items, maintain a product and bundle catalog, apply price books, and handle the full quote lifecycle — all with zero runtime dependencies and complete TypeScript types. Available on npm as @turbodocx/sdk (same package as TurboSign and TurboWebhooks).


What is TurboQuote?

TurboQuote is TurboDocx's quoting and CPQ module. Quotes progress through a lifecycle: draft → pending_approval → sent → accepted / declined / voided. A draft can also be marked declined directly, for a deal that dies before the quote is ever sent. Each quote belongs to a company and contact, carries line items (individual products or bundles), and can optionally have a price book applied. Accepted quotes can be merged with a TurboDocx Deliverable (e.g. a contract generated from a template) and sent for e-signature through TurboSign via sendQuoteWithDeliverable.

Installation​

npm install @turbodocx/sdk

Requirements​

  • Node.js 18 or higher (native fetch)
  • TypeScript 4.7+ (optional, for type checking — declaration files are included)
  • Zero runtime dependencies — the SDK uses only Node built-ins

Configuration​

import { TurboQuote } from '@turbodocx/sdk';

TurboQuote.configure({
  apiKey: process.env.TURBODOCX_API_KEY!,
  orgId: process.env.TURBODOCX_ORG_ID,   // optional — falls back to env var
  // accessToken: process.env.TURBODOCX_ACCESS_TOKEN,  // optional — OAuth token instead of apiKey
});
No senderEmail on the client — but set one on your quote template

Unlike TurboSign, TurboQuote.configure() does not require senderEmail or senderName — quotes are not sent as signature emails. Only a credential is required — either apiKey or an OAuth accessToken (accessToken wins when both are set); orgId is recommended but falls back to TURBODOCX_ORG_ID. If you skip configure() entirely, the SDK auto-initialises from environment variables on the first method call.

The quote's "Prepared by" sender comes from your org quote template instead. Because an API key has no mailbox of its own, if the org's quote template has no sender email set, createQuote, duplicateQuote, sendQuote / sendQuoteWithDeliverable, and handleExpiredQuote still succeed: they fall back to a generic TurboDocx sender (no-reply@turbodocx.com) rather than rejecting the call. Configure both Sender Name and Sender Email once (const tmpl = await TurboQuote.getTemplate(); await TurboQuote.updateTemplate(tmpl.id, { senderEmail, senderName });) so quotes show your own sender identity instead of the generic fallback.

Environment Variables​

TURBODOCX_API_KEY=your_api_key_here
TURBODOCX_ORG_ID=your_org_id_here
# optional — defaults to https://api.turbodocx.com
TURBODOCX_BASE_URL=https://api.turbodocx.com

Quick Start​

The most common flow: create a quote for a company and contact, add a product line item, then send it.

import { TurboQuote } from '@turbodocx/sdk';
import { writeFileSync } from 'node:fs';

TurboQuote.configure({
  apiKey: process.env.TURBODOCX_API_KEY!,
  orgId: process.env.TURBODOCX_ORG_ID,
});

// 1. Create a draft quote
const quote = await TurboQuote.createQuote({
  name: 'Acme Corp — Enterprise Plan',
  companyId: 'company-uuid',
  contactId: 'contact-uuid',
  currency: 'USD',
  termDays: 30,
});

// 2. Add a product line item
await TurboQuote.addLineItems(quote.id, {
  productId: 'product-uuid',
  productName: 'Enterprise Licence',
  unitPrice: 1200,
  billingFrequency: 'annual',
  quantity: 5,
});

// 3. Send the quote
const { quote: sentQuote, message } = await TurboQuote.sendQuote(quote.id, {
  validUntil: '2026-07-31',
});
console.log(message);           // "Quote sent successfully"
console.log(sentQuote.status);  // "sent"

// 4. Download the PDF
const pdf = await TurboQuote.downloadQuotePdf(sentQuote.id);
writeFileSync('quote.pdf', Buffer.from(pdf));

1. Create a company, quote, and add line items​

import com.turbodocx.TurboQuoteClient;
import com.turbodocx.TurboQuote;
import com.turbodocx.TurboDocxException;
import com.turbodocx.models.quote.*;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;

public class QuoteLifecycle {
    public static void main(String[] args) throws Exception {
        TurboQuoteClient client = new TurboQuoteClient.Builder()
            .apiKey(System.getenv("TURBODOCX_API_KEY"))
            .orgId(System.getenv("TURBODOCX_ORG_ID"))
            .build();

        TurboQuote tq = client.turboQuote();

        // Step 1: Create a company with an initial contact
        CreateCompanyContactInput contact = new CreateCompanyContactInput();
        contact.setName("Alice Buyer");
        contact.setEmail("alice@example.com");

        CreateCompanyRequest companyReq = new CreateCompanyRequest();
        companyReq.setName("Acme Corp");
        companyReq.setContacts(Arrays.asList(contact));

        Company company = tq.createCompany(companyReq);
        ContactListResponse contacts = tq.listCompanyContacts(company.getId());
        String contactId = contacts.getResults().get(0).getId();

        // Step 2: Create a quote
        CreateQuoteRequest quoteReq = new CreateQuoteRequest();
        quoteReq.setName("Q1 Software License");
        quoteReq.setCompanyId(company.getId());
        quoteReq.setContactId(contactId);
        quoteReq.setTermDays(30);
        quoteReq.setCurrency(Currency.USD);

        Quote quote = tq.createQuote(quoteReq);
        System.out.println("Quote: " + quote.getId() + " status=" + quote.getStatus());

        // Step 3: Add a line item.
        // productId, productName, unitPrice and billingFrequency are all required.
        // productId may be null (custom line item), but must always be set.
        AddLineItemRequest item = new AddLineItemRequest();
        item.setProductId("product-uuid");
        item.setProductName("Enterprise Software License");
        item.setUnitPrice(1200.00);
        item.setQuantity(3.0);
        item.setBillingFrequency("annual");
        item.setDiscountType(DiscountType.PERCENT);
        item.setDiscountPercent(10.0);

        List<LineItem> lineItems = tq.addLineItems(quote.getId(), item);
        System.out.println("Added " + lineItems.size() + " line item(s)");

        // Step 4: Send the quote
        SendQuoteResponse sent = tq.sendQuote(quote.getId());
        System.out.println("Sent. Status: " + sent.getQuote().getStatus());

        // Step 5: Download the PDF
        byte[] pdf = tq.downloadQuotePdf(quote.getId());
        Files.write(Paths.get("quote.pdf"), pdf);
        System.out.println("PDF saved (" + pdf.length + " bytes)");
    }
}

2. Create and send in one call​

createAndSend is a convenience method that creates the quote, adds line items and bundle items, and sends it atomically.

CreateAndSendRequest req = new CreateAndSendRequest();
req.setName("Partner Proposal");
req.setCompanyId(companyId);
req.setContactId(contactId);

AddLineItemRequest item = new AddLineItemRequest();
item.setProductId("product-uuid");     // required — null for a custom line item
item.setProductName("Starter Plan");
item.setUnitPrice(499.00);
item.setQuantity(1.0);
item.setBillingFrequency("monthly");   // required
req.setItems(Arrays.asList(item));

// req.setSend(...) to configure send options, or omit to use defaults

CreateAndSendResponse result = tq.createAndSend(req);
System.out.println("Quote created and sent: " + result.getQuote().getId());

3. Apply a price book, then send with a deliverable​

// Apply a price book to recalculate line item prices
ApplyPriceBookResponse applied = tq.applyPriceBook(quoteId, priceBookId);
System.out.println("Updated: " + applied.getUpdatedCount()
    + ", Skipped: " + applied.getSkippedCount());

// Send with a TurboDocx deliverable attached
SendQuoteWithDeliverableRequest sendReq = new SendQuoteWithDeliverableRequest();
sendReq.setDeliverableId("your-deliverable-id");
sendReq.setMergePosition("end");

SendQuoteWithDeliverableResponse sendResp = tq.sendQuoteWithDeliverable(quoteId, sendReq);
System.out.println("Document ID: " + sendResp.getDocumentId());

Create a quote, add line items, send, and download the PDF / Full quote lifecycle: create → add items → send → download PDF / Full lifecycle: create → add items → send → download PDF​

import asyncio
import os
from turbodocx_sdk import TurboQuote

TurboQuote.configure(
    api_key=os.environ["TURBODOCX_API_KEY"],
    org_id=os.environ["TURBODOCX_ORG_ID"],
)


async def full_quote_lifecycle():
    # 1. Create a draft quote
    quote = await TurboQuote.create_quote({
        "name": "Acme Corp — Annual Plan Q3",
        "companyId": "company-uuid",
        "contactId": "contact-uuid",
        "validUntil": "2026-09-30",
        "currency": "USD",
    })
    quote_id = quote["id"]
    print(f"Created quote {quote_id}")

    # 2. Add product line items
    items = await TurboQuote.add_line_items(quote_id, [
        {
            "productId": "product-uuid-1",
            "productName": "Platform License",
            "quantity": 5,
            "unitPrice": "199.00",
            "billingFrequency": "annual",
        },
        {
            "productId": "product-uuid-2",
            "productName": "Onboarding Package",
            "quantity": 1,
            "unitPrice": "499.00",
            "billingFrequency": "one-time",
        },
    ])
    print(f"Added {len(items)} line items")

    # 3. Apply a price book (optional)
    result = await TurboQuote.apply_price_book(quote_id, "pricebook-uuid")
    print(f"Price book applied: {result['updatedCount']} items updated")

    # 4. Send the quote
    sent = await TurboQuote.send_quote(quote_id, {
        "ccEmails": ["manager@acme.com"],
        "validUntil": "2026-09-30",
    })
    print(f"Sent: {sent['message']}")

    # 5. Download the PDF
    pdf_bytes = await TurboQuote.download_quote_pdf(quote_id)
    with open("acme-quote.pdf", "wb") as f:
        f.write(pdf_bytes)
    print(f"PDF saved ({len(pdf_bytes)} bytes)")


asyncio.run(full_quote_lifecycle())

Convenience: createAndSend / Convenience: create, add items, and send in one call / Convenience: CreateAndSend​

createAndSend combines quote creation, line item addition, and sending into a single call.

const { quote } = await TurboQuote.createAndSend({
  name: 'Acme Corp — Starter',
  companyId: 'company-uuid',
  contactId: 'contact-uuid',
  currency: 'USD',
  termDays: 30,
  items: [
    { productId: null, productName: 'Setup Fee', unitPrice: 500, billingFrequency: 'one-time' },
    { productId: 'product-uuid', productName: 'Monthly Subscription', unitPrice: 99, billingFrequency: 'monthly', quantity: 10 },
  ],
  send: { validUntil: '2026-07-31' },
});
console.log(quote.status); // "sent"

Method Reference​

All methods are static on the TurboQuote class. Configure once, then call on the class directly.

Quotes / Quotes — CRUD​

listQuotes / list_quotes / ListQuotes​

List quotes with optional pagination and filters. Returns totals and pipeline stats alongside results.

const { results, totalRecords, stats } = await TurboQuote.listQuotes({
  limit: 20,
  offset: 0,
  statuses: ['draft', 'sent'],   // string or string[]
  companyId: 'company-uuid',
  currency: 'USD',
});
// stats.total, stats.winRate, stats.monthlyRecurringRevenue, ...

for (const q of results) {
  console.log(q.name, q.status);
}

createQuote / create_quote / CreateQuote​

Create a new quote in draft status.

// Fixed-term quote — termDays 0–3650, no renewalPeriod (0 = one-time, -1 = auto-renewal)
const quote = await TurboQuote.createQuote({
  name: 'Q3 Renewal',           // required
  companyId: 'company-uuid',    // required
  contactId: 'contact-uuid',    // required
  currency: 'USD',              // 'USD'|'EUR'|'GBP'|'CAD'|'AUD'|'INR'
  termDays: 30,                 // fixed term in days — omit to get the default of 60
  validUntil: '2026-09-30',
  taxRate: 8.5,
  priceBookId: 'pb-uuid',
});

// Auto-renewal quote — termDays: -1 REQUIRES renewalPeriod, and renewalPeriod is ONLY valid
// when termDays is -1. Pairing renewalPeriod with a fixed term (e.g. termDays: 30) returns a 400.
const subscription = await TurboQuote.createQuote({
  name: 'Annual Subscription',
  companyId: 'company-uuid',
  contactId: 'contact-uuid',
  currency: 'USD',
  termDays: -1,                 // -1 = auto-renewal
  renewalPeriod: 'annually',    // 'weekly'|'monthly'|'quarterly'|'annually'
});
termDays and renewalPeriod are coupled

termDays defaults to 60 when omitted. Valid values are -1 (auto-renewal) or 0–3650 (0 = one-time).

renewalPeriod is required when termDays is -1, and must be null or absent for every other termDays value — sending it alongside a fixed term returns a 400. The same rule applies on updateQuote.

getQuote / get_quote / GetQuote​

Fetch a single quote. The returned object includes a statusInfo field with transition flags (canSend, canAccept, canDecline, canVoid) and a preparedBy object — the resolved "Prepared by" identity shown on the quote PDF.

const quote = await TurboQuote.getQuote('quote-uuid');
console.log(quote.statusInfo?.canSend);     // true when status is 'draft'
console.log(quote.statusInfo?.canDecline);  // also true when status is 'draft'
console.log(quote.preparedBy?.name);     // e.g. "Acme Billing Integration" or the template sender
console.log(quote.preparedBy?.email);    // may be undefined for an API-created quote — render a placeholder

preparedBy is resolved server-side (org template first, then the quote's creator). Prefer it over creator for any customer-facing display — creator may be the internal API service account. For an API-created quote the resolved name is the API key's name (never a generic "API Service User"), and the email comes from the org quote template. preparedBy is returned by the single-quote fetch only — it is not present on create, duplicate, or list responses.

updateQuote / update_quote / UpdateQuote​

Patch any combination of quote fields. Pass null to clear nullable fields (renewalPeriod, validUntil, taxRate, priceBookId).

const updated = await TurboQuote.updateQuote('quote-uuid', {
  name: 'Q3 Renewal — Revised',
  taxRate: null,       // clears the tax rate
});
name is trimmed, and renaming is draft-only

name is trimmed on both createQuote and updateQuote — ' Acme ' is stored as 'Acme' — and a name that is empty once trimmed returns a 400. A quote can only be renamed while it is a draft; on any other status the update is rejected with Cannot update quote that is not in draft status (templateId is the only field exempt from that rule). Rename before you send, because sending snapshots the quote's current name onto the TurboSign document — that is the name signers see in the request email and on the signed PDF.

deleteQuote / delete_quote / DeleteQuote​

Soft-delete a quote.

const { message } = await TurboQuote.deleteQuote('quote-uuid');

duplicateQuote / duplicate_quote / DuplicateQuote​

Copy a quote (and its line items) into a new draft.

const copy = await TurboQuote.duplicateQuote('quote-uuid');

The copy is named Copy of <original name>, truncated to the name column's 255-character limit. Rename it with updateQuote before sending if that is not what you want signers to see.

The copy is attributed to whoever ran the duplicate, not to the original quote's creator — duplicating with an API key produces a quote whose "Prepared by" resolves through that API key and your org quote template.

applyPriceBook / apply_price_book / ApplyPriceBook​

Apply a price book to all line items on a quote. Returns the updated quote plus counts of how many items were updated vs skipped.

const { quote, updatedCount, skippedCount, message } = await TurboQuote.applyPriceBook(
  'quote-uuid',
  'pricebook-uuid',
);

removePriceBook / remove_price_book / RemovePriceBook​

Detach the price book from a quote (line item prices are not reverted).

const quote = await TurboQuote.removePriceBook('quote-uuid');

downloadQuotePdf / download_quote_pdf / DownloadQuotePdf​

Download the quote as a PDF. Returns raw bytes as an ArrayBuffer.

const pdf = await TurboQuote.downloadQuotePdf('quote-uuid');
writeFileSync('quote.pdf', Buffer.from(pdf));

Quote Numbering Configuration​

Customize the per-org quote number format: prefix, year/month tokens, separator, zero-padding, suffix, starting number, and reset cadence. Both methods are admin only; a non-admin API key receives a 403.

getQuoteNumberConfig / get_quote_number_config / GetQuoteNumberConfig​

Fetch the org's current quote numbering format and the current per-period issued floor.

const config = await TurboQuote.getQuoteNumberConfig();
console.log(config.format.prefix);   // e.g. "Q-"
console.log(config.currentFloor);    // the current per-period issued floor

updateQuoteNumberConfig / update_quote_number_config / UpdateQuoteNumberConfig​

Update the numbering format. Pass the full format object; all eight fields are required.

const config = await TurboQuote.updateQuoteNumberConfig({
  prefix: 'INV',
  yearToken: 'none',      // 'none' | 'two' | 'four'
  monthToken: 'off',      // 'off' | 'two'
  separator: '-',
  padWidth: 4,            // 0–12
  suffix: '',
  startNumber: 1000,      // >= 0
  resetCadence: 'never',  // 'never' | 'yearly' | 'monthly'
});
console.log(config.format.startNumber);  // 1000

Field reference, defaults & validation​

All eight format fields are sent on every update. The API enforces these caps and allowed values — a violation returns 400:

FieldTypeAllowed / rangeDefault
prefixstring≤ 12 characters"Q"
yearTokenenumnone | two | fourfour
monthTokenenumoff | twooff
separatorstring≤ 4 characters"-"
padWidthinteger0–12 (0 = no padding)5
suffixstring≤ 12 characters""
startNumberinteger0–10000000001
resetCadenceenumnever | yearly | monthlyyearly

An org that has never configured numbering uses the default format above, which renders like Q-2026-00001.

Beyond the per-field caps, the API rejects self-inconsistent formats with a 400:

  • resetCadence: "yearly" requires a year token (yearToken other than none) — otherwise numbers repeat across years.
  • resetCadence: "monthly" requires both a year token and a month token (monthToken: "two").
  • The rendered quote number must be ≤ 256 characters.

currentFloor (returned by both methods) is read-only — the sequence the next quote will use for the current period — and is never sent on update.

Quote Status Transitions / Quotes — Status Transitions​

Send preconditions

Both send methods share the same server-side checks. Each is rejected with HTTP 400 and a specific error code before anything is created or emailed:

ConditionCode
Quote is not a draftQuoteNotSendable
No validUntil date setQuoteValidUntilRequired
validUntil is in the pastQuoteExpired
No line itemsQuoteHasNoLineItems
Contact missing a name or emailQuoteContactRequired
Company or contact deleted/deactivatedQuoteCustomerInactive

A quote with no line items cannot be sent — add at least one product, bundle, or custom line item first. Likewise an expired quote is rejected; update validUntil, or use the handle-expired flow to void it and create a fresh draft.

sendQuote / send_quote / SendQuote​

Send a draft quote to the contact. Optionally include CC recipients, set a validity deadline, or attach a reminder & expiration schedule.

const { quote, message } = await TurboQuote.sendQuote('quote-uuid', {
  validUntil: '2026-07-31',
  ccEmails: ['manager@example.com'],

  // Optional reminder & expiration schedule (same shape as TurboSign sendSignature)
  remindersEnabled: true,
  reminderDelay: { value: 3, unit: 'days' },     // { value, unit } — 'hours' | 'days'
  reminderInterval: { value: 3, unit: 'days' },
  maxReminders: 5,                               // -1 unlimited, 0 none, max 50
  expirationEnabled: true,                       // toggles expiry on/off
  expirationWarning: { value: 3, unit: 'days' },
  expirationWarningInterval: { value: 1, unit: 'days' },
});
Quote expiry is pinned to validUntil

For a quote, the signing deadline is hard-pinned to the quote's validUntil date — you do not set expireAfter. expirationEnabled still toggles whether the signing window closes at all, but when it's on, the deadline is validUntil (any expireAfter you pass is ignored). The reminder and expiration-warning cadence still applies, and it must fit inside the validUntil window — a cadence that would outlive the quote's validity is rejected with a 400.

sendQuoteWithDeliverable / send_quote_with_deliverable / SendQuoteWithDeliverable​

Send a quote paired with a TurboDocx deliverable (e.g., a contract generated from a template). The deliverable is merged before or after the quote PDF. It accepts the same reminder & expiration schedule as sendQuote (expiry pinned to validUntil, per the note above).

const { quote, message, documentId } = await TurboQuote.sendQuoteWithDeliverable(
  'quote-uuid',
  {
    deliverableId: 'deliverable-uuid',
    mergePosition: 'end',   // 'beginning' | 'end'
    ccEmails: ['legal@example.com'],

    // Optional — same schedule fields as sendQuote
    remindersEnabled: true,
    reminderDelay: { value: 3, unit: 'days' },
    expirationEnabled: true,
  },
);
// documentId — TurboSign document created for the merged PDF

Reminders and expiration when sending a quote / Reminders and expiration on quote sends / Reminders and expiration on send / Reminders and expiration on a quote send​

Both send_quote and send_quote_with_deliverable accept the same reminder/expiration schedule as TurboSign. Because these are quote request-body fields, the keys are camelCase (like ccEmails / validUntil above), even though the method names are snake_case:

sent = await TurboQuote.send_quote("quote-uuid", {
    "validUntil": "2026-09-30",
    "remindersEnabled": True,
    "reminderDelay": {"value": 3, "unit": "days"},     # {value, unit}: "days" or "hours"
    "reminderInterval": {"value": 3, "unit": "days"},
    "maxReminders": 5,                                  # -1 unlimited, 0 none, max 50
    "expirationEnabled": True,
    "expirationWarning": {"value": 1, "unit": "days"},  # 0 = never warn
    "expirationWarningInterval": {"value": 1, "unit": "days"},
})
Quote expiry is pinned to validUntil

For a quote, the signing deadline is hard-pinned to the quote's validUntil date. Any expireAfter you pass is ignored — expirationEnabled still toggles expiry on or off, but when on, the document expires exactly at validUntil. The reminder and expiration-warning cadence still applies and must fit inside the validUntil window; a cadence that would outlive the quote is rejected with 400. Duration values are {value, unit} ("days" or "hours"), min 1, max 999 days / 23976 hours.

declineQuote / decline_quote / DeclineQuote​

Mark a quote as declined — either a sent quote (typically on behalf of the recipient) or a draft whose deal died before it was ever sent.

reason (max 190 characters) is required once a quote has been sent — declining a sent quote without one returns 400 CANNOT_DECLINE_QUOTE. A draft is declined without a reason: the reason is stored on the quote's linked signature document, and a draft has none, so any reason passed for a draft is accepted by the API and not recorded.

const quote = await TurboQuote.declineQuote('quote-uuid', {
  reason: 'Budget constraints for this quarter',
});

// A draft is declined with no reason — one passed here would not be recorded.
const closedOut = await TurboQuote.declineQuote('draft-quote-uuid', {});

voidQuote / void_quote / VoidQuote​

Void a sent quote that should no longer be valid; a draft cannot be voided, since voiding an unsent quote is meaningless.

const quote = await TurboQuote.voidQuote('quote-uuid', {
  reason: 'Superseded by revised quote #Q-102',
});

handleExpiredQuote / handle_expired_quote / HandleExpiredQuote​

Handle a quote that has passed its validUntil date. The endpoint closes out the original quote — voiding or declining it depending on action — and then creates a duplicate draft carrying newValidUntil as its new validity date. The returned quote is the new duplicate; the original stays terminal.

action ('void', 'decline' or 'renew') and newValidUntil (ISO date) are required. reason (≤ 190 characters) is required for 'void' and 'decline', and optional for 'renew' — a renewal closes nothing out, so there is nothing to give a reason for. Use 'renew' when the quote's signature request has already expired on its own; use 'void' or 'decline' when the quote is merely past its validUntil and you are closing it yourself.

const quote = await TurboQuote.handleExpiredQuote('quote-uuid', {
  action: 'void',                 // 'void' | 'decline' | 'renew'
  reason: 'Expired — re-quoting',  // required for void/decline, optional for renew
  newValidUntil: '2026-08-31',    // required, ISO date carried onto the duplicate
});
There is no extend or resend action

action accepts only "void", "decline" and "renew". "extend" and "resend" do not exist in the API and return a 400. Extending is what the endpoint already does for you — pass newValidUntil and it lands on the duplicate it creates.

The replacement draft keeps the original name

Unlike duplicateQuote, the draft this endpoint creates is not prefixed with Copy of — re-issuing the same deal keeps the original quote's name, so repeated renewals cannot compound into Copy of Copy of …. That matters because the next send snapshots the name onto the TurboSign document.

Price Books (on a Quote) / Price Books on Quotes​

Applying and removing a price book on a quote is documented with the other quote methods: see applyPriceBook and removePriceBook.

Line Items​

Line items attach products or bundles to a quote, each with a price, quantity, billing frequency, and optional discount.

listLineItems / list_line_items / ListLineItems​

const { results, totalRecords } = await TurboQuote.listLineItems('quote-uuid', {
  limit: 50,
  billingFrequency: 'monthly',
});

addLineItems / add_line_items / AddLineItems​

Add one or more product line items. Pass a single object or an array of up to 50 items.

productId, productName, unitPrice, and billingFrequency are all required on every item. productId is special: the key must be present, but its value may be null for a custom (freeform) line item. Omitting the key entirely returns a 400. quantity is optional and defaults to 1.

// Single item
await TurboQuote.addLineItems('quote-uuid', {
  productId: 'product-uuid',       // required key — pass null for a custom (freeform) line item
  productName: 'Professional Services',
  unitPrice: 150,
  billingFrequency: 'one-time',
  quantity: 8,
  discountPercent: 10,
  discountType: 'percent',
});

// Multiple items at once — array is capped at 50 items
await TurboQuote.addLineItems('quote-uuid', [
  { productId: 'p1', productName: 'Licence A', unitPrice: 500, billingFrequency: 'annual' },
  { productId: 'p2', productName: 'Licence B', unitPrice: 300, billingFrequency: 'annual' },
  { productId: null, productName: 'Custom Discount Credit', unitPrice: -100, billingFrequency: 'one-time' },
]);
Array caps

addLineItems accepts a single object or an array of 1–50 items. A reorder request accepts up to 200 items. Exceeding either cap returns a 400.

addBundleLineItems / add_bundle_line_items / AddBundleLineItems​

Add one or more bundle line items.

await TurboQuote.addBundleLineItems('quote-uuid', {
  bundleId: 'bundle-uuid',
  bundleName: 'Starter Bundle',
  quantity: 2,
  showItemsToEndUser: true,
});

updateLineItem / update_line_item / UpdateLineItem​

Update a single line item's price, quantity, discount, or billing frequency.

const updated = await TurboQuote.updateLineItem('quote-uuid', 'item-uuid', {
  quantity: 12,
  discountPercent: 15,
  billingFrequency: 'monthly',
});

removeLineItem / remove_line_item / RemoveLineItem​

Remove a line item from a quote.

const { message } = await TurboQuote.removeLineItem('quote-uuid', 'item-uuid');

Products​

Manage your product catalog. Products can include images (uploaded as multipart form data — the SDK detects the MIME type from magic bytes automatically).

MethodSignatureReturns
listProducts(opts?) → ProductListResponsePaginated list + catalog stats
createProduct(req) → ProductCreated product
getProduct(id) → ProductSingle product
updateProduct(id, req) → ProductUpdated product
deleteProduct(id) → SuccessResponseMessage
duplicateProduct(id) → ProductNew duplicate
getProductPrimaryImages(productIds[]) → { [id]: ProductImage | null }Primary image map
// Create a product with an image
const product = await TurboQuote.createProduct({
  name: 'Enterprise Licence',
  listPrice: 1200,
  billingFrequency: 'annual',
  categoryId: 'category-uuid',
  sku: 'ENT-001',
  showInCatalog: true,
  images: ['/path/to/product-image.png'],  // file path, Buffer, or File object
});

// List with filters
const { results, totalProducts } = await TurboQuote.listProducts({
  categoryIds: ['cat-1', 'cat-2'],
  billingFrequency: 'monthly',
  showInCatalog: true,
});

// Fetch primary images for multiple products at once
const images = await TurboQuote.getProductPrimaryImages(['p-uuid-1', 'p-uuid-2']);
// images['p-uuid-1'] → ProductImage | null

ListProducts​

list, err := qc.ListProducts(ctx, &turbodocx.ListProductsOptions{
    Query: &[]string{"license"}[0],
})
// list.Results        []Product
// list.TotalProducts  int
// list.CatalogValue   float64

CreateProduct​

price := 99.99
product, err := qc.CreateProduct(ctx, &turbodocx.CreateProductRequest{
    Name:             "Starter License",
    ListPrice:        price,
    BillingFrequency: "monthly",
    CategoryID:       "category-uuid",
})

For products with images, set Images []ProductImageInput (supports FilePath or Data bytes) — the SDK automatically uses multipart upload:

product, err := qc.CreateProduct(ctx, &turbodocx.CreateProductRequest{
    Name:             "Starter License",
    ListPrice:        99.99,
    BillingFrequency: "monthly",
    CategoryID:       "category-uuid",
    Images: []turbodocx.ProductImageInput{
        {FilePath: "/path/to/logo.png"},
    },
})

GetProduct / DeleteProduct / DuplicateProduct​

product, err := qc.GetProduct(ctx, "product-uuid")
result,  err := qc.DeleteProduct(ctx, "product-uuid")
copy,    err := qc.DuplicateProduct(ctx, "product-uuid")

UpdateProduct​

PATCH semantics with Clear* helpers: ClearCost, ClearSku, ClearDescription, ClearDetailedSpecification, ClearInternalNotes. Supports image uploads via Images.

newPrice := 109.99
product, err := qc.UpdateProduct(ctx, "product-uuid", &turbodocx.UpdateProductRequest{
    ListPrice: &newPrice,
})

GetProductPrimaryImages​

Returns a ProductPrimaryImagesResponse (map[string]*ProductImage) keyed by product ID.

images, err := qc.GetProductPrimaryImages(ctx, []string{"product-uuid-1", "product-uuid-2"})
if img, ok := images["product-uuid-1"]; ok && img != nil {
    fmt.Println(img.FileName)
}

Bundles​

Bundles group multiple products into a single purchasable unit with optional bundle-level discounts.

MethodSignatureReturns
listBundles(opts?) → BundleListResponsePaginated list + stats
createBundle(req) → BundleCreated bundle
getBundle(id) → BundleSingle bundle
updateBundle(id, req) → BundleUpdated bundle
deleteBundle(id) → SuccessResponseMessage
duplicateBundle(id) → BundleNew duplicate
const bundle = await TurboQuote.createBundle({
  name: 'Starter Pack',
  categoryId: 'category-uuid',
  currency: 'USD',
  showInCatalog: true,
  syncWithProducts: true,
  items: [
    { productId: 'p1', unitPrice: 200, billingFrequency: 'monthly', quantity: 1 },
    { productId: 'p2', unitPrice: 50,  billingFrequency: 'monthly', quantity: 3 },
  ],
});

Price Books​

Price books let you define alternative pricing tiers. When a price book is applied to a quote, matching product line items are repriced automatically.

MethodSignatureReturns
listPriceBooks(opts?) → PriceBookListResponsePaginated list + stats
createPriceBook(req) → PriceBookCreated price book
getPriceBook(id) → PriceBookSingle price book
updatePriceBook(id, req) → PriceBookUpdated price book
deletePriceBook(id) → SuccessResponseMessage
duplicatePriceBook(id) → PriceBookNew duplicate
listPriceBookProducts(id, opts?) → PaginatedResponse<PriceBookProductPricing>Per-product pricing
const pb = await TurboQuote.createPriceBook({
  name: 'Partner Tier',
  priceBookTypeId: 'type-uuid',
  validFrom: '2026-01-01',
  validTo: '2026-12-31',
  discountPercent: 20,
  isDefault: false,
  showInQuoteBuilder: true,
  productPricing: [
    { productId: 'p1', discountPercent: 25, finalPrice: 900 },
  ],
});

// Apply to a quote
const { updatedCount, skippedCount } = await TurboQuote.applyPriceBook(
  'quote-uuid',
  pb.id,
);

Companies​

Companies represent the buyer organisations your quotes are addressed to. Each company must have at least one contact.

MethodSignatureReturns
listCompanies(opts?) → CompanyListResponsePaginated list
createCompany(req) → CompanyCreated company
getCompany(id) → CompanySingle company
updateCompany(id, req) → CompanyUpdated company
deleteCompany(id) → SuccessResponseMessage
listCompanyContacts(companyId, opts?) → ContactListResponseCompany's contacts
const company = await TurboQuote.createCompany({
  name: 'Acme Corporation',
  phone: '+1-555-0100',
  city: 'San Francisco',
  state: 'CA',
  country: 'US',
  contacts: [
    { name: 'Alice Smith', email: 'alice@acme.example', title: 'VP of Engineering' },
  ],
});

const { results: contacts } = await TurboQuote.listCompanyContacts(company.id);

Contacts​

Contacts belong to a company and are the individuals a quote is addressed to.

No getContact endpoint

There is no getContact(id) method — the backend does not expose a GET /v1/contacts/:id route. Retrieve an individual contact via listContacts with a search query, or fetch all contacts for a company with listCompanyContacts.

MethodSignatureReturns
listContacts(opts?) → ContactListResponsePaginated list
createContact(req) → ContactCreated contact
updateContact(id, req) → ContactUpdated contact
deleteContact(id) → SuccessResponseMessage
const contact = await TurboQuote.createContact({
  name: 'Bob Jones',
  companyId: 'company-uuid',
  email: 'bob@acme.example',
  title: 'Procurement Manager',
});

const { results } = await TurboQuote.listContacts({ companyId: 'company-uuid' });

Quote Templates​

Quote templates control the visual presentation of the sent quote (logo, brand colours, disclaimer, terms, sender info). There is one active template per org, accessible via getTemplate(). You can also manage named templates.

Singleton vs. list

getTemplate() returns the org's single active template via GET /v1/quote-template (singular path). listTemplates() returns all named templates via GET /v1/quote-templates (plural path).

Templates are auto-provisioned — use getTemplate() → updateTemplate()

getTemplate() self-heals: if the org has no template, the API creates one from your org branding and returns it. Every established org therefore already has a template, which means:

  • createTemplate() returns 400 TEMPLATE_ALREADY_EXISTS and is effectively unreachable. Do not build a get-then-create flow.
  • deleteTemplate() is really "reset to org branding defaults" — it soft-deletes, and the next getTemplate() regenerates a fresh one.

The correct flow is getTemplate() → updateTemplate(tmpl.id, …).

MethodSignatureReturns
getTemplate() → QuoteTemplateActive org template (auto-created if none exists)
listTemplates(opts?) → QuoteTemplateListResponseAll named templates
getTemplateById(id) → QuoteTemplateNamed template by ID
createTemplate(req) → QuoteTemplateCreated template — 400 if one already exists
updateTemplate(id, req) → QuoteTemplateUpdated template
deleteTemplate(id) → SuccessResponseResets to org branding defaults
// 1. Fetch the active template — created from org branding on first read
const tmpl = await TurboQuote.getTemplate();
console.log(tmpl.primaryColor);  // e.g. "#1a73e8"

// 2. Brand it by updating the template you just fetched
const branded = await TurboQuote.updateTemplate(tmpl.id, {
  logoUrl: 'https://cdn.example.com/logo.png',
  primaryColor: '#0057b8',
  primaryTextColor: '#ffffff',
  disclaimer: 'Prices valid for 30 days.',
  termsAndConditions: 'See attached terms...',
  senderName: 'TurboDocx Sales',
  senderEmail: 'sales@example.com',
});

GetTemplate​

Returns the active (default) quote template for the org, creating one from org branding if none exists. Use this for the most common case.

tmpl, err := qc.GetTemplate(ctx)
fmt.Printf("Primary color: %s\n", tmpl.PrimaryColor)

GetTemplateByID​

Retrieves a specific template by ID when you have multiple templates.

tmpl, err := qc.GetTemplateByID(ctx, "template-uuid")

ListTemplates / UpdateTemplate / DeleteTemplate​

Brand the org's template by fetching it and updating it in place — never by creating one.

list, err := qc.ListTemplates(ctx, &turbodocx.PaginationParams{
    Limit: &[]int{5}[0],
})

// Get the auto-provisioned template, then update it.
tmpl, err := qc.GetTemplate(ctx)

logoURL := "https://cdn.example.com/logo.png"
tmpl, err = qc.UpdateTemplate(ctx, tmpl.ID, &turbodocx.UpdateQuoteTemplateRequest{
    LogoURL:      &logoURL,
    PrimaryColor: &[]string{"#0066CC"}[0],
    SenderName:   &[]string{"Sales Team"}[0],
})

// DeleteTemplate resets the org back to its branding defaults —
// the next GetTemplate call regenerates a fresh template.
result, err := qc.DeleteTemplate(ctx, tmpl.ID)

UpdateQuoteTemplateRequest has Clear* helpers: ClearLogoURL, ClearDisclaimer, ClearTermsAndConditions, ClearClosingMessage, ClearSenderName, ClearSenderPhone, ClearContactEmail.

Types (Categories) / Types / Categories​

Types are reusable category/classification values used across products, bundles, price books, and companies (e.g., industry tags, price book types).

No getType endpoint

There is no getType(id) method — the backend does not expose GET /v1/types/:id. Use listTypes to retrieve individual types.

MethodSignatureReturns
listTypes(opts?) → QuoteTypeListResponsePaginated list
createType(req) → QuoteTypeCreated type
updateType(id, req) → QuoteTypeUpdated type
deleteType(id) → SuccessResponseMessage
const type = await TurboQuote.createType({
  name: 'Software',
  categoryType: 'product_category',  // 'product_category'|'pricebook_type'|'company_industry'|'bundle_category'
});

const { results } = await TurboQuote.listTypes({
  categoryType: 'company_industry',
  includeUsage: true,
});

Bulk Imports​

Every create-family entity has a matching bulkCreate* method for seeding a catalog or migrating CRM data in one call. Each method sends POST {resource}/bulk with an array of rows using the same shape as that entity's single-create request (e.g. bulkCreateProducts takes CreateProductRequest[]). Company rows require a contacts array with at least one contact; contact rows require a companyId.

Rows process sequentially with partial success — a failed row does not throw and does not roll back earlier rows. Every bulk method resolves to a BulkImportResult:

  • imported — count of rows created
  • failed — array of { row, reason } for rows that did not import; row is the 1-indexed position in your request array
  • adjusted — array of { row, reason } for rows that imported with a server-side adjustment (e.g. a bundle item whose product wasn't found was dropped)

Requests are capped at 500 rows — anything above the cap returns a 400. Available to admin and contributor API keys.

Product rows require a real categoryId

Every bulkCreateProducts row requires name, categoryId, listPrice, and billingFrequency. categoryId must be the UUID of an existing type (categoryType: 'product_category') — there is no categoryName field on the bulk row, and the API rejects unknown keys, so passing one returns a 400. Resolve or create the category first with listTypes / createType, then pass its id.

// 1. Resolve the product category first — bulk rows need its UUID, not its name.
const { results: categories } = await TurboQuote.listTypes({ categoryType: 'product_category' });
const category =
  categories.find((t) => t.name === 'Software') ??
  (await TurboQuote.createType({ name: 'Software', categoryType: 'product_category' }));

// 2. Import, passing the resolved UUID on every row.
const result = await TurboQuote.bulkCreateProducts([
  { name: 'Enterprise Licence', categoryId: category.id, listPrice: 1200, billingFrequency: 'annual' },
  { name: 'Onboarding Package', categoryId: category.id, listPrice: 499, billingFrequency: 'one-time' },
]);

console.log(`Imported ${result.imported} of 2 rows`);
for (const failure of result.failed) {
  console.error(`Row ${failure.row} failed: ${failure.reason}`);
}
for (const adjustment of result.adjusted) {
  console.warn(`Row ${adjustment.row} imported with adjustment: ${adjustment.reason}`);
}

The other five bulk methods follow the exact same pattern:

MethodArgumentReturns
bulkCreatePriceBooksCreatePriceBookRequest[]BulkImportResult
bulkCreateBundlesCreateBundleRequest[]BulkImportResult
bulkCreateCompaniesCreateCompanyRequest[] — each row needs contacts (min. 1)BulkImportResult
bulkCreateContactsCreateContactRequest[] — each row needs companyIdBulkImportResult
bulkCreateTypesCreateQuoteTypeRequest[]BulkImportResult

bulkCreateProducts​

BulkImportResult bulkCreateProducts(List<CreateProductRequest> rows)
Product rows require a real categoryId

Every bulkCreateProducts row requires name, categoryId, listPrice, and billingFrequency. categoryId must be the UUID of an existing type (CategoryType.PRODUCT_CATEGORY) — there is no categoryName field on the bulk row schema, and the API rejects unknown keys, so sending one returns a 400. Resolve or create the category first with listTypes / createType, then pass its ID.

// 1. Resolve the product category first — bulk rows need its UUID, not its name.
ListTypesOptions typeOpts = new ListTypesOptions();
typeOpts.setCategoryType(CategoryType.PRODUCT_CATEGORY);

String categoryId = tq.listTypes(typeOpts).getResults().stream()
    .filter(t -> "Software".equals(t.getName()))
    .map(QuoteType::getId)
    .findFirst()
    .orElseGet(() -> {
        CreateQuoteTypeRequest typeReq = new CreateQuoteTypeRequest();
        typeReq.setName("Software");
        typeReq.setCategoryType(CategoryType.PRODUCT_CATEGORY);
        try {
            return tq.createType(typeReq).getId();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });

// 2. Import, passing the resolved UUID on every row.
CreateProductRequest row1 = new CreateProductRequest();
row1.setName("Enterprise License");
row1.setCategoryId(categoryId);
row1.setListPrice(1200.00);
row1.setBillingFrequency("annual");

CreateProductRequest row2 = new CreateProductRequest();
row2.setName("Onboarding Package");
row2.setCategoryId(categoryId);
row2.setListPrice(499.00);
row2.setBillingFrequency("one-time");

BulkImportResult result = tq.bulkCreateProducts(Arrays.asList(row1, row2));

System.out.println("Imported " + result.getImported() + " of 2 rows");
for (BulkImportRowIssue failure : result.getFailed()) {
    System.err.println("Row " + failure.getRow() + " failed: " + failure.getReason());
}
for (BulkImportRowIssue adjustment : result.getAdjusted()) {
    System.out.println("Row " + adjustment.getRow()
        + " imported with adjustment: " + adjustment.getReason());
}

The other five bulk methods follow the exact same pattern:

MethodRowsReturns
bulkCreatePriceBooksList<CreatePriceBookRequest>BulkImportResult
bulkCreateBundlesList<CreateBundleRequest>BulkImportResult
bulkCreateCompaniesList<CreateCompanyRequest> — each row needs contacts (min. 1)BulkImportResult
bulkCreateContactsList<CreateContactRequest> — each row needs companyIdBulkImportResult
bulkCreateTypesList<CreateQuoteTypeRequest>BulkImportResult

Enums and Constants​

TypeValues
QuoteStatusdraft, pending_approval, sent, accepted, declined, voided
BillingFrequencymonthly, quarterly, annual, one-time
LineItemTypeproduct, bundle
RenewalPeriodweekly, monthly, quarterly, annually
CurrencyUSD, EUR, GBP, CAD, AUD, INR
CategoryTypeproduct_category, pricebook_type, company_industry, bundle_category
BundleItemStatusactive, product_deleted, product_unavailable, currency_mismatch
DiscountTypepercent, amount
Terminal statuses

accepted, declined, and voided are terminal — a quote in one of these states cannot be transitioned out of it, and any further status call returns a 400. Check quote.StatusInfo.IsTerminal (and the Can* flags) before attempting a transition, and use DuplicateQuote when you need to revive a closed-out quote.

Null-Clear Semantics (PATCH)​

Go's zero value is indistinguishable from "not set" at the JSON level, so UpdateQuoteRequest and related PATCH request types use a private nullFields map to track fields the caller explicitly wants to set to null. Call the Clear* method on the request before passing it:

req := &turbodocx.UpdateQuoteRequest{}
req.ClearTaxRate()          // sends "taxRate": null  (removes tax from quote)
req.ClearRenewalPeriod()    // sends "renewalPeriod": null
// Name left unset — omitted from payload entirely
quote, err := qc.UpdateQuote(ctx, "quote-uuid", req)

Types with Clear* helpers:

TypeClearable fields
UpdateQuoteRequestPriceBookID, ValidUntil, TaxRate, RenewalPeriod
UpdateLineItemRequestCost, CategoryID, CategoryName, ProductSku, ProductDescription, DisplayOrder
UpdateProductRequestCost, Sku, Description, DetailedSpecification, InternalNotes
UpdatePriceBookRequestDescription, ValidTo
UpdateBundleRequestDescription, Sku, CategoryID
UpdateCompanyRequestPhone, City, State, Country, IndustryID
UpdateContactRequestEmail, Phone, Title
UpdateQuoteTemplateRequestLogoURL, Disclaimer, TermsAndConditions, ClosingMessage, SenderName, SenderPhone, ContactEmail

Convenience / Convenience Method​

create_and_send / createAndSend​

Orchestrates multiple API calls: create quote → add product items → add bundle items → send. Returns {"quote": <sent Quote>}.

result = await TurboQuote.create_and_send({
    # CreateQuote fields
    "name": "Year-End Renewal",
    "companyId": "company-uuid",
    "contactId": "contact-uuid",
    "currency": "USD",
    # optional line items added before send
    "items": [
        {"productId": "product-uuid-1", "productName": "Platform License", "quantity": 10, "unitPrice": "99.00", "billingFrequency": "monthly"},
    ],
    # optional bundle items added before send
    "bundleItems": [
        {"bundleId": "bundle-uuid-1", "bundleName": "Starter Pack", "quantity": 1},
    ],
    # send options (ccEmails, validUntil)
    "send": {
        "ccEmails": ["finance@example.com"],
        "validUntil": "2026-12-31",
    },
})
print(result["quote"]["id"])

TypeScript Types​

Key types exported from @turbodocx/sdk:

import type {
  // Core quote
  Quote,
  QuoteStatusInfo,
  CreateQuoteRequest,
  UpdateQuoteRequest,
  ListQuotesOptions,
  QuoteListResponse,
  SendQuoteRequest,
  SendQuoteWithDeliverableRequest,
  DeclineQuoteRequest,
  VoidQuoteRequest,
  HandleExpiredQuoteRequest,
  ApplyPriceBookResponse,
  CreateAndSendRequest,
  // Line items
  LineItem,
  AddLineItemRequest,
  AddBundleLineItemRequest,
  UpdateLineItemRequest,
  ListLineItemsOptions,
  // Products
  Product,
  CreateProductRequest,
  UpdateProductRequest,
  ListProductsOptions,
  // Bundles
  Bundle,
  CreateBundleRequest,
  UpdateBundleRequest,
  // Price books
  PriceBook,
  CreatePriceBookRequest,
  // Companies & contacts
  Company,
  CreateCompanyRequest,
  Contact,
  CreateContactRequest,
  // Templates & types
  QuoteTemplate,
  QuoteType,
  // Enums
  QuoteStatus,
  BillingFrequency,
  Currency,
  RenewalPeriod,
  LineItemType,
  DiscountType,
  CategoryType,
  // Shared
  SuccessResponse,
} from '@turbodocx/sdk';

Key Enum Values​

TypeValues
QuoteStatus'draft' 'pending_approval' 'sent' 'accepted' 'declined' 'voided'
BillingFrequency'monthly' 'quarterly' 'annual' 'one-time'
Currency'USD' 'EUR' 'GBP' 'CAD' 'AUD' 'INR'
RenewalPeriod'weekly' 'monthly' 'quarterly' 'annually'
DiscountType'percent' 'amount'
CategoryType'product_category' 'pricebook_type' 'company_industry' 'bundle_category'
Terminal statuses

accepted, declined, and voided are terminal — a quote in one of these states cannot be transitioned out of it, and any further status call returns a 400. Check quote.statusInfo (canSend, canAccept, canDecline, canVoid) before attempting a transition, and duplicateQuote when you need to revive a closed-out quote.

Error Handling​

import {
  TurboQuote,
  TurboDocxError,
  AuthenticationError,
  AuthorizationError,
  ValidationError,
  NotFoundError,
  RateLimitError,
  NetworkError,
} from '@turbodocx/sdk';

try {
  await TurboQuote.sendQuote('quote-uuid');
} catch (e) {
  if (e instanceof ValidationError) {
    // 400 — e.g. quote is not in draft status, missing required fields
    console.error('Validation failed:', e.message);
  } else if (e instanceof NotFoundError) {
    // 404 — quote, company, contact, or product does not exist
    console.error('Not found:', e.message);
  } else if (e instanceof AuthenticationError) {
    // 401 — bad or revoked API key
    console.error('Auth failed:', e.message);
  } else if (e instanceof AuthorizationError) {
    // 403 — API key does not have permission for this org
    console.error('Forbidden:', e.message);
  } else if (e instanceof RateLimitError) {
    // 429 — back off and retry
    console.error('Rate limited — retry after a moment');
  } else if (e instanceof NetworkError) {
    // request never reached the server
    console.error('Network error:', e.message);
  } else if (e instanceof TurboDocxError) {
    // catch-all for any other typed SDK error
    console.error(`Error ${e.statusCode}: ${e.message}`);
  } else {
    throw e;
  }
}

Common Error Codes / Error Code Reference / Error Types​

StatusClassWhen
400ValidationErrorInvalid request body, wrong quote status for transition
401AuthenticationErrorMissing or invalid API key
403AuthorizationErrorValid key without permission for this resource
404NotFoundErrorQuote, company, product, or contact not found
429RateLimitErrorRate limit exceeded — back off and retry

Runnable Examples / Runnable End-to-End Examples​

Validated end-to-end examples live in the SDK repo:

Run any example with:

export TURBODOCX_API_KEY=your_key
export TURBODOCX_ORG_ID=your_org_id
npx tsx examples/turboquote-basic.ts

See Also​

Last updated on