Salesforce n8n integrationAutomate Salesforce with n8n.

Writes a note on an existing account, so context sits on the record rather than in a private inbox.

• Account ID: the record the note belongs to, often {{ $json.id }} from an earlier Salesforce node.
• Title: required, and it is what a rep sees in the list, so make it specific.
• Body: optional, limited to 32 KB, which is far more than any meeting recap needs.
• Is Private: true restricts the note to its owner and to users holding the Modify All Data permission.

Inserts a new account and returns the created record, ID included, ready for the next node.

• Name: the only required field, capped at 255 characters.
• Additional Fields: 26 optional fields, among them Phone, Website, Industry, Annual Revenue, Number Of Employees, Owner and the whole Billing and Shipping address set.
• Custom Fields: sits inside Additional Fields and reaches the fields your admin added.

One operation that decides for itself: it looks for an existing account, updates it when there is a hit, and inserts a new one otherwise.

• Match Against: the field checked to see whether the account already exists, usually an external identifier your other system owns.
• Value to Match: the value looked up in that field for this item.
• Name: still required, because it is what a new record gets created with.

Removes an account from the org. There is no confirmation step in the node, so it runs the moment the workflow reaches it.

• Account ID: the record to delete. Pass an ID you just read in the same workflow rather than one stored elsewhere, since a stale ID will either fail or hit the wrong record.

Reads one account and returns its fields, which is the step most update workflows forget and then regret.

• Account ID: the record to read, typically carried over from a trigger item or from a search result.

Pulls a list of accounts in one execution, with a way to narrow both the rows and the columns.

• Return All: on, n8n walks the pages of the API until the list is exhausted; off, it stops at Limit.
• Limit: the maximum number of accounts returned when Return All is off.
• Fields: the fields to include, separated by commas. Ask for the five you need, not the whole record.
• Conditions: filters the accounts returned.

Returns an overview of the account object's metadata rather than account records. Nothing to configure, which makes it a quick way to look at how the object is actually built in your org.

Changes fields on an account that already exists, leaving everything you do not name untouched.

• Account ID: the record to modify.
• Update Fields: 27 fields available here, one more than on creation, since Name becomes editable rather than required.
• Owner Name or ID: reassigns the account, which is the field most territory workflows come down to.

Uploads a file and attaches it to a record. The file travels as binary data inside the workflow, so no intermediate storage is involved.

• Parent ID: the record the file hangs off, an account, a case, or anything else that accepts attachments.
• Name: shown as File Name, capped at 255 characters.
• Input Binary Field: the name of the binary field holding the file, which is data unless the node before it renamed the field.
• Is Private: true keeps the file visible only to its owner and administrators.

Detaches and deletes a file from the org, permanently.

• Attachment ID: identifies the file itself, not the record it is attached to. Read it from a listing step in the same workflow, because nothing in the parent record hands you that ID by itself.

Retrieves a single attachment from its identifier.

• Attachment ID: the file to read, usually an ID carried over from a listing step or from the trigger when an attachment event started the run.

Lists attachments, which is the practical way to find out what is filed where.

• Conditions: the filter that makes this operation useful, since an unfiltered list returns files from across the org.
• Return All: off by default, in which case Limit caps how many files come back.
• Fields: the columns to include, comma separated.

Hands back an overview of the attachment object's metadata. There is nothing to fill in: the operation takes no parameters at all, so it runs as a quick lookup rather than a query you have to shape.

Edits an existing attachment, either its metadata or the file itself.

• Attachment ID: the file to modify.
• Name: renames the file, still capped at 255 characters.
• Description: a text description, limited to 255 characters.
• Input Binary Field: supply it and the stored file is replaced by the binary coming in, which keeps the same attachment record instead of creating a second one.

Posts a comment on a case, which is how a workflow talks inside a support thread rather than around it.

• Case ID: the case receiving the comment.
• Comment Body: shown as Body in the node, the text of the comment.
• Is Published: true makes the comment visible to customers in the Self-Service portal, false keeps it internal. Read that one twice before sending a diagnostic message.

Opens a case in Salesforce from anything your workflow can reach, a form, a monitoring alert, an inbound email.

• Type Name or ID: the only required field, chosen from the list your org defines.
• Additional Fields: 17 optional fields, including Subject, Description, Priority, Status, Case Origin, Contact ID and Account ID.
• Supplied Email: the address captured at creation. It cannot be changed afterwards, so set it in this node rather than planning to fix it later.

Erases a case and, with it, the thread attached to it.

• Case ID: the case to remove. Build a filter before this node rather than after, because there is nothing to undo once the execution has passed it.

Loads one case with its current field values.

• Case ID: the case to read.

Brings back a list of cases, which is what reporting and backlog workflows run on.

