Skip to main content

Salesforce

Query Salesforce with SOQL, create/update/upsert/delete records, and upload files — all against a connected Salesforce org.

Overview​

The Salesforce node runs against a Salesforce credential (one per org). Choose an Operation:

  • Query records (SOQL) — read records; each returned record is emitted as one item.
  • Create record — insert a new record.
  • Update record — update an existing record by ID.
  • Upsert record — insert or update, matched on an external-ID field.
  • Delete record — delete a record by ID.
  • Upload file — upload a file to Salesforce as a ContentVersion (optionally linked to a record).

Querying​

Builder vs. Raw SOQL​

Builder mode composes the query visually: pick an Object, choose the Fields & relationships to return, and add filters, a sort, and a limit. Raw SOQL mode lets you write a SOQL string directly.

Choosing fields and joins​

In the field selector, tick scalar fields to return them. Expand a relationship to pull related records — the node compiles each join to the right SOQL form automatically:

  • Parent lookups (e.g. a Contact's Account) become dotted paths inline: Account.Name.
  • Child collections (e.g. an Account's Contacts) become subqueries: (SELECT ... FROM Contacts).

A live SOQL preview below the tree shows exactly what will run as you build.

Polymorphic relationships​

Some lookups can point at more than one kind of object. The clearest example is ContentDocumentLink.LinkedEntity, which links a file to whatever it's shared with — an Account, a Contact, a User, a Case, and so on. A relationship's row shows its possible targets (e.g. LinkedEntity → Account, Contact, User +12).

Because a polymorphic lookup has no single target, it can't be expanded until you fix its type. To do that, add a filter on the relationship's <Relationship>.Type field:

  • Add a filter LinkedEntity.Type equals Account.

Once the type is fixed, the relationship becomes expandable — pick the target type's fields as usual, and the node compiles the join to a typed TYPEOF expression (TYPEOF LinkedEntity WHEN Account THEN Name, … END) so the related record comes back correctly typed. A single-type lookup (only one possible target) is expandable directly, with no filter needed.

You can also select <Relationship>.Type as a plain filter or sort field without expanding, to narrow or order by the linked record's object type.

Filtering, sorting and IDs​

  • Filters add WHERE conditions, combined with AND. Pick a Field, an Operation (equals, contains, in, exists, >, >=, <, <=, …), and a Value (which accepts an expression).
  • Sort by / Sort direction order the results.
  • Record IDs restrict the query to specific IDs (an identity lookup); leave it empty to return all matches.

Pagination​

Queries paginate automatically — the node follows Salesforce's query cursor and pulls every matching page, so you never set an offset. To protect against accidentally pulling an entire large object, a Max records safety cap (default 50,000) bounds the total; raise it per-node if you genuinely need more.

Files​

A query against ContentVersion or ContentDocument — whether it's the root object or reached through a relationship at any depth — attaches a file reference to each returned record, so the file flows directly into any node that takes a file (such as the Data Extractor) without exposing a storage URL.

Classic Attachment records (the older, pre-Chatter file type) work the same way: a query against Attachment attaches a file built from the attachment's body, so legacy attachments flow into file nodes too. (Upload always creates a modern ContentVersion, never a classic Attachment.)

Attached files without hand-picking version fields. When you query ContentDocumentLink (the junction that links a file to a record), the node automatically pulls the linked document's latest published version and attaches a single file to each link — you don't need to select version fields yourself. If you also explicitly expand the linked ContentDocument, the file stays on that document instead, so the file is never duplicated.

To fetch only files attached to a particular object type, combine this with a polymorphic type filter — e.g. query ContentDocumentLink, filter LinkedEntity.Type equals Account, and optionally expand LinkedEntity to pull the Account's fields alongside each file.

Upload file takes a file from an upstream node and stores it as a ContentVersion. Set a Title, Description, and Tags to make the file searchable in Salesforce, and optionally Attach to record ID to link it to an Account, Case, or other record. Leave File name blank to keep the source file's own name (its extension is preserved); set it to rename the upload.

Permissions​

Operations run as the connected Salesforce user. If a create/update/upload fails with a permission error, check that user's profile and permission sets (object CRUD and field-level security) — this is separate from the OAuth connection itself.