Salesforce CSV Import Formatting Guide

1. Before you start: understand the impact on your system of record

Importing data into Salesforce modifies a central system of record. Whether you are inserting newly generated leads, updating existing customer accounts, or executing a departmental migration, unverified CSV files can overwrite valid CRM data, trip validation rules, or introduce thousands of duplicate records. Always retain an untouched backup copy of your source CSV file before applying any transformation or import steps.

Before modifying columns or cell values, identify your precise import operation: an **Insert** (creating new records), an **Update** (modifying existing records using a record identifier), or an **Upsert** (updating existing records when a match is found and inserting new records when no match is found). The operation dictates which fields are required, which identifiers must be present, and how duplicate records should be evaluated.

Salesforce officially recommends testing every import with a small sample file of 5 to 10 records in a sandbox or test environment before running a large batch. A small test run confirms field mappings, date formats, picklist validation, and automation triggers without putting live production records at risk.

• Retain an untouched, dated backup of the original source CSV file.
• Confirm whether your import action is an Insert, Update, or Upsert.
• Identify mandatory fields and active validation rules on the target Salesforce object.
• Prepare a small 5–10 record sample to test before committing the full dataset.

2. Choose your Salesforce import method: Data Import Wizard vs. Data Loader

Salesforce provides two primary native tools for importing CSV data into an org: the browser-based **Data Import Wizard** and the desktop **Data Loader** application. Selecting the appropriate tool depends on your target Salesforce object, the size of your dataset, and whether specialized update rules apply.

The Salesforce Data Import Wizard is accessible directly inside Salesforce Setup under Data Management. It is designed for standard business imports of up to **50,000 records** at a time. It supports common standard objects—specifically Accounts, Contacts, Leads, Solutions, Campaign Members, and Person Accounts—as well as Custom Objects. Crucially, the Data Import Wizard does **not** support Opportunities, Cases, Campaigns, Products, or Assets.

For larger datasets or unsupported objects, Salesforce Data Loader is a standalone desktop application capable of processing up to **5,000,000 records** per run leveraging Salesforce's Bulk API. Data Loader supports all standard and custom objects, automated field-mapping files (`.sdl`), and mass deletion or export workflows. RowDesk does not connect to Salesforce via API; it prepares and verifies the CSV file locally in your browser before you hand it off to either native Salesforce tool.

3. Structure the header row and map columns accurately

Salesforce CSV files require exactly one header row on line 1, followed immediately by data records. Multi-row headers, title banners, grouped summary rows, or empty header cells will cause column misalignment or complete file rejection during the mapping stage.

Header labels do not have to match Salesforce API field names verbatim in the Data Import Wizard, because the wizard provides an interactive mapping screen where source columns can be assigned to target fields. However, using clear, standardized column names (such as `Email`, `First Name`, `Last Name`, `Company`, or API names like `PostalCode`) allows Salesforce to auto-map columns accurately and reduces manual configuration.

Verify that every row in the file has the exact same number of delimiter-separated columns as the header row. A missing comma or an unescaped line break in a text field will shift subsequent fields to the wrong column, causing data corruption or validation errors. You can scan your file with RowDesk's CSV Data Quality Checker to verify structural integrity and column consistency before mapping.

• Ensure line 1 contains unique, descriptive header names with no blank header cells.
• Remove any preamble text, title banners, or summary footers from the CSV.
• Match column names to target field labels or API names to accelerate auto-mapping.
• Confirm that all data rows contain the exact same column count as the header row.

4. Preserve Salesforce IDs, external IDs, and leading zeros

Salesforce assigns a unique 15-character or 18-character alphanumeric record ID to every record (for example, `0015g00000XyZaAAB`). The 15-character ID is case-sensitive, meaning `0015g00000XyZaA` and `0015g00000xyzaa` point to two entirely different records. Because spreadsheet applications and data transformation tools often normalize letter casing, you should always use **18-character case-insensitive Salesforce IDs** in spreadsheet and CSV workflows to avoid case-conversion corruption.

Custom External IDs—such as an ERP customer number, legacy database key, or e-commerce customer identifier—should be used wherever possible for upsert operations. An External ID field allows Salesforce to recognize existing records and perform updates without exposing internal system keys to external teams.

A major hazard in CSV preparation occurs when spreadsheet software (like Microsoft Excel) misinterprets text identifiers as numbers. Opening a raw CSV in Excel can silently strip leading zeros from postal codes (turning `'02138'` into `2138`) or convert 12-to-18-digit phone numbers and tracking codes into scientific notation (turning `98765432101234` into `9.87654E+13`). Once Excel saves the file, the lost precision cannot be restored.

In RowDesk, all cell values are treated strictly as text. Identifiers with leading zeros and long alphanumeric codes are preserved without numeric reinterpretation during cleaning, deduplication, and splitting. If an earlier program has already truncated digits from a file, RowDesk cannot reconstruct the missing data; always inspect raw source exports before editing.

5. Clean whitespace, standardize casing, and clear placeholder tokens

Extraneous whitespace is one of the most common causes of CRM import errors and false duplicate mismatches. A trailing space in an email address (`'alex@example.com '`) or a leading space in an account name (`' Acme Corp'`) can cause duplicate detection to fail, creating redundant records in Salesforce. Trim surrounding whitespace across all columns before mapping.

Standardizing character casing is good data hygiene, although Salesforce does not strictly require uniform casing for all fields. Picklists and email addresses benefit most from standardization: emails should be formatted in lowercase for consistency, while name and title fields should use standard capitalization. Distinguish good CRM data hygiene from hard Salesforce schema requirements: Salesforce will not reject a lead simply because a job title is in uppercase, but clean casing prevents unsightly reporting.

Audit and remove empty rows and placeholder tokens. Spreadsheet exports frequently contain dummy values like `'N/A'`, `'null'`, `'None'`, or `'#N/A'`. Unless intentionally removed, these tokens will be imported into Salesforce as literal text strings. Use RowDesk's Free CSV Cleaner to strip surrounding whitespace, remove completely blank lines, and standardize empty placeholders across the dataset.

• Trim leading and trailing whitespace from names, emails, and company fields.
• Standardize email addresses to lowercase to ensure uniform CRM records.
• Eliminate completely blank rows from the CSV file.
• Clear placeholder tokens such as 'N/A' or 'NULL' so they are not stored as literal values.

6. Format Date and Date/Time fields for Salesforce

Salesforce requires strict date and timestamp formatting. Acceptable syntax depends on whether the destination field is a pure Date field or a Date/Time field, which tool you are using, and the importing user's locale settings.

**Date Fields** (such as `Birthdate`, `CloseDate`, or custom date fields): The official recommended standard across Salesforce tools is ISO 8601: `YYYY-MM-DD` (for example, `2026-06-02`). In Data Loader, `MM/DD/YYYY` is accepted by default for US locales, or `DD/MM/YYYY` if the 'Use European date format' checkbox is enabled in Data Loader settings. Pure date fields must never include time or time zone values.

**Date/Time Fields**: Salesforce stores all date/time values internally in Coordinated Universal Time (UTC). The most reliable format for import is the full ISO 8601 UTC timestamp: `YYYY-MM-DDThh:mm:ss.SSSZ` (e.g. `2026-06-02T14:30:00.000Z`) or with an explicit offset such as `YYYY-MM-DDThh:mm:ss.SSS+02:00`. If you use the 24-hour military format `YYYY-MM-DD hh:mm:ss` without a time zone suffix, Data Loader defaults to the local computer's time zone setting, which can shift dates and hours unexpectedly. Always check the official Salesforce Date and Date/Time guidance for your org's configuration.

7. Handle Booleans, restricted picklists, and schema validation

Each Salesforce field enforces data type constraints defined in your org's Object Manager. Preparing your CSV values to match these constraints avoids failed rows during import.

**Checkbox / Boolean Fields**: Salesforce accepts `true` or `false`, as well as `1` (true) or `0` (false). Values are case-insensitive (`TRUE`, `True`, and `true` are all accepted). Blank values in checkbox fields on new records typically default to `false` unless a default value is specified in field settings.

**Picklist Fields**: Check whether the target picklist field has the setting **'Restrict picklist to the values defined in the value set'** enabled. If restricted, any value in your CSV that does not match an active picklist API value will cause the entire record to fail during import. For unrestricted picklists, new values can be inserted, but doing so can clutter your org with inconsistent options. Verify your picklist entries against Salesforce Setup before uploading.

**Text Length and Required Fields**: Standard and custom text fields enforce strict character limits (e.g. 255 characters). Values exceeding the limit will cause import errors unless truncation is configured. In addition, review all universally required fields on the target object; records missing a required field cannot be inserted.

• Use true/false or 1/0 for checkbox fields.
• Verify that picklist values match active API values in restricted picklist sets.
• Ensure text fields do not exceed maximum character limits (e.g. 255 characters).
• Confirm that every record contains a non-empty value for universally required fields.

8. Understand blank and null value semantics: Insert vs. Update

Handling empty cells requires extreme care when updating existing Salesforce records. There is a fundamental difference between leaving an existing value unchanged and intentionally wiping out an existing value with a blank.

In the **Data Import Wizard**, blank cells in an update CSV are ignored by default. If an existing Contact has a phone number in Salesforce and your CSV update row has an empty phone cell, the phone number in Salesforce will **not** be deleted. The Data Import Wizard cannot be used to mass-clear field values to null.

In **Data Loader**, behavior depends entirely on your API configuration: in the standard **SOAP API**, Data Loader ignores blank cells on update by default. To intentionally clear existing values, you must open **Settings** and check **'Insert null values'**. When checked, every empty cell in your CSV overwrites the corresponding Salesforce field with null. In **Bulk API** mode, the 'Insert null values' setting is disabled; to clear a field using the Bulk API, you must enter the exact literal string **`#N/A`** in the CSV cell. The Bulk API interprets `#N/A` as an explicit instruction to set the field to null.

Never perform a bulk find-and-replace on empty cells without understanding which import tool you are using and whether you intend to preserve or overwrite existing data.

9. Deduplicate records before Salesforce ingestion

While Salesforce orgs may have active Duplicate Rules or Matching Rules configured, relying on Salesforce to catch duplicates at import time is risky. When a duplicate rule is set to 'Block', entire batches or individual rows are rejected with cryptic error messages. When set to 'Allow' with alerting, duplicate leads and contacts slip into your CRM, cluttering sales queues and confusing ownership.

Deduplicating the CSV prior to import gives you complete visibility and control. Decide on an identity key appropriate for your object: for Contacts and Leads, `Email` is common; for B2B accounts, `Email Domain + Company Name` or an `External Account ID` may be used. Distinguish between exact duplicate rows (where every column is identical) and matching records that differ across secondary fields (such as phone number or job title).

Use RowDesk's CSV Duplicate Remover or the Deduplicate feature to inspect duplicate groups side-by-side. Choose whether to keep the first occurrence or keep the most complete record (the row with the highest number of populated fields) before exporting a verified, duplicate-free CSV.

• Define identity keys (e.g. Email, External ID, or Email + Company) before deduplicating.
• Distinguish exact duplicate rows from records sharing an identity with different details.
• Review duplicate groups to choose which survivor record to retain.
• Export a deduplicated CSV before submitting records to Salesforce.

10. Compare incoming data against existing Salesforce records

One of the most effective strategies for lead imports and CRM migrations is reconciling your incoming CSV against an export of current Salesforce records before attempting an import. This prevents accidental duplicate creation and clarifies whether an import should be an Insert or an Update.

The workflow is simple: first, export a report from Salesforce containing current record IDs and key identifiers (such as `Email` or `External ID`). Second, open RowDesk Compare CSV Files. Third, load your incoming spreadsheet as File A and your Salesforce export as File B. Fourth, map the matching identifier column.

RowDesk evaluates the datasets and cleanly separates them into three distinct result sets: **Only in File A** represents net-new records that do not exist in Salesforce (export this subset for a clean, risk-free Insert operation); **In Both (Matched)** represents records that already exist in your CRM (review this subset to determine whether an Update operation is needed, or exclude them from new lead distribution); and **Only in File B** represents existing Salesforce records unaffected by the incoming file.

RowDesk performs this comparison entirely inside your browser. No Salesforce API connection or OAuth credentials are required; you simply export your report, compare the files locally, and proceed with confidence.

11. Verify UTF-8 encoding, delimiters, and RFC 4180 quotes

Salesforce strongly recommends saving import files with **UTF-8 encoding**. Non-UTF-8 encodings (such as ANSI, Windows-1252, or ISO-8859-1) often corrupt international characters, accents (e.g. `é`, `ñ`, `ü`), smart quotes, and non-Latin alphabets, turning them into replacement symbols like `?` or unexpected byte sequences.

Adhere strictly to standard RFC 4180 CSV specifications. Fields containing commas, line breaks (CRLF or LF), or double quotes must be enclosed in double quotation marks. Any literal quotation marks inside a cell must be escaped by doubling them (`""`).

Ensure that comma (`,`) is used as the delimiter. If your computer's regional operating system settings default to semicolons (`;`), verify your export settings or adjust Data Loader's delimiter configuration accordingly.

• Save and export the CSV with UTF-8 encoding to preserve international characters.
• Enclose cells containing commas, line breaks, or quotation marks in double quotes.
• Escape internal quotation marks with double quotes ("").
• Confirm the delimiter matches your Salesforce import tool configuration (comma by default).

12. Split large imports to avoid 50,000-record limits and timeouts

The Salesforce Data Import Wizard enforces a hard limit of **50,000 records** per single import run. If your file contains 120,000 records, you must divide it into smaller batches before the wizard will accept it.

Even when using Data Loader or the Bulk API where larger limits apply, dividing massive files into smaller chunks (such as 10,000 to 50,000 records) is standard administrative best practice. Smaller batches reduce the impact of network interruptions, minimize database lock contention (e.g. when multiple records roll up to the same parent Account simultaneously), and make error troubleshooting significantly easier.

Use RowDesk's Free CSV Splitter to divide large files into custom batch sizes. The splitter runs entirely in your browser, preserves exact cell contents and identifiers, and automatically repeats the header row across every split part without counting it toward the data-row limit.

13. Test with a small batch before running full imports

Never import a large dataset directly into production without verifying a small test batch. Isolate 5 to 10 representative rows from your prepared CSV and import them into a Salesforce sandbox or as a test run in production.

After running the test batch, inspect the resulting records in Salesforce: did all fields map to their intended destinations? Are dates and timestamps showing the correct day, month, and hour? Did phone numbers and postal codes retain their leading zeros? Were assignment rules, validation rules, or record-triggered Flows activated correctly?

Review the success and error CSV logs generated by Salesforce. If any validation errors or field truncation issues occur, address them in the source file before executing the full import.

• Extract 5 to 10 representative rows for an initial test run.
• Execute the test import in a sandbox or non-production environment if available.
• Verify field values, date accuracy, picklist values, and text formatting in Salesforce.
• Confirm that assignment rules, notifications, and Flows triggered appropriately.
• Review the Salesforce error log CSV to catch issues before the bulk run.

14. Salesforce CSV pre-import checklist

Use this comprehensive pre-import checklist before uploading any CSV file into Salesforce Data Import Wizard or Data Loader:

• Untouched backup copy of the original source file saved and archived.
• Target Salesforce object and operation (Insert, Update, or Upsert) confirmed.
• Single header row on line 1 with clear column names and no duplicate headers.
• 18-character case-insensitive Salesforce IDs or unique External IDs used for matching.
• Postal codes, customer IDs, and phone numbers preserved as literal text with leading zeros.
• Surrounding whitespace trimmed and categorical casing standardized across key columns.
• Empty rows removed and unwanted placeholder tokens ('N/A', 'null') cleared.
• Date fields formatted as ISO 8601 (YYYY-MM-DD) and Date/Time fields aligned to UTC.
• Picklist values verified against restricted value sets in Salesforce Setup.
• Blank-cell update semantics confirmed ('Insert null values' in SOAP vs. '#N/A' in Bulk API).
• Pre-import duplicate review completed using email or composite business keys.
• Incoming data compared against existing Salesforce export to isolate net-new records.
• File split into batches under 50,000 rows if using the Data Import Wizard.
• File encoded in UTF-8 format with standard comma delimiters.
• Small 5–10 record test batch verified in a sandbox or test environment.

15. Prepare your Salesforce CSV with RowDesk

RowDesk provides a unified, browser-local workspace to prepare, clean, deduplicate, and compare CSV files before CRM ingestion. The recommended preparation workflow follows a structured sequence:

1. **Scan**: Inspect dataset health, structural defects, and missing rates with the CSV Data Quality Checker.

2. **Clean**: Trim whitespace, remove blank rows, and standardize empty placeholders with CSV Cleaner or Clean Data.

3. **Deduplicate**: Group repeated contacts or companies and select survivor records with CSV Duplicate Remover or Deduplicate.

4. **Compare**: Map incoming rows against a recent Salesforce export to separate net-new leads from existing contacts using Compare CSV Files or Compare Files.

5. **Split (if needed)**: Divide files larger than 50,000 rows into import-ready parts with the Free CSV Splitter.

6. **Review & Export**: Review changes, verify record counts, and download a verified CSV export.

RowDesk operates strictly as a pre-import preparation workspace. It does not connect directly to Salesforce via OAuth or API, and it does not write data directly into your CRM. You retain full control over when and how your prepared CSV is imported using Salesforce's native tools.

16. Browser-local privacy and data security

When handling sensitive customer records, prospect lists, or proprietary CRM data, security and confidentiality are paramount. In RowDesk, all file parsing, data cleaning, deduplication, comparison, and CSV serialization occur locally inside your web browser.

Raw dataset contents, column headers, and cell values are never uploaded to, transmitted across, or stored on RowDesk servers. Administrative metadata—such as optional email capture for tool downloads, billing, and privacy-safe aggregate analytics—utilizes standard secure backend infrastructure, but your CRM data remains strictly on your device.

Salesforce is a registered trademark of Salesforce, Inc. RowDesk is an independent browser-based data preparation tool and is not affiliated with, endorsed by, or sponsored by Salesforce, Inc.