Introduction
The Pimcore 12 Salesforce Connector keeps your catalog and CRM data in sync between Pimcore and Salesforce (Sales / Service Cloud).
It syncs products, accounts, contacts, leads, and opportunities automatically, in both directions. Moreover, every sync runs as a background job inside Pimcore Studio.
As a result, keeping your product data and CRM records aligned is faster and far more reliable.
Copying products and CRM records between Pimcore and Salesforce by hand doesn’t scale. So Webkul built the Pimcore 12 Salesforce Connector to remove the copy-paste.
It bridges your Pimcore data model and your Salesforce org over the Salesforce REST API. As a result, products, accounts, contacts, leads, and opportunities all flow automatically, in both directions.
It’s built natively for Pimcore 12 and Salesforce. Also, it brings two big upgrades. First, every sync runs as a restartable background job.
So large data sets no longer block your screen or time out. Meanwhile, you watch each run on a live progress view. Second, it’s bidirectional.
It both imports from and exports to Salesforce. Because of that, you can seed Pimcore from an existing Salesforce org, then push curated changes back out.
The Pimcore 12 Salesforce Connector also lives natively inside the new Pimcore Studio UI. Furthermore, it adds its own screens for credentials, mapping, and the job runner.
So there are no separate tools to learn.
Server Requirements
The connector runs on top of a standard Pimcore 12 install, so if Pimcore runs, the connector runs. Here is what that stack needs.
| Component | Requirement |
|---|---|
| PHP | 8.4 or 8.5 (CLI + FPM), with pdo_mysql, intl, mbstring, curl, gd / imagick, zip, exif, opcache |
| Symfony | 7.4 (installed as a Pimcore dependency) |
| Pimcore | Pimcore 12 — Platform 2026.1 (pimcore/pimcore: 2026.1.x) with the Studio UI bundle |
| Database | MariaDB 10.11+ or MySQL 8.0+ |
| Web server | Nginx or Apache 2.4 |
| Composer | Composer 2 |
| Node.js | 22+ — only if you rebuild the Studio UI assets yourself |
| Message queue | A running Symfony Messenger worker (Supervisor is recommended) — this is what drives the background sync jobs |
| Salesforce | A Salesforce org (Sales / Service Cloud) with an External Client App using the Client Credentials Flow and a Run As user, reachable from the Pimcore server over HTTPS |
A few PHP settings matter for large data sets. So set memory_limit to at least 512M (1G for big imports), and raise max_execution_time for the CLI. Because the syncs run in the background, the web request itself never has to wait.
Key Features of the Pimcore 12 Salesforce Connector
- Bidirectional sync — import and export for Products, Accounts, Contacts, Leads, and Opportunities.
- Asynchronous job engine — syncs run in the background on a dedicated queue, so they never block your work.
- Live Job-Execution view — real-time status, read / created / updated counts, a run-history grid, and a one-click Stop.
- Config-driven mapping — point the connector at your Pimcore classes and match fields on screen; nothing to hard-code.
- Field Mapping is the single source of truth — pair each Salesforce field with a Pimcore attribute once; the same map drives both import and export.
- Idempotent matching — a per-entity match key plus a persisted connector link keeps Pimcore and Salesforce in step, so re-runs update instead of duplicating.
- Custom fields, both sides — type a Salesforce API name (e.g.
Brand__c) or a new Pimcore field and the connector wires it up. - Granular ACL — nine permission keys under a “Salesforce Connector” category, enforced fail-closed on every route, plus a per-job “Started by” audit trail.
Connecting the Pimcore 12 Salesforce Connector to Salesforce
The connector talks to Salesforce over the Salesforce REST API using OAuth 2.0 with the Client Credentials Flow. Authentication is done through a Salesforce External Client App, so no admin user password is ever shared — a designated Run As user drives every call.
Inside Salesforce, create an External Client App, enable the Client Credentials Flow, and assign a Run As user. Salesforce then gives you two values:
- Consumer Key — used as the
client_id - Consumer Secret — used as the
client_secret
Together with your My Domain URL (https://<my-domain>.my.salesforce.com), that’s all you need from the Salesforce side.
Setting Up the Pimcore 12 Salesforce Connector in Studio
In Pimcore, open Salesforce Connector → Credentials. Then click Add credential and enter your Name, Host (your My Domain URL), Consumer Key, Consumer Secret, and API version (e.g. v60.0). Next, click Test connection.
The connector then performs a real OAuth handshake and calls Salesforce live, so you get instant confirmation that everything is wired up. The secret is masked afterwards, showing only the last few characters.
You can store multiple credential profiles and mark one as active.
Object Mapping: the Connector Adapts to Your Data Model
Most connectors force you into fixed class names. This one, however, treats “which Pimcore class is a Salesforce Account?” as a simple setting.
On the Object Mapping screen, you point each Salesforce entity (Product, Account, Contact, Lead, Opportunity) at whatever classes your team already uses. So the connector adapts to your data model, instead of the other way around.
It comes pre-configured — the installer seeds lean WkSalesforce* classes and the mapping — so the Pimcore 12 Salesforce Connector works out of the box. Also, you can repoint it any time.
Field Mapping
Beyond the class level, the Field Mapping screen lets you line up individual fields — Pimcore field on one side, Salesforce field on the other. One shared map drives both import and export, so you configure it once. Only the fields you map are synced, and a per-entity match key is used to find-or-create records.
Both columns let you pick a known field or type a custom name. Type a Salesforce API name like Brand__c and it’s sent as-is; type a new Pimcore field and saving the mapping auto-creates it on the class as a text field. Defaults ship with the connector, so an unconfigured install still runs.
The Entities It Syncs
The connector maps the objects at the heart of a Salesforce org, each to a Pimcore class you control:
| Salesforce | Pimcore (default) | Match key |
|---|---|---|
Product2 + PricebookEntry | WkSalesforceProduct | sku ↔ ProductCode |
Account | WkSalesforceAccount | customerNumber ↔ AccountNumber |
Contact | WkSalesforceContact | email ↔ Email |
Lead | WkSalesforceLead | email ↔ Email |
Opportunity | WkSalesforceOpportunity | name ↔ Name |
Products are a little special: Product2 has no UnitPrice column, so the connector reads and writes the price on the Standard PricebookEntry automatically. Sensible create defaults are applied where Salesforce requires them — for example a new Lead gets Company = "Pimcore Export", and a new Opportunity gets StageName = "Prospecting" with a close date 30 days out.
With your mapping saved, open Export and pick an entity — say Product. Then pick the connection and click Start. The connector then pushes your records out via the Salesforce REST API, with the fields you mapped.
Exports are safe to re-run. Instead of duplicating, the connector updates what already exists. It resolves create-vs-update from a persisted connector link first, then falls back to a remote key match (e.g. ProductCode), and only then creates — so the same Pimcore object always lands on the same Salesforce record. If a record was deleted in Salesforce after its mapping was stored, the connector self-heals on the next run and recreates it. Sometimes a record can’t be exported. In that case, it’s flagged as a clear warning that tells you exactly what to fix.
Importing from Salesforce
Already have a live Salesforce org? Then import it into Pimcore in a few clicks. In fact, it’s the fastest way to onboard your data. Import is also additive.
So each run creates what’s missing and updates what exists, matching each Salesforce record back to Pimcore by the entity’s key. As a result, you can bootstrap once and re-run any time without duplicates.
Because import and export stay linked, the workflow is simple. First, import to seed Pimcore. Then enrich your content there. Finally, export it back.
As a result, every change lands on the original Salesforce record.
Runs as a Background Job
Every import and export dispatched from Studio runs on a dedicated Messenger queue, drained by a Supervisor-managed worker. So a large sync never blocks the browser or times out a web request.
You watch each run on a live execution view — status, read / created / updated counts, structured errors and warnings, and a one-click Stop. Every job also records the authenticated Studio user that started it, so there’s a clear “Started by” audit trail.
Permissions & Access Control
The connector ships a granular permission model, enforced fail-closed on every route — an ungranted action returns 403. Nine keys under the “Salesforce Connector” category let you split view, manage, test, import, export, and stop across your team.
Grant them in Pimcore Settings → Users / Roles → Permissions, ideally on a role. The Studio UI reads your effective grants and shows or hides each control to match exactly what the backend will allow.
Try the Pimcore 12 Salesforce Connector
Want to see it in action? Then try the live demo. It gives you a Pimcore 12 Studio environment with the connector already installed and connected to a Salesforce org.
So you can map entities and run a sync without setting anything up. Finally, when you’re ready to roll it out, grab it from the Webkul Store.
Your purchase includes the bundle, documentation, and support.
Be the first to comment.