QuickBooks Make integrationAutomate QuickBooks with Make.

Create an Invoice writes a brand new invoice into your QuickBooks company, so the document is already there before anyone opens the app.

Something changed after the invoice was written. Update an Invoice reopens it and rewrites only the parts the scenario gives it.

Deleting is the one move you cannot walk back. Delete an Invoice takes the document out of the company file.

Reading beats guessing. Get an Invoice pulls one invoice you can already identify and hands its content to the rest of the scenario.

When you do not know which invoice you need, Search for Invoices goes through them and returns what matches.

Download an Invoice fetches the document as a file, ready to be pushed into a drive folder, an email or an archive.

The sending step itself can be automated. Send an Invoice asks QuickBooks to deliver the document to the client.

Money going out has its own document. Create a Bill records what a supplier charges you, inside QuickBooks, from data the scenario already carries.

Update a Bill edits a supplier bill that is already recorded, changing the parts you map into it and leaving the rest alone.

Delete a Bill takes a supplier bill out of QuickBooks for good.

One bill, all its details. Get a Bill retrieves a supplier bill you can point to and passes the content down the scenario.

Search for Bills goes through your supplier bills and brings back the ones that match what you asked for.

For a sale already paid, an invoice is the wrong document. Create a Sales Receipt records the sale and the payment in one move.

Update a Sales Receipt rewrites a receipt already stored in QuickBooks, touching only what the scenario maps into it.

Get a Sales Receipt returns the details of one receipt you can identify, which is usually the step before an email or a report.

Search for Sales Receipts sweeps your receipts and returns those matching your criteria, as bundles the next modules work through.

The receipt as a file, not as data. Download a Sales Receipt pulls the document so the scenario can store it or attach it somewhere.

Send a Sales Receipt has QuickBooks deliver the receipt to the customer, so the scenario ends with the proof in their inbox.

Before the invoice comes the quote. Create an Estimate builds one in QuickBooks from data the scenario is already holding.

Update an Estimate reworks a quote that is still open, replacing the parts the scenario maps and leaving everything else standing.

Delete an Estimate removes a quote from QuickBooks entirely.

Download an Estimate turns the quote into a file the scenario can pass on, attach or keep.

Send an Estimate asks QuickBooks to deliver the quote to the client, which closes the loop between the form and the mailbox.

Get an Estimate reads one quote and returns its content to the scenario.

Search for Estimates looks through your quotes and returns the ones that match, one bundle per result.

Create a Journal Entry posts an accounting entry directly, which is how a bookkeeper writes something the standard documents do not cover.

Update a Journal Entry changes an entry that already exists, following the same logic as the other update modules.

Delete a Journal Entry takes the entry out of QuickBooks.

Get a Journal Entry returns one entry and its content, ready for a check or a message.

Search for Journal Entries runs through the entries and returns those that match, which is how a scenario can audit its own work.

Create a Payment records money received against a customer in QuickBooks.

Update a Payment edits a payment already recorded, rewriting only the parts the scenario provides.

Download a Payment pulls the payment as a file the scenario can file away or attach to a message.

Send a Payment is listed in the QuickBooks doc without a description of its own, so treat it as the delivery step for a payment and confirm what it returns before building on it.

Search for Payments looks through the recorded payments and returns the matches.

Create a Deposit records money arriving in an account, the step that usually follows a batch of payments.

Update a Deposit corrects a deposit already in QuickBooks with the values the scenario maps into it.

Delete a Deposit removes the deposit from the company file.

Get a Deposit reads one deposit and hands its details over.

Search for Deposits returns the deposits matching your criteria, so a scenario can work through them one after another.

A credit memo is money you owe a customer back, recorded against their account. This module writes one into QuickBooks from the data your scenario already carries, so the balance is corrected without anyone opening the books.

A memo with the wrong figure gets corrected, not stacked with a second one next to it. Update a Credit Memo rewrites the one already in QuickBooks with the values you send.

This one takes a credit memo out of QuickBooks for good. It is the cleanup module for a duplicate, or for a test entry that was never meant to land in the live company file.

Reading without writing: Get a Credit Memo fetches one memo and hands its content to the next module, leaving QuickBooks exactly as it was.

A search comes back as a list, and each memo leaves the module as its own bundle, the packet of data that travels from one module to the next. Search for Credit Memos returns every memo that fits your criteria.

New client, new record. Create a Customer adds the contact to QuickBooks so the first invoice has somewhere to land.

Addresses move and billing contacts change. Update a Customer overwrites the record you point it at with the values your scenario carries, so the next invoice goes to the right place.

Plenty of scenarios open right here: Get a Customer pulls one customer record and passes its content along, touching nothing in QuickBooks.

Search for Customers goes through the customer list and returns the ones that match, each as a separate result for the module that follows.

A purchase order is what your company commits to buy from a supplier. This module files one in QuickBooks straight from the request that started the scenario.

Quantities shift and delivery dates slip. Update a Purchase Order carries those changes onto the order already recorded, so the paperwork matches what was really agreed.

Before a delivery is accepted, somebody has to know what was ordered. Get a Purchase Order brings one order up into the rest of the scenario.

Every order that fits your criteria comes out here, one at a time, ready for whatever the scenario does with them.

Order cancelled before it shipped? Delete a Purchase Order takes it out of QuickBooks so nobody works from a commitment that no longer exists.

Items are the products and services that end up on an invoice. Create an Item adds one to the QuickBooks catalog so it can be billed.

Prices move, and the catalog has to move with them. Update an Item rewrites an entry in place, so every invoice created afterwards bills the new figure instead of the old one.

One product, one read. Get an Item returns what QuickBooks knows about a single product or service and leaves the catalog alone.

Search for Items sweeps the catalog and returns each product or service that matches, one per result.

A supplier has to exist in QuickBooks before their first bill. Create a Vendor opens that record with what your scenario already knows about them.

Bank details, contact name, payment terms: when a supplier reports a change, this module writes it into their record instead of leaving it in someone's inbox.

Get a Vendor brings back one supplier record, which is often all a scenario needs to decide what happens next, and nothing in QuickBooks moves while it reads.

Supplier lists get messy over the years. Search for Vendors runs through yours and returns the records that match, one by one.

Not everything you attach is a file. Create a Text Attachment stores a written note in QuickBooks, so the comment travels with the accounting instead of staying in a chat thread.

Upload a File takes a document your scenario is carrying, a scanned receipt or a signed order, and drops it into QuickBooks.

The other direction: Download a File pulls a document out of QuickBooks and puts it in the scenario, ready for the module that archives or sends it.

Delete an Attachment removes a document or a note that was attached in QuickBooks, which keeps a record readable instead of buried under old files.

Search for Attachments lists the documents QuickBooks holds for what you ask about and passes them on one by one, so a scenario can count them, copy them elsewhere or spot the ones that never arrived.

A chart of accounts is a set of drawers. Create an Account opens a new one without a trip through the QuickBooks settings.

Renaming a drawer, sharpening its description: Update an Account edits an account already sitting in the chart.

Before writing anything, a scenario can check the ground. Get an Account returns what QuickBooks holds on a single account and changes none of it.

Rather than guessing, this module asks QuickBooks which accounts match and returns them to the scenario.

A purchase is money already spent, by card or in cash. Create a Purchase records it in QuickBooks instead of letting it surface at the end of the quarter.

Update a Purchase corrects an expense already recorded: the amount, the account it sits under, the note that goes with it.

The expense recorded twice is a classic, and Delete a Purchase is how a scenario takes one back out.

One expense, read back exactly as QuickBooks stored it. Get a Purchase hands it to the scenario when what comes next needs the real figures rather than the ones in the request that started everything.

Search for Purchases returns every expense that fits your criteria, each one as a result to work through.

Hours worked only become billable once they are recorded somewhere. Create a Time Activity writes the entry into QuickBooks from what your team already logs in another tool.

Three hours logged against the wrong job is a common mix-up. Update a Time Activity fixes the existing entry instead of leaving a second one beside it.

Get a Time Activity reads one time entry and passes it on, which answers most of what a scenario asks about a single job, without anyone opening the timesheet.

Hours come out in bulk here: Search for Time Activity returns every entry that matches, one result at a time.

The refund you agreed with a customer only counts once it sits in the books. This module writes it there, taking the customer and the amount from the module placed before it, so nobody keys the same decision in twice.

When the sum agreed with a customer moves after the receipt was recorded, this module rewrites the one that exists instead of stacking a second. Hand it the identifier of the receipt, map only what changed, and the account keeps a single clean record.

Pull one refund receipt back into the scenario when the numbers themselves matter. The module reads the record and lays its content out for whatever follows, a message to the finance team, a line in a tracker, a check before approval.

Nothing is written by this module. It runs your criteria over the refund receipts already in the account and comes back with zero, one or several of them, and the rest of the scenario decides what happens to them.

Every connection points at one QuickBooks company, and this module brings that company's details back into the run. Put it first in a scenario you are building, click Run once, and you see straight away whether Make is talking to the account you meant.

The catalogue of ready-made modules stops somewhere. This one carries on: with the same connection, your scenario reaches any endpoint of the QuickBooks API, the channel two programs use to talk to each other.

A charge paid by card still has to land in the accounts like any other. Create a Credit Card Payment records it in QuickBooks from what the previous module carries, so the card statement and the ledger stop drifting apart.

Delete a Payment does exactly what its name says, and QuickBooks does not give the record back. The careful build is a pair: Get a Payment first, so the scenario holds the detail of what it is about to remove, then the deletion on the same identifier.

What makes this module delicate is not the deletion itself, it is the module sitting in front of it. A search hands over every receipt that matches the criteria, and the deletion then fires on each one of them.

Sometimes a sales receipt exists twice, because a scenario ran again on the same data or because a colleague entered it by hand. Delete a Sales Receipt takes one of them out of QuickBooks, from the identifier you map into it, and that is final.

Timesheets pushed into QuickBooks by a scenario always end up producing the odd line too many. This module removes one logged activity, working from its identifier, and it acts on that entry only.

Reading one payment is all this module does. It brings the full record into the scenario, ready for the step after it, a control, an alert, a line in a report.