Live on AppExchange · Rated 5.0 · Free
Import records that match on your rules, not just IDs.
A native Salesforce data loader that simplifies CSV imports. Upserts, dynamic lookups, automatic field mapping and row-level error reporting, built for efficient data migration.
See an import without a single record ID.
A five-minute walkthrough, from the sample CSV to the results email. Pick a chapter to jump straight to it.
The standard data loader knows record IDs. Your spreadsheet does not.
Every bulk import runs into the same wall. The CSV has an account name, an email, an external code, but Salesforce wants an eighteen-character ID, and nothing in the file has one.
Manual ID lookups
Export the parent records, VLOOKUP the IDs into your file, hope nothing shifted between the export and the import. Repeat for every lookup field.
Silent duplicate creation
Matching on one field alone creates a second record whenever the value is slightly different, and you only find out weeks later during a report.
Opaque failures
An import fails partway and returns an error file that has to be reconciled against the original by hand before you can retry it.
A load that should take ten minutes turns into an afternoon of spreadsheet surgery, and the risk of a bad import lands on whoever ran it.
A loader that resolves the lookup for you, at import time.
Point it at a CSV, tell it which fields identify a match, and it resolves the related records as it loads. The mapping step that used to happen in a spreadsheet now happens inside Salesforce.
Your CSV file
Headers are read and auto-mapped to fields on the target object, so most imports need no manual mapping at all.
Your Salesforce org
Lookups are resolved dynamically, matching runs across the fields you chose, and records are inserted or upserted.
It stays a data loader on purpose. Nothing proprietary sits between your file and your records, so what lands in Salesforce is exactly what you can see in the preview before you run it.
From file to loaded records.
A short, predictable path, with a checkpoint before anything is written.
Install from AppExchange
Choose the object
Upload the CSV
Review the mapping
Set the match rule
Run and review errors
Install from AppExchange
The native managed package installs into your org in a few clicks. Nothing external to configure and no separate account to create.
Choose the object
Pick the target object for the import. Standard or custom, whichever your file belongs to.
Upload the CSV
Drop in your file. Headers are read immediately and auto-mapped to matching fields on the object.
Review the mapping
Adjust anything the auto-mapper did not catch, and set which fields should resolve as lookups.
Set the match rule
Choose the field or combination of fields that identifies an existing record, so the load upserts instead of duplicating.
Run and review errors
Run the import and read the result row by row, so a failure points at a line in your file rather than a batch ID.
What the loader does.
Built around the parts of a bulk import that usually go wrong.
CSV import with upserts
Insert new records and update existing ones in a single pass, rather than splitting a file into two loads.
Dynamic lookup resolution
Related records are resolved during the import, so your file can reference a name or a code instead of an ID.
Auto-mapped headers
Column headers are matched to fields on the target object automatically, leaving only the exceptions to set by hand.
Multi-field matching
Match on a combination of fields rather than one, so near-identical values do not create duplicates.
Row-level error reporting
Every failure is reported against its own row, so you fix a line in your file instead of re-running a whole batch blind.
Standard and custom objects
Load into whichever object the data belongs to, without a different tool for custom ones.
100% native
Runs inside Salesforce. No external service holds your file and no data leaves the org during a load.
Completely free
No licence cost and no per-record fee, however large the file is.
Where the time actually gets saved.
Your headers, already matched
The mapping screen opens pre-filled rather than blank, so a clean file often needs no mapping work at all and a messy one needs only the exceptions corrected.
- Column headers read straight from the CSV
- Matched against fields on the target object
- Manual override available on any field
Reference records by what you actually have
Instead of exporting parent records to fetch their IDs, point the loader at the field your file already contains and let it resolve the relationship during the load.
- Resolve lookups at import time
- Use names, emails or external codes
- No pre-import VLOOKUP step
Failures you can act on
When something does not load, the result tells you which row and which field, so the fix is a correction in your file rather than an investigation.
- Reported per row, not per batch
- Points at the field that failed
- Correct and re-run only what failed
The load runs inside your org.
A data loader handles some of the most sensitive records you have. This one is a native package, so your file is never uploaded to an external service to be processed.
Nothing is uploaded offsite
Parsing, matching and inserting all happen inside Salesforce. No third party holds a copy of your file.
Runs as you
The import executes under your user, so your existing object and field permissions apply exactly as they normally would.
Preview before write
You confirm the mapping and the match rule before anything is committed, rather than discovering the result afterwards.
Row-level audit trail
Every row is reported as inserted, upserted or failed, so a completed load can be reconciled against the source file.
What changes on your next big load.
The tool is only interesting because of the spreadsheet work it removes.
No pre-import prep
The VLOOKUP-the-IDs step disappears, which is usually the longest part of preparing a load.
Fewer duplicates
Matching across several fields catches the near-identical records that single-field matching creates.
Failures are legible
Row-level reporting turns a failed import from an investigation into a correction.
Free to run
No licence and no per-record pricing, regardless of how large or frequent your loads are.
Nothing leaves the org
The load runs natively in Salesforce, so your file is not handed to an external service.
Any object
Standard or custom, the same tool and the same workflow either way.
Against how bulk imports usually get done.
| Standard Data Loader | Spreadsheet prep first | Smart Lookup Data Loader | |
|---|---|---|---|
| Lookups by name or code | No, IDs only | Manual VLOOKUP | Resolved at import |
| Header mapping | Manual | Manual | Auto-mapped |
| Match on several fields | No | Not reliably | Yes |
| Error detail | Batch-level file | Found afterwards | Row-level |
| Prep time before a load | Moderate | High | Minimal |
| Runs inside Salesforce | Desktop app | Wherever your sheet is | Fully native |
| Cost | Free | Staff time | Free |
Comparison reflects publicly documented behaviour at time of writing. Verify before publishing.
Anyone who loads data into Salesforce more than once a month.
Salesforce admins
Routine bulk updates that currently start with exporting parent records just to fetch their IDs.
Data migration teams
Multi-object migrations where relationships have to be resolved as records land, not afterwards.
Revenue operations
Regular account, contact and opportunity loads from lists that arrive as spreadsheets.
Consultants
Client orgs where the same import has to be run repeatedly and handed over cleanly.
Marketing operations
List uploads that need to attach to existing accounts without creating a second copy of each one.
Support and service
Bulk case or asset loads that reference records by a customer code rather than an ID.
The questions admins ask first.
What does Smart Lookup Data Loader do?
It imports CSV data into Salesforce while resolving lookup relationships during the load, so your file can reference related records by a name, email or code instead of a record ID.
How is Smart Lookup Data Loader different from the standard Data Loader?
The standard loader expects record IDs for lookup fields, which usually means preparing the file with a VLOOKUP first. This one resolves those references itself, auto-maps your headers, and can match on several fields at once.
Will Smart Lookup Data Loader create duplicate records?
Matching on a combination of fields rather than a single one is what prevents most duplicate creation. You choose which fields identify an existing record before the load runs.
What happens when a row fails in Smart Lookup Data Loader?
Failures are reported at row level, so you can see which line and which field caused the problem, correct it in your file, and re-run only what failed.
Does Smart Lookup Data Loader work with custom objects?
Yes. Standard and custom objects use the same workflow.
Does my data leave Salesforce with Smart Lookup Data Loader?
No. It is a native package and the load runs inside your org.
How much does Smart Lookup Data Loader cost?
It is free, with no per-record or per-load charge.
Do I need a developer to use Smart Lookup Data Loader?
No. It is built for admins and operations teams, not for developers.
Stop preparing spreadsheets. Start loading.
Install Smart Lookup Data Loader from the Salesforce AppExchange and run your next import without the prep work.
Get it on AppExchangeFree managed package · No credit card · Published by TwinStack Solutions
Our other AppExchange products.
Native apps built around the same idea: less manual work between your data and your Salesforce org.
Smart Forms & Surveys
Native forms. Real records.
- Drag-and-drop form and survey builder
- Public forms on Salesforce Sites
- Creates or updates any object
- No external callouts
Google Form Auto Sync
Responses, straight into Salesforce.
- Real-time sync on form submission
- 100% native, no middleware
- No Google Sheets in the path
- No third-party server in the path
Who Sees What
Why can this user see that?
- Start from a user, not a permission set
- See every object, field and record
- Shows the exact rule that granted access
- Read-only and fully native
Notes from the team.
New posts most weeks: setup guides, integration patterns, and what we learn from the Salesforce community.
Why every bulk import starts with a VLOOKUP, and how to skip it
The record-ID problem behind most Salesforce data loads.
Single-field matching is how duplicate accounts get created
A practical approach to choosing match keys for an import.
Reading a failed import: row-level errors versus batch files
What to look at first when a load comes back with failures.