QuickBooks MCP server for AI agents

Let Claude, ChatGPT or your own agent read QuickBooks: 28 typed functions through one MCP server. No QuickBooks API key needed.

Functions
28
Sign-in
Not needed
Works with
MCP, HTTP, Node, Python

Connect

Just QuickBooks

An MCP server for QuickBooks alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/quickbooks
Every site

One MCP server for QuickBooks and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 28
  • calculateEmployeeCostEstimates the full yearly cost of one employee (salary plus payroll taxes, benefits and overhead) the way /r/employee-cost-calculator/ does.

    Arguments

    NameTypeRequired
    payType"hourly" | "salary"
    "hourly" (default) or "salary".
    No
    ratenumber
    Hourly rate, or the annual salary when payType is "salary".
    Yes
    hoursPerWeeknumber
    Hours worked per week; required when payType is "hourly".
    No
    statestring
    State name or two-letter code, e.g. "Texas" or "TX".
    Yes
    retirementContributionnumber
    Employer retirement contribution for the year.
    No
    healthnumberNo
    dentalnumberNo
    visionnumberNo
    otherExpenses{ label?: string; amount: number }[]No

    Returns QuickbooksEmployeeCost

    interface QuickbooksEmployeeCost {
      state: string;
      payType: "hourly" | "salary";
      annualWages: number;
      medicare: number;
      socialSecurity: number;
      futa: number;
      suta: number;
      payrollTaxes: number;
      retirement: number;
      insurance: number;
      otherExpenses: number;
      totalAnnualCost: number;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/calculateEmployeeCost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.calculateEmployeeCost({
      payType: "hourly",
      rate: 25,
      hoursPerWeek: 40,
      state: "TX"
    });
  • calculatePaycheckComputes a US employee's take-home pay for one paycheck from gross pay, pay frequency, state, federal filing status and W-4 entries, returning…

    Arguments

    NameTypeRequired
    statestring
    Two-letter USPS code of the state the work is performed in, e.g. "CA".
    Yes
    grossPaynumber
    Gross pay for ONE pay period, in dollars.
    Yes
    payFrequency"weekly" | "biweekly" | "semimonthly" | "monthly" | "quarterly" | "semiannually" | "annually"
    How often the employee is paid; sets the annualization QuickBooks uses.
    Yes
    federalFilingStatus"single" | "marriedFilingJointly" | "headOfHousehold"
    The employee's federal Form W-4 filing status.
    Yes
    zipcodestring
    ZIP code, for the handful of states and cities that tax by locality.
    No
    citystringNo
    countystringNo
    federalExemptionsnumber
    Pre-2020 Form W-4 allowances. 0 (the default) is correct for a current-style W-4.
    No
    federalAdditionalWithholdingnumber
    Extra federal income tax withheld per paycheck, in dollars.
    No
    stateFilingStatusstring
    The state's OWN filing-status code.
    No
    stateExemptionsnumber
    State withholding allowances.
    No
    stateAdditionalWithholdingnumber
    Extra state income tax withheld per paycheck, in dollars.
    No
    grossYTDnumber
    Gross pay already paid this year before this check.
    No
    payDatestring
    The pay date, as YYYY-MM-DD.
    No

    Returns QuickbooksPaycheckResult

    /** One withholding line QuickBooks' paycheck calculator returns, "CA Income Tax",
     * "Social Security" and so on, the site's own labels. */
    interface QuickbooksPaycheckTaxLine {
      code: string;
      label: string;  // the site's own labels, read the values off a result, never guess one from prose
      amount: number;
    }
    
    interface QuickbooksPaycheckResult {
      grossPay: number;
      employeeTaxes: QuickbooksPaycheckTaxLine[];
      /** `grossPay` minus every employee tax line. */
      netPay: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/calculatePaycheck

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.calculatePaycheck({
      state: "WA",
      grossPay: 2000,
      payFrequency: "biweekly",
      federalFilingStatus: "single"
    });
  • findAccountantsSearches the QuickBooks ProAdvisor directory for certified accountants and bookkeepers near a city, ZIP or address, optionally filtered by industry…

    Arguments

    NameTypeRequired
    argsstring | QuickbooksFindAccountantsArgsYes
    interface QuickbooksFindAccountantsArgs {
      /** A city and state, ZIP or street address, e.g. "Austin, TX" or "80202". */
      location: string;
      /** Search radius in miles, 1-500. Default 25. */
      radiusMiles?: number;
      /** 1-50, default 10. */
      limit?: number;
      /** The `nextCursor` a previous page returned. */
      cursor?: string;
    }

    Returns QuickbooksAccountantSearch

    /** One ProAdvisor search result. Call `getAccountant` with its `searchId`. */
    interface QuickbooksAccountantSummary {
      searchId: string;
      name: string | null;
      firm: string | null;
      summary: string | null;
      city: string | null;
      state: string | null;
      zipCode: string | null;
      distanceMiles: number | null;
      /** The directory's own service codes, e.g. "BOOKKEEPING_US". */
      services: string[];
      professionalDesignations: string[];
      /** Certification abbreviations, e.g. "QBOADV". */
      certifications: string[];
      /** 0 = offers a free consultation. */
      consultationPrice: number | null;
      rating: number | null;
      reviewCount: number;
      profileUrl: string;
    }
    
    interface QuickbooksAccountantSearch {
      totalCount: number;
      accountants: QuickbooksAccountantSummary[];
      /** Pass back as `cursor` for the next page; null on the last one. */
      nextCursor: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/findAccountants

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.findAccountants({ location: "Austin, TX", limit: 5 });
  • generateInvoiceBuilds an invoice PDF (seller, customer, line items, tax, discount) the way QuickBooks' free invoice generator (/invoice-generator/) does, and saves…

    Arguments

    NameTypeRequired
    fromQuickbooksInvoicePartyYes
    billToQuickbooksInvoicePartyYes
    itemsQuickbooksInvoiceLineItem[]Yes
    invoiceNumberstring
    Default "1001".
    No
    datestring
    YYYY-MM-DD; default today (UTC).
    No
    dueDatestring
    YYYY-MM-DD.
    No
    taxRatenumber
    Percent of the subtotal after discount, e.g. 8.25.
    No
    discountnumber
    Flat amount off the subtotal before tax.
    No
    currencystring
    ISO 4217, default "USD".
    No
    notesstringNo
    termsstringNo

    Returns QuickbooksGeneratedInvoice

    /** A file saved to the run's files, a presigned `url` until `expiresAt`. */
    interface QuickbooksSavedFile {
      id: string;
      name: string;
      contentType: string;
      bytes: number;
      url: string;
      expiresAt: string;
      keepUntil?: string | null;
    }
    
    interface QuickbooksGeneratedInvoice {
      invoiceNumber: string;
      date: string;
      dueDate: string | null;
      currency: string;
      items: { description: string; quantity: number; rate: number; amount: number }[];
      subtotal: number;
      discount: number;
      tax: number;
      total: number;
      /** The PDF in the run's files; absent when the run has no file store. */
      file?: QuickbooksSavedFile;
      pdfBytes: number;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/generateInvoice

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.generateInvoice({
      from: { name: "Northwind Supply" },
      billTo: { name: "Contoso Ltd" },
      items: [{ description: "Consulting", quantity: 2, rate: 150 }],
      taxRate: 10
    });
  • getAccountantReads one ProAdvisor's public profile by the searchId findAccountants returns (or the proadvisor.intuit.com profile URL): firm, bio, services…

    Arguments

    NameTypeRequired
    searchIdstringYes

    Returns QuickbooksAccountant

    interface QuickbooksAccountantReview {
      id: string;
      title: string | null;
      text: string | null;
      rating: number | null;
      recommended: boolean | null;
      reviewer: string | null;
      date: string | null;
      services: string[];
      /** The ProAdvisor's own replies. */
      replies: { text: string; date: string | null }[];
    }
    
    /** One ProAdvisor's public profile. */
    interface QuickbooksAccountant {
      searchId: string;
      name: string | null;
      firm: string | null;
      summary: string | null;
      website: string | null;
      phones: { type: string | null; number: string; extension: string | null }[];
      city: string | null;
      state: string | null;
      zipCode: string | null;
      services: string[];
      industries: string[];
      /** Product codes, e.g. "QBO_US". */
      softwareExpertise: string[];
      languages: string[];
      professionalDesignations: string[];
      certifications: { name: string; advanced: boolean | null; expired: boolean | null }[];
      yearsInBusiness: number | null;
      numberOfPartners: number | null;
      consultationPrice: number | null;
      socialLinks: { name: string | null; url: string }[];
      rating: number | null;
      reviewCount: number;
      ratings: {
        responsiveness: number | null;
        professionalism: number | null;
        expertise: number | null;
        helpfulness: number | null;
      };
      /** Up to the 100 newest reviews. */
      reviews: QuickbooksAccountantReview[];
      profileUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getAccountant

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getAccountant("<searchId>");
  • getAppReads one App Store listing by the id a searchApps result returns: full description, developer, categories, use cases, rating, review count, badges…

    Arguments

    NameTypeRequired
    idstringYes

    Returns QuickbooksApp

    /** One App Store listing as the search index returns it. Call `getApp` with its `id`. */
    interface QuickbooksAppSummary {
      /** Algolia's own id for this listing, pass verbatim to `getApp`. */
      id: string;
      name: string;
      shortName: string;
      developer: string | null;
      tagline: string | null;
      rating: number;
      reviewCount: number;
      /** Whether the App Store marks this a paid listing, the search index carries
       * no price, so this is the closest thing to a pricing summary it offers. */
      premium: boolean;
      logoUrl: string | null;
      supportedEditions: string[];
      url: string;
    }
    
    /** One App Store listing's full detail. */
    interface QuickbooksApp extends QuickbooksAppSummary {
      description: string | null;
      overview: string | null;
      /** The human-facing categories this listing's own page shows (e.g. "Send
       * Invoices"), narrower than the search index's internal category enum,
       * which `searchApps` does not expose. Often empty. */
      categories: string[];
      /** What the App Store says this app helps a QuickBooks user DO (e.g.
       * "Invoicing", "Payment"). */
      useCases: string[];
      badges: string[];
      builtByIntuit: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getApp

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getApp("<id>");
  • getEventReads one Community event's title, start and end time (with the site's own UTC offset), attendance mode (online or in-person) and description, off…

    Arguments

    NameTypeRequired
    slugstringYes

    Returns QuickbooksEvent

    /** One Community event's detail. */
    interface QuickbooksEvent {
      title: string;
    
      startDate: string | null;
      endDate: string | null;
      /** "online" or "in-person". */
      attendanceMode: string | null;
      description: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getEvent

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getEvent("accounting-101-77");
  • getHelpArticleReads one QuickBooks help article as text: title, the steps, which QuickBooks products it applies to, and when it was updated.

    Arguments

    NameTypeRequired
    urlstringYes

    Returns QuickbooksHelpArticle

    /** One QuickBooks help article's detail. */
    interface QuickbooksHelpArticle {
      title: string;
      /** The article's steps and explanatory text, in reading order, with HTML
       * stripped, one entry per paragraph, heading or list item. */
      content: string[];
      /** The QuickBooks products and editions this article is tagged under, in
       * the site's own words (e.g. "QuickBooks Online Plus"). */
      products: string[];
      updatedAt: string | null;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getHelpArticle

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getHelpArticle("/learn-support/en-us/help-article/invoicing/automatically-invoice-unbilled-time-activities/L0M6412kT_US_en_US");
  • getPayrollPlansLists the QuickBooks Payroll plans (Core, Premium, Elite) with monthly base price, per-employee price, promotional price and what each plan includes…

    Arguments

    None.

    Returns QuickbooksPayrollPlan[]

    /** One QuickBooks Payroll bundle (payroll plus a QuickBooks Online plan) off /payroll/pricing/. */
    interface QuickbooksPayrollPlan {
      id: string;
      name: string;
      tagline: string | null;
      /** Monthly base price in dollars, before per-employee charges. */
      monthlyPrice: number | null;
      promoPrice: number | null;
      promoPercentOff: number | null;
      promoDuration: string | null;
      /** The monthly charge per employee paid, in dollars. */
      perEmployeePrice: number | null;
      features: string[]; // "Full service payroll", "Same-day direct deposit"
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getPayrollPlans

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getPayrollPlans();
  • getPlansLists the QuickBooks Online plans (Solopreneur, Simple Start, Essentials, Plus, Advanced) with each plan's monthly list price, any current…

    Arguments

    None.

    Returns QuickbooksPlan[]

    /** One QuickBooks Online plan as the /pricing/ shopping widget lists it. */
    interface QuickbooksPlan {
      id: string;
      name: string;
      tagline: string | null;
      /** Monthly list price in dollars; null for Free and the quote-only Enterprise Suite. */
      monthlyPrice: number | null;
      /** The promotional monthly price, when a promotion runs. */
      promoPrice: number | null;
      promoPercentOff: number | null;
      /** How long the promotion lasts, e.g. "3 months". */
      promoDuration: string | null;
      /** The plan's user allowance as the card words it, e.g. "3 users". */
      users: string | null;
      usersNote: string | null;
      recommended: boolean;
      features: string[]; // "Run enhanced reports", "Automated bookkeeping"
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getPlans

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getPlans();
  • getResourceArticleReads one Resource Center article (/r/<topic>/<slug>/) as text with its title, author and date.

    Arguments

    NameTypeRequired
    urlstringYes

    Returns QuickbooksResourceArticleDetail

    /** One Resource Center article's text, as getResourceArticle reads it. */
    interface QuickbooksResourceArticleDetail {
      title: string;
      author: string | null;
      publishedAt: string | null;
      updatedAt: string | null;
      /** Body paragraphs, headings and list items in reading order. */
      content: string[];
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getResourceArticle

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getResourceArticle("/r/accounting/quick-ratio/");
  • getServiceStatusReturns QuickBooks' current service status per region and component (operational, degraded, outage) and any open incident, from…

    Arguments

    None.

    Returns QuickbooksServiceStatus

    /** One component on status.quickbooks.intuit.com, a region under a product. */
    interface QuickbooksStatusComponent {
      product: string | null;
      region: string;
      status: string;  // the site's own labels, read the values off a result, never guess one from prose
    }
    
    interface QuickbooksServiceStatus {
      indicator: string;
      description: string;
      updatedAt: string | null;
      components: QuickbooksStatusComponent[];
      openIncidents: { id: string; name: string; status: string; impact: string; url: string | null }[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getServiceStatus

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getServiceStatus();
  • getStatePayrollTaxesReturns one US state's income-tax rate range as /payroll/tools/tax-map/'s own state selector carries it (e.g. "2.0 - 5.0%", or "0%" for a state with…

    Arguments

    NameTypeRequired
    statestringYes

    Returns QuickbooksStateIncomeTaxRange

    /** One US state's income-tax rate range off the payroll tax-map page. */
    interface QuickbooksStateIncomeTaxRange {
      code: string;
      name: string;
      /** e.g. "2.0 - 5.0%", or "0%" for a state with no income tax. */
      incomeTaxRate: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getStatePayrollTaxes

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getStatePayrollTaxes("CA");
  • getThreadReads one Community thread's question and its accepted (or top suggested) answer, with author, date and whether it's the accepted solution, off the…

    Arguments

    NameTypeRequired
    urlstringYes

    Returns QuickbooksThread

    /** One reply on a Community thread. */
    interface QuickbooksThreadAnswer {
      text: string;
      author: string | null;
      authorUrl: string | null;
      postedAt: string | null;
      /** Whether this is the asker's (or a moderator's) marked solution, vs. just the top reply. */
      accepted: boolean;
      url: string | null;
    }
    
    /** One Community thread's question and (at most) one reply, the thread page's
     * own structured data carries no more than that, however many replies the
     * thread actually has (see answerCount). */
    interface QuickbooksThread {
      title: string;
      question: string;
      askedBy: string | null;
      askedByUrl: string | null;
      askedAt: string | null;
      upvoteCount: number;
      answerCount: number;
      answer: QuickbooksThreadAnswer | null;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getThread

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getThread("/community/banking-50/problems-with-open-banking-376230");
  • getTimeTrackingPlansLists the QuickBooks Time plans (Premium, Elite) and the two Payroll Workforce bundles that include Time, with each plan's monthly base fee, per-user…

    Arguments

    None.

    Returns QuickbooksTimeTrackingPlan[]

    /** One QuickBooks Time plan off /time-tracking/pricing/ (the page also sells Time inside two
     * Payroll "Workforce" bundles, returned here too with "bundle: true"). */
    interface QuickbooksTimeTrackingPlan {
      id: string;
      name: string;
      tagline: string | null;
      /** True when the plan is a Payroll bundle that includes Time, not Time on its own. */
      bundle: boolean;
      /** Monthly base fee in dollars (Time's includes one admin). */
      monthlyPrice: number | null;
      promoPrice: number | null;
      promoPercentOff: number | null;
      promoDuration: string | null;
      /** The monthly charge per extra user (Time) or per employee (bundle), in dollars. */
      perUserPrice: number | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/getTimeTrackingPlans

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.getTimeTrackingPlans();
  • listAppCategoriesLists the QuickBooks App Store's categories (e.g. Invoicing and Payments, Inventory, Team and Payroll) with each one's en-us listing count and the…

    Arguments

    None.

    Returns QuickbooksAppCategory[]

    interface QuickbooksAppCategory {
      /** Pass to searchApps({ category }). */
      slug: string; // "INVOICING_AND_PAYMENTS"
      label: string; // "Invoicing and Payments"
      appCount: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listAppCategories

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listAppCategories();
  • listAppReviewsLists the user reviews on one App Store listing by the id searchApps or getApp returns, newest first, with each review's rating, title, text, date…

    Arguments

    NameTypeRequired
    argsstring | QuickbooksListAppReviewsArgsYes
    /** One App Store category. */
    interface QuickbooksListAppReviewsArgs {
      /** The `id` a searchApps or getApp result returns. */
      id: string;
      /** 1-50, default 10. */
      limit?: number;
      /** Newest reviews to skip, for paging. Default 0. */
      offset?: number;
    }

    Returns QuickbooksAppReviews

    interface QuickbooksAppReview {
      id: string;
      title: string | null;
      text: string | null;
      rating: number | null;
      date: string | null;
      reviewer: string | null;
      reviewerLocation: string | null;
      recommended: boolean | null;
      developerResponses: { text: string; date: string | null; team: string | null }[];
      comments: { text: string; date: string | null; author: string | null }[];
    }
    
    interface QuickbooksAppReviews {
      totalReviews: number;
      averageRating: number | null;
      ratingDistribution: { rating: number; count: number }[];
      reviews: QuickbooksAppReview[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listAppReviews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listAppReviews("<args>");
  • listBoardThreadsLists one Community board's threads, most-recently-active first, with title, snippet, URL, author, reply count, views and solved state.

    Arguments

    NameTypeRequired
    argsstring | QuickbooksListBoardThreadsArgsYes
    interface QuickbooksListBoardThreadsArgs {
      /** A board slug listCommunityBoards returns, e.g. "banking-50". */
      board: string;
      /** 1-based page of results. Default 1. */
      page?: number;
      /** How many threads to return, 1-25 (default 25). */
      limit?: number;
    }

    Returns QuickbooksBoardThread[]

    /** One thread on a Community board, as `listBoardThreads` lists it. Call
     * `getThread` with its `url` for the full question and answer. */
    interface QuickbooksBoardThread {
      /** The thread's public id, the number at the end of its URL. */
      id: string;
      title: string;
      /** The question's opening text, as the board page's own preview shows it. */
      snippet: string;
      url: string;
      /** The site's own content-type label: "question", "discussion", "idea",
       * "bug" or "productUpdate". */
      contentType: string;
      author: string | null;
      replyCount: number;
      views: number;
      /** Whether the thread has an accepted answer. */
      solved: boolean;
      publishedAt: string | null;
      lastActivityAt: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listBoardThreads

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listBoardThreads("banking-50");
  • listCommunityBoardsLists the Community's boards and topic areas with their URLs, so a caller can browse a topic or pass a board slug alongside a thread lookup.

    Arguments

    None.

    Returns QuickbooksCommunityBoard[]

    /** One QuickBooks Community board or topic area. */
    interface QuickbooksCommunityBoard {
      /** The board's own id segment, e.g. "banking-50", what a thread's URL carries. */
      slug: string;
      title: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listCommunityBoards

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listCommunityBoards();
  • listEventsLists upcoming QuickBooks Community events and webinars by slug and URL, off the site's own sitemap.xml.

    Arguments

    None.

    Returns QuickbooksCommunityEvent[]

    /** One upcoming Community event or webinar, as listEvents finds it. Call
     * getEvent with its slug or URL for the title, date and description. */
    interface QuickbooksCommunityEvent {
      slug: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listEvents

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listEvents();
  • listFeaturedAccountantsLists the ProAdvisors QuickBooks features on a state's /find-an-accountant/<state>/ page, with name, city and searchId, so a caller holding only a…

    Arguments

    NameTypeRequired
    statestringYes

    Returns QuickbooksFeaturedAccountant[]

    /** One ProAdvisor a state's /find-an-accountant/<state>/ page features. */
    interface QuickbooksFeaturedAccountant {
      name: string;
      firm: string | null;
      location: string | null;
      rating: number | null;
      reviewCount: number | null;
      badge: string | null;
      /** The searchId getAccountant takes. */
      searchId: string | null;
      profileUrl: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listFeaturedAccountants

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listFeaturedAccountants("Texas");
  • listIncidentsLists QuickBooks' recent service incidents with their status updates, affected components and start and resolve times.

    Arguments

    NameTypeRequired
    limitnumber
    How many of the most recent incidents to return, 1-50 (default 20).
    No

    Returns QuickbooksIncident[]

    interface QuickbooksIncident {
      id: string;
      name: string;
      status: string;  // the site's own labels, read the values off a result, never guess one from prose
      impact: string;
      startedAt: string | null;
      resolvedAt: string | null;
      url: string | null;
      components: string[];
      updates: { status: string; body: string; at: string | null }[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listIncidents

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listIncidents({ limit: 5 });
  • listPaycheckCalculatorStatesLists the US states with their own paycheck calculator page (/payroll/paycheck-calculator/<state>/), by two-letter code, with each page's URL.

    Arguments

    None.

    Returns QuickbooksPaycheckCalculatorState[]

    /** One US state with its own /payroll/paycheck-calculator/<state>/ page. */
    interface QuickbooksPaycheckCalculatorState {
      code: string;
      name: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listPaycheckCalculatorStates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listPaycheckCalculatorStates();
  • listResourceArticlesLists articles in the QuickBooks Resource Center (/r/) for a topic (accounting, taxes, payroll, cash flow, starting a business…) with title, slug and…

    Arguments

    NameTypeRequired
    argsstring | QuickbooksListResourceArticlesArgsYes
    /** listResourceArticles' argument: a topic slug, and optionally a page. */
    interface QuickbooksListResourceArticlesArgs {
      /** e.g. "accounting", "taxes", "payroll", "cash-flow", "starting-a-business". */
      topic: string;
      /** 1-based listing page. Default 1. */
      page?: number;
    }

    Returns QuickbooksResourceArticle[]

    /** One Resource Center article, as listResourceArticles finds it. */
    interface QuickbooksResourceArticle {
      title: string;
      topic: string;
      slug: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listResourceArticles

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listResourceArticles("accounting");
  • listTemplatesLists QuickBooks' free downloadable invoice and timesheet templates (Word, Excel and PDF), from /payments/invoicing/templates/ and…

    Arguments

    None.

    Returns QuickbooksTemplate[]

    /** One QuickBooks downloadable business template. */
    interface QuickbooksTemplate {
      category: "invoice" | "timesheet";
      name: string;
      format: "pdf" | "docx" | "xlsx" | "pptx";
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/listTemplates

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.listTemplates();
  • searchAppsSearches the QuickBooks App Store for apps that connect to QuickBooks, by keyword and optionally one category slug from listAppCategories, returning…

    Arguments

    NameTypeRequired
    querystring | QuickbooksSearchAppsArgsYes
    interface QuickbooksSearchAppsArgs {
      /** Keyword, narrowed by `category` when one is given. */
      query: string;
      /** How many results to return, 1-75 (default 20). */
      limit?: number;
      /** A `slug` listAppCategories returns, e.g. "INVENTORY". */
      category?: string;
    }

    Returns QuickbooksAppSummary[]

    /** One App Store listing as the search index returns it. Call `getApp` with its `id`. */
    interface QuickbooksAppSummary {
      /** Algolia's own id for this listing, pass verbatim to `getApp`. */
      id: string;
      name: string;
      shortName: string;
      developer: string | null;
      tagline: string | null;
      rating: number;
      reviewCount: number;
      /** Whether the App Store marks this a paid listing, the search index carries
       * no price, so this is the closest thing to a pricing summary it offers. */
      premium: boolean;
      logoUrl: string | null;
      supportedEditions: string[];
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/searchApps

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.searchApps("invoicing");
  • searchCommunitySearches QuickBooks Community (the Intuit-run user forum) for questions matching a phrase and returns each thread's title, snippet, board (when…

    Arguments

    NameTypeRequired
    querystring | QuickbooksSearchCommunityArgsYes
    interface QuickbooksSearchCommunityArgs {
      query: string;
      /** 1-based page of results. Default 1. */
      page?: number;
      /** How many results to return, 1-10 (default 10). */
      limit?: number;
    }

    Returns QuickbooksCommunitySearchResult[]

    /** One Community search result. */
    interface QuickbooksCommunitySearchResult {
      title: string;
      snippet: string;
      url: string;
      /** The board slug, when the URL is one `getThread` can read. Null on an
       * older URL shape this provider does not otherwise parse. */
      board: string | null;
      /** Whether the thread has an accepted answer. */
      solved: boolean;
      createdAt: string | null;
      updatedAt: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/searchCommunity

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.searchCommunity("payroll tax");
  • searchHelpArticlesSearches the QuickBooks help center (/learn-support/en-us/) for articles matching a question and returns each article's title, URL and snippet.

    Arguments

    NameTypeRequired
    querystring | QuickbooksSearchHelpArticlesArgsYes
    interface QuickbooksSearchHelpArticlesArgs {
      query: string;
      page?: number;
      /** How many results to return, 1-10 (default 10). */
      limit?: number;
    }

    Returns QuickbooksHelpArticleSummary[]

    /** One help-center search result. Call `getHelpArticle` with its `url`. */
    interface QuickbooksHelpArticleSummary {
      title: string;
      url: string;
      snippet: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/quickbooks/searchHelpArticles

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.quickbooks.searchHelpArticles("void an invoice");

Use it from code