• Return All: leave it off and the node stops at Limit, which is the usual reason a weekly report looks suspiciously flat.
• Limit: caps the number of cases returned.
• Conditions: narrows the list, by status or by owner for instance.
• Fields: the fields to include, separated by commas.

Describes the case object's metadata instead of returning cases, and takes no parameters at all.

Modifies a case that already exists, which is where most support automation ends up.

• Case ID: the case to update.
• Update Fields: 18 fields here, one more than at creation, since Type moves into the optional set.
• Status Name or ID: the field that directly controls the IsClosed flag, so closing a case means setting this one.
• Is Escalated: flips the case into escalated, which is how a rule-based check hands it over to a manager.

Campaign membership is the record that ties a contact to a marketing campaign. This operation creates that link, so the contact appears in the campaign member list without any field on the contact itself being rewritten.

• Contact ID: the Salesforce record ID of the contact to enroll, usually {{ $json.id }} carried over from a previous node.
• Campaign Name or ID: pick the campaign from the dropdown n8n loads from your org, or pass an ID through an expression when the campaign changes per run.
• Status, inside Options: controls the HasResponded flag on the membership.

Notes are free text attached to a record rather than stored in a field. The node writes one and links it to a contact.

• Contact ID: the record the note gets attached to.
• Title: the note title, the only text shown in the related list, so make it scannable.
• Body, in Options: the note content, limited to 32 KB.
• Is Private: when on, only the note owner or a user holding the Modify All Data permission can read it or query it through the API.
• Owner Name or ID: the user who owns the note.

One new contact record per incoming item, and the node returns the Salesforce ID it just minted so later steps can attach notes, tasks or files to it.

• Last Name: the single required field, capped at 80 characters. Leave it empty and the node stops the execution.
• Additional Fields: 37 optional fields, among them Email, Phone, Title and Account Name or ID, which is what files the contact under a parent account.
• Custom Fields: add the fields your admin created, one Field Name or ID and Value pair at a time.

Duplicates are the usual cost of syncing people from an outside system. Upsert avoids them: Salesforce looks for a match first and only creates a record when it finds none.

• Match Against: the field Salesforce checks to decide whether the contact already exists, chosen from the dropdown.
• Value to Match: the value looked up in that field. Found, the contact is updated; not found, a new one is created.
• Last Name: still required, still capped at 80 characters.
• Additional Fields: the same 37 optional fields, applied in both branches.

Removal is permanent from the workflow's point of view: the node sends the delete and moves on, with nothing to undo downstream.

• Contact ID: the record ID, not the email address and not the full name. Feed it from a Get Many step or from the trigger item rather than typing it by hand.

One ID in, one full contact record out. Useful whenever a later node needs fields that the trigger item does not carry.

• Contact ID: the record to fetch, commonly {{ $json.id }} from an upstream node. Unlike the dropdown fields elsewhere in this node, this one is free text, so a wrong value comes back as a failed execution rather than an empty result.

Reading contacts in bulk, one item per record. What comes back depends entirely on how you set the paging and filtering switches.

• Return All: on, n8n walks every page of the API and returns all matching contacts; off, it stops at Limit.
• Limit: the maximum number of contacts returned when Return All is off.
• Conditions, in Options: filters the query so the node fetches a slice instead of the whole object.
• Fields: a comma separated list of the fields to include, which keeps the payload small on large orgs.

This one returns an overview of the contact object's metadata rather than contact records, so no rows come back and there is nothing to configure. It answers questions about how the object is shaped in your org, not about who is in it.

Fields you name get overwritten, fields you leave out keep their current value. That partial behavior is what makes this safe to run on records other teams also edit.

• Contact ID: which record to edit.
• Update Fields: 38 optional fields, one more than on create because Last Name moves here and is no longer required.
• Email Opt Out: flags that the contact does not want email from Salesforce, worth wiring to whatever your unsubscribe page writes.

Custom objects are the tables your admin added to the org, and the node treats them like any other resource: pick the object, set its fields, get a record back.

• Custom Object Name or ID: the object to write to, loaded into a dropdown from your org so you never guess the API name.
• Fields: the values to set, added one at a time as a Field Name or ID and Value pair.
• Record Type Name or ID, in Additional Fields: which record type the new record belongs to when the object defines several.

The upsert pattern applied to a custom object: Salesforce decides between insert and update by looking at one field you nominate, which keeps a repeated import idempotent.

• Custom Object Name or ID: the target object.
• Match Against: the field checked to see whether the record already exists.
• Value to Match: present in that field, the record is updated; absent, a new one is created.
• Fields: the values written in either branch, as Field Name or ID and Value pairs.

Two identifiers are needed here, not one: the object tells the node which table to work on, the record ID tells it which row to drop.

