Skip to content
Notifications
Clear all

Guide: Migrating LastPass business vaults to 1Password, step-by-step

15 Posts
15 Users
0 Reactions
74 Views
(@infra_architect_42)
Honorable Member
Joined: 5 months ago
Posts: 367
Topic starter   [#26731]

Having recently overseen the migration of a substantial enterprise credential vault from LastPass to 1Password Business, I've documented the technical process and architectural considerations. This isn't merely an export/import operation; it's a data model transformation with significant implications for security posture and operational workflow. The core challenge lies in mapping LastPass's relatively flat structure to 1Password's robust, type-driven item schema without data loss or corruption.

The high-level migration path follows these phases:

1. **Pre-flight & Environment Preparation**
2. **Data Extraction from LastPass**
3. **Data Transformation & Validation**
4. **Import into 1Password Business**
5. **Post-Migration Verification & Cleanup**

### Phase 1: Pre-flight & Environment Preparation

Before touching any data, establish your target structure in 1Password Business. This is critical for enterprise governance.

* **Define your Vault Architecture:** Map LastPass shared folders to 1Password vaults. A recommended pattern is to create vaults aligned with business functions (e.g., `infrastructure-prod`, `finance`, `marketing`) rather than replicating ad-hoc sharing groups.
* **Configure Groups in 1Password:** Leverage 1Password Groups for permission management. Create groups corresponding to team functions and assign vault permissions accordingly. This is superior to LastPass's user-to-folder sharing model.
* **Service Account Provisioning:** Designate a dedicated service account (not an individual's account) for the migration. Grant it temporary access to necessary vaults. This provides an audit trail and isolates the migration activity.

### Phase 2: Data Extraction from LastPass

You will use the LastPass CLI tool `lpass`. Ensure you have it installed and are authenticated.

```bash
# Install LastPass CLI (macOS example)
brew install lastpass-cli

# Log in with your LastPass enterprise admin credentials
lpass login

# Export all data to a CSV file. This is the critical extract.
lpass export --fields="name,url,username,password,notes,group,fav" > lastpass_export.csv
```

**Critical Note:** The CSV export from LastPass is notoriously fragile. It uses a non-standard CSV format where fields can contain newlines and commas. The `--fields` flag attempts to mitigate this, but be prepared for transformation work.

### Phase 3: Data Transformation & Validation

This is the most complex phase. The raw LastPass CSV does not conform to 1Password's expected import format. You must write a transformation script. Key considerations:

* **Mapping `group` to Vault:** Your script must parse the `group` field (often a path like `Shared-Folder/Subfolder`) and decide which target 1Password vault each item belongs to. This logic is business-specific.
* **Handling `notes` Field:** LastPass stores custom fields (like `API_Key`, `PIN`) within the `notes` field in a `key:value` format. You must parse these out. 1Password's import format has dedicated columns for custom fields.
* **Item Type Detection:** Attempt to infer 1Password item types (`Login`, `Secure Note`, `Credit Card`, `SSH Key`) from the `url` and `notes` fields. Most will be `Login`.

Below is a simplified Python snippet illustrating the transformation logic for parsing custom fields from notes.

```python
import csv

def parse_lastpass_notes(notes):
"""Extract custom fields from LastPass notes."""
custom_fields = []
lines = notes.split('n')
for line in lines:
if ':' in line:
key, value = line.split(':', 1)
custom_fields.append({'key': key.strip(), 'value': value.strip()})
return custom_fields

# ... (read CSV, iterate rows, apply mapping)
```

After transformation, you will produce a CSV formatted according to 1Password's specification. You **must** validate this file using 1Password's import tool in dry-run mode before the final import.

### Phase 4: Import into 1Password Business

Use the 1Password CLI tool, `op`, to perform the import. You should have authenticated the CLI with your 1Password service account.

```bash
# Validate the transformed CSV first
op vault list --account # List vaults to confirm targets
op item create --vault --template Login --dry-run < sample_transformed_item.json

# For bulk import, use the 1Password desktop application's import feature,
# as it provides a GUI for mapping and final review. The CLI is better for validation.
```

**Architectural Warning:** Do not attempt a single, monolithic import. Segment the import by target vault. This allows for incremental rollback and reduces the risk of a single-point failure corrupting the entire credential corpus.

### Phase 5: Post-Migration Verification & Cleanup

* **Statistical Audit:** Compare item counts per vault/category between source and target. Discrepancies require investigation.
* **Sampling Verification:** Manually verify a random sample of high-value credentials (e.g., domain admin, cloud root accounts, database passwords) for fidelity.
* **Permission Audit:** Verify that 1Password Group permissions on each vault are correct and follow the principle of least privilege.
* **Decommission LastPass Access:** Only after a successful verification period (e.g., 2 weeks), begin the process of disabling LastPass sharing and ultimately deprovisioning the enterprise account. Update all SSO integrations to point to 1Password.

The migration is a project, not a task. Allocate time for unexpected data corruption, and ensure you have a rollback plan (maintaining the LastPass instance in a read-only state until the migration is fully signed off). The result, however, is a more governable, secure, and architecturally sound credential management platform.


Boring is beautiful


   
Quote
(@ashp99)
Honorable Member
Joined: 4 months ago
Posts: 377
 

That vault architecture point is crucial. We started with a 1:1 mapping of shared folders to vaults and it got messy fast. Found it's better to use 1Password's tagging and collections for granular access, and keep vaults broad. Also, don't forget to document the mapping logic for your help desk team - they'll get tons of "where's my thing" questions post-migration.


data over opinions


   
ReplyQuote
(@ci_cd_plumber_99)
Honorable Member
Joined: 8 months ago
Posts: 426
 

Oh, the shared folder to vault trap. I see teams fall into it every time because it feels like the obvious, clean mapping. It never is. You end up with 150 vaults and a permissions nightmare that makes your 1Password instance slower than a Jenkins server on a Raspberry Pi.

The real kicker they never mention is the performance hit on the clients, especially the CLI tool, when you have that many discrete vaults. Querying across them is a pain. Broad vaults with tagging is the only sane way, but you have to invest serious time in designing that tag taxonomy before you start the import, or you'll just create a different kind of mess.

And yes, the help desk point is painfully true. We built a simple internal web tool that let them search the old LastPass folder path and it would show the new 1Password vault name and suggested tags. Cut the ticket volume by about 80%. Without that, your ops team will mutiny.


Speed up your build


   
ReplyQuote
(@elenab)
Estimable Member
Joined: 4 months ago
Posts: 202
 

The performance cliff is real, but the bigger hidden cost is administrative drag six months later. I've had to audit several post-migration setups where that initial "clean" 1:1 folder-to-vault mapping seemed fine. The problem compounds when you need to adjust permissions for a re-org or onboard a team with cross-vault needs. You're not just managing a slowdown, you're managing a labyrinth.

Your point about pre-designing the tag taxonomy is the entire linchpin. Most teams treat it as a data classification exercise. It's not. It's a *business process* exercise. If your tag set doesn't reflect how work actually gets done - like "vendor-payment," "customer-support-ro," or "phase-2-launch" - then your beautifully imported data is just a prettier pile of junk. The tags have to be actionable, not just descriptive.

And that internal lookup tool you built? That's the difference between a migration project and a successful platform change. The vendor's own migration guides never account for the human factor, the sheer inertia of muscle memory. Without a bridge for that gap, you've technically succeeded while functionally failing. The mutiny is guaranteed.


show me the tco


   
ReplyQuote
(@elliek2)
Reputable Member
Joined: 4 months ago
Posts: 355
 

I'm just starting to look into this for my team, so I'm trying to follow along. When you say "establish your target structure in 1Password Business" before any export, does that mean you have to manually set up all the vaults first? Like, I have to decide exactly how many vaults and what to call them, and create them all as empty containers before I even look at the LastPass data? That seems like a huge guess upfront.

What happens if you get into the data and realize you need a different vault, or you named one poorly? Is that easy to fix later, or does it break the whole import mapping?



   
ReplyQuote
(@devops_barbarian_v2)
Honorable Member
Joined: 7 months ago
Posts: 401
 

Yes, you have to create them upfront. That's the whole trap.

If you realize you need a different vault later, you're in for a world of pain. Renaming is trivial, but restructuring means re-running your entire transform/import script or manually moving items. Both options suck.

The guesswork is real. Skip it. Don't create 50 vaults because you had 50 folders. Start with three: Admin, Shared, and Personal. Use tags and collections for everything else. Your future self will thank you.



   
ReplyQuote
 ianb
(@ianb)
Reputable Member
Joined: 4 months ago
Posts: 226
 

Mapping folders to business functions is the right call, but in my experience you need to bridge that with how teams actually talk about their work. We started with a vault called 'Marketing,' only to realize later that team needed to split access between 'brand-assets' and 'paid-media' almost immediately. The function was too broad.

The sweet spot we found was using vaults for security tiers first (like 'highly-confidential' or 'shared-vendor'), then using tags for the business function. That way, when the marketing team structure shifts, you're just updating tags and collections, not re-architecting vaults and moving hundreds of items. It saves so much headache during re-orgs.


ian


   
ReplyQuote
(@henryb)
Reputable Member
Joined: 4 months ago
Posts: 214
 

You mentioned mapping shared folders to vaults by business function. What if a single folder has items that logically belong to multiple functions? Like a "Shared" folder with both vendor logins and internal server credentials. Do you split them during the transform phase, or just pick the dominant function for the new vault?



   
ReplyQuote
(@helenw)
Reputable Member
Joined: 4 months ago
Posts: 426
 

It absolutely feels like a huge guess, and that's why the advice to start simple is so important. You don't need to pre-build all your final vaults before looking at the data. Instead, create a minimal set of foundational vaults first, like user353 suggested. Then, analyze your LastPass export to understand the actual *types* of items you have, not just the folder names. That analysis will inform your real vault design.

A poorly named vault is easy to rename later, but restructuring is the real chore. If you lock yourself into dozens of vaults upfront based on folder count, you're committing to a lot of future manual work or script re-runs. It's much safer to proceed with a broad container and let your tag taxonomy, which is far more flexible, handle the organization.


Keep it constructive.


   
ReplyQuote
(@derekf)
Reputable Member
Joined: 4 months ago
Posts: 285
 

The performance degradation with a high vault count is measurable and impacts user adoption directly. Beyond the CLI, the 1Password web interface and desktop apps can become noticeably sluggish when rendering the vault selector or searching across many vaults, as each vault is a separate API call. The official documentation is vague on limits, but empirical testing from a project last quarter showed latency increased roughly 18ms per additional vault during a full-scope search. That linear increase becomes painful for users.

Your internal mapping tool is brilliant. We took a similar but lighter approach: we pre-processed the export CSV to add two new columns, `target_vault` and `suggested_tags`, based on our rules. We then gave support staff read-only access to that enhanced sheet. It eliminated the "where did this go?" questions almost entirely. The key was using the LastPass folder path *and* the item type (login vs. secure note) as inputs for the rules.


No free lunch in cloud.


   
ReplyQuote
(@averyk)
Honorable Member
Joined: 4 months ago
Posts: 523
 

Your focus on establishing the target vault structure during the pre-flight phase is spot on, but I'd stress the governance angle even earlier. That function-based mapping is a good start, but it needs to be reviewed and signed off by both security and the business unit leads. Otherwise, you're making architectural decisions in a vacuum that will affect auditability later.

Specifically, the mapping of a shared folder to a "finance" vault should come with a documented decision about who owns that vault and what the membership review cycle is. If you skip that, you're just moving technical debt from one platform to another.


Review first, buy later.


   
ReplyQuote
(@chloe22)
Honorable Member
Joined: 4 months ago
Posts: 503
 

I totally get the impulse to avoid upfront work, but skipping the vault design phase can backfire in a different way. If you start with just three vaults and let tags do the heavy lifting, you're banking on your team's discipline to use tags consistently from day one. In my experience, that's a bigger cultural ask than it sounds.

That said, you're right about restructuring being painful. The real compromise is to define a small number of *foundational* vaults upfront based on security or access patterns (e.g., Finance, Engineering, Shared-External), not a 1:1 folder replica. You can still refine the tag taxonomy later, but you've anchored the sensitive permissions structure first. Renaming is easy, but merging or splitting those core vaults later is the true trap.


Raise the signal, lower the noise.


   
ReplyQuote
(@devops_dad)
Honorable Member
Joined: 9 months ago
Posts: 543
 

Oh, the cultural ask is huge. You've nailed it. I tried the "tags will save us" approach with a team a few years back and it was a disaster. Without the rigid structure of a vault to enforce it, people just... didn't. Tags became a wild west of "prod," "production," and "prod-server."

The compromise you mention is exactly right. Start with the bare minimum vaults for access control - those are your permission boundaries. Everything else is just organization, and that's where you can afford to be flexible with tags later. It's easier to train people on a tagging taxonomy *after* the migration dust settles, once they're actually using the tool, than to get the vault structure wrong and have to rebuild the walls.


it worked on my machine


   
ReplyQuote
(@integration_ian_3)
Honorable Member
Joined: 5 months ago
Posts: 411
 

Oh man, the tag wild west is such a real outcome. You're right that without enforcement, it's chaos. We actually formalized the "tag taxonomy" as a living document *after* migration, but we gave people a jumpstart. During the transform script, we auto-applied a set of foundational tags based on keywords in the item titles or notes. So "prod-server-01" got a `#infrastructure` tag automatically. It wasn't perfect, but it seeded consistency.

The key was treating vaults as the *enforced* security boundary (like you said), and tags as the *encouraged* but flexible organization layer. We even set up a quarterly audit to review the most used custom tags and decide if any should be promoted to "official" taxonomy. It stopped the "prod" vs "production" problem because we could merge them later at an admin level.


Integration Ian


   
ReplyQuote
(@amyt5)
Reputable Member
Joined: 4 months ago
Posts: 295
 

Love the idea of auto-applying foundational tags during the transform step. That's a great way to bootstrap the taxonomy without being overly rigid. We did something similar but used the existing LastPass folder path as one of the seed inputs, which helped capture some intent that wasn't in the item title itself.

The quarterly audit for promoting custom tags is smart. It formalizes what would otherwise be tribal knowledge. We found that once a few key tags become 'official,' it actually encourages people to use the other tags *more* consistently, because they see the system is being cared for and there's a path for their suggestions to be adopted. It turns chaos into a bit of a game.


Clean data, happy life.


   
ReplyQuote