• Custom Object Name or ID: the custom object holding the record.
• Record ID: the record to be deleted. This is free text, so it normally arrives from a previous lookup rather than being typed in.

A single record read from a custom object, returned as one item with its fields. Pair it with a lookup step whenever the ID is not already in the payload.

• Custom Object Name or ID: which custom object to read from, selected in the dropdown.
• Record ID: the record to be retrieved.

Bulk read on a custom object, with the same paging switches as the standard resources plus a field picker that knows your org's schema.

• Custom Object Name or ID: the object to query.
• Return All: enabled, every page is fetched; disabled, Limit caps the number of records.
• Conditions, in Options: narrows the query to the rows you actually want.
• Field Names or IDs: a multi select of fields to include, chosen from the list or given as IDs through an expression.

Editing happens field by field on a record you identify, and anything you do not list stays as it was.

• Custom Object Name or ID: the object the record lives in.
• Record ID: the record to be updated.
• Fields: each change expressed as a Field Name or ID and Value pair, which is also how you set a Record Type Name or ID when the object has several.

Binary data travels between n8n nodes in a named property, and this operation takes that property and stores it in Salesforce as a document.

• Input Binary Field: the name of the binary field on the incoming item that holds the file. Get this name wrong and the node has nothing to send.
• Title: the file name as it will be stored.
• File Extension, in Additional Fields: forces an extension; left empty, the value from the binary data is used.
• Link To Object ID: attaches the document to an existing record.
• Owner Name or ID: the user who owns the document.

Flows are the automations built inside Salesforce itself. This operation lists them, which is mostly how you find the API name you need before invoking one.

• Return All: on, the node pages through the full list of flows; off, Limit sets how many come back.
• Limit: the maximum number of flows returned.

Rather than rebuilding org logic in n8n, this hands execution back to Salesforce: the node calls a flow and the flow does the work with the org's own rules.

• API Name: the flow's API name, required, and the value the Get Many operation exists to give you.
• JSON Parameters: switches input between the key and value UI and raw JSON.
• Variables: the input variables sent to the flow, added one by one or written as a JSON object depending on that switch.

Attaching an existing lead to a campaign creates the campaign member record, so the lead shows up in that campaign's audience without anyone opening Salesforce.

• Lead ID: the Salesforce identifier of the lead to attach, often {{ $json.Id }} carried over from an earlier Salesforce step.
• Campaign Name or ID: pick the campaign from the list n8n loads from your org, or pass an ID through an expression when the campaign changes from one run to the next.
• Status: sits in Options and controls the HasResponded flag on the membership.

Notes written this way stay on the lead record itself, readable by anyone who opens it, instead of sitting in one person's inbox.

• Lead ID: identifies the lead the note belongs to.
• Title: the note title, and the only text visible before someone expands it.
• Body: the note content, capped at 32 KB, which is where a call summary or a form comment goes.
• Is Private: set to true, only the note owner or a user with the Modify All Data permission can read it or query it through the API.

Two fields carry a new lead into Salesforce: Company and Last Name. Everything else rides along in Additional Fields, which holds 27 optional entries.

• Company: the company of the lead. Leave it empty and, if person account record types are enabled in the org, the lead converts to a person account.
• Last Name: limited to 80 characters.
• Email and Lead Source Name or ID: both optional, both in Additional Fields, and the second one decides how attribution reads three months later.

Run the same person through Create twice and the org ends up with two leads. Create or Update looks first, writes second.

• Match Against: the field n8n checks to decide whether the lead already exists.
• Value to Match: the value looked for in that field. Found, the lead is updated. Not found, a new one is created.
• Company and Last Name: still required, because any run can end in a creation.

Deletion leaves nothing to undo on the n8n side: the node sends the request and moves to the next item, so put a filter you trust in front of it.

• Lead ID: the record identifier, not the email address and not the company name. It usually comes from a preceding Get Many step, or from the trigger as {{ $json.Id }}.

One identifier goes in, the full record comes out as a single item. Useful when an upstream tool handed the workflow an ID and nothing else.

• Lead ID: the record to fetch. An expression such as {{ $json.leadId }} keeps the workflow generic from one execution to the next.

Get Many walks the Lead object and returns one item per record, the usual starting point for a batch that scores or routes.

• Return All: enabled, n8n chains the API pages until every lead is in. Disabled, Limit caps how many come back.
• Conditions: the filters that keep the batch on the leads worth processing.
• Fields: the fields to include, separated by commas, which keeps the payload light on a large org.

No record comes back here. Get Summary returns an overview of the Lead object's metadata, its shape rather than its contents, and it asks for no parameter at all.

Update touches only what you send. Fields left out of Update Fields keep their current values, so a partial payload is safe to send on every run.

• Lead ID: the record to modify.
• Status Name or ID: one of the 29 entries in Update Fields, chosen from the status list the org defines.
• Rating and Owner Name or ID: the two a routing workflow writes most, one for priority, one for the rep who picks the lead up.

Comments about a deal arrive from several people at once. This operation turns one into a proper note on the opportunity, where the rep will look for it.

• Opportunity ID: the deal the note attaches to.
• Title: required, and worth templating so the notes list stays readable.
• Body: up to 32 KB of text.
• Owner Name or ID: the user who owns the note, handy when a shared credential would otherwise sign everything.

Three fields open a deal: a name, a close date and a stage. The 13 entries in Additional Fields fill in the forecast around it.

• Name: limited to 80 characters.
• Close Date: the date the deal is expected to close, a date value and not free text.
• Stage Name or ID: chosen from the stages configured in the org.
• Amount and Account Name or ID: both optional, both worth filling if the pipeline report should mean anything.

Same logic as the lead version, applied to deals: n8n looks for an existing opportunity and only creates one when the lookup comes back empty.

• Match Against and Value to Match: the field checked, and the value searched for in it.
• Name, Close Date and Stage Name or ID: required on top of the match, since the run may end in a creation.

Removing a deal skews every pipeline history built on it, which is why most teams move it to a lost stage instead. Duplicates are the real case for this operation.

• Opportunity ID: the identifier of the deal to remove, usually read from a Get Many step whose filter already did the selecting.

Reading a single deal returns its current amount, its stage and its dates, which is what a workflow needs before it decides anything.

• Opportunity ID: the record to read. Coming from the trigger, it arrives as an expression such as {{ $json.Id }}.

Get Many returns opportunities as separate items, ready to be summed, grouped or sent somewhere the sales team already reads.

• Conditions: the filter that makes this operation worth running, for instance restricting the batch to a single stage.
• Return All: enabled, n8n chains the API pages to the end. Disabled, Limit decides how many deals come back.
• Fields: separated by commas, to bring back the amount and the close date without the rest of the record.

Get Summary describes the Opportunity object rather than any single deal: it returns an overview of that object's metadata, with no parameter to fill in.

Moving a deal forward usually comes down to one field, and Update Fields offers 16 of them.

• Opportunity ID: the deal to change.
• Stage Name or ID: what a pipeline automation writes most often.
• Amount: the estimated total sale amount, worth refreshing whenever the quote changes.
• Next Step: a short description of what still has to happen to close, capped at 255 characters.

Query runs a SOQL statement and returns all of its results in a single response, which covers the reads the resource operations cannot express.

• Query: the SOQL string, along the lines of SELECT+Name+FROM+MyObject. An invalid statement comes back as a MALFORMED_QUERY response, so test it in Salesforce before wiring it into a workflow.

One field is required to create a task: its status. The 25 entries in Additional Fields do everything else.

• Status Name or ID: the current status, such as In Progress or Completed, taken from the list the org defines.
• Subject Name or ID: the subject line, capped at 255 characters.
• Activity Date: the due date, always stamped at midnight UTC.
• Who ID: points at a person, a lead or a contact, where What ID points at an account, an opportunity or a case.

Tasks pile up faster than any other object in a CRM, and this operation removes one for good.

• Task ID: the task to remove. Feed it from a Get Many step whose Conditions already narrowed the list, since nothing here asks for a confirmation.

Fetching a single task returns its status, its subject and the records it is linked to.

• Task ID: the identifier of the task to read, usually carried over from the trigger item.

Get Many lists tasks one item at a time, which is how a workflow finds out what the team still owes.

• Return All: enabled, n8n keeps requesting pages until every task has been retrieved. Disabled, Limit stops it earlier.
• Conditions: the filters that keep the batch to one owner or one status.
• Fields: the fields to return, separated by commas.

Like its lead and opportunity counterparts, this call returns an overview of the Task object's metadata and not a single task.

Update rewrites the fields you provide and leaves the rest alone, across the 26 available in Update Fields.

• Task ID: the task to modify.
• Status Name or ID: what most automations write, to close a task from outside Salesforce.
• Is ReminderSet: turns the popup reminder on or off, and Reminder Date Time sets the moment it fires.

Fetches one Salesforce user from its identifier and hands the whole record to the next node, which turns a bare ID sitting in a field into something the rest of the workflow can actually read.

• User ID: the ID of the user that needs to be fetched, usually an expression such as {{ $json.userId }} that pulls the value from the item coming out of the previous node.

Reads the user list of the org and emits one item per user, which is where most workflows that spread records across a team start.

• Return All: switched on, n8n walks through the API pages until every user is back; switched off, Limit caps how many come out.
• Conditions: filters the list inside Salesforce, one condition per row added through Add Condition.
• Fields: the fields to include, separated by commas, to keep the payload light.