ClickUp CSV Import: Bulk Task Migration Without the Guesswork

Want to import CSV data into ClickUp? Go to Settings > Imports / Exports > Spreadsheet, upload your file, map your columns, and click Import. The only required field is Task Name. Everything else is optional.

Simple enough. But the details will bite you. ClickUp's importer has a 10,000 row limit, only works in the web app, and won't update existing tasks. Here's what works, what doesn't, and how to deal with the gaps when they show up.

What You Need Before You Start

Check these before you waste time formatting a CSV:

• Permissions: Only Admins and Owners can import on Free, Unlimited, and Business plans. Enterprise plans can grant import access to Members through custom roles. Guests and Limited Members? Locked out entirely.
• Web app only: The import feature doesn't exist on desktop or mobile. You need a browser. Annoying if you live in the desktop app.
• File size: Maximum 10,000 rows per file. More than that? Split it yourself.
• Rate limit: 60 imports per day per Workspace. You'll probably never hit this, but it's there.

Plan Availability

The Spreadsheets importer works on all ClickUp plans, including Free Forever. But Free plans hit walls fast after importing:

If your CSV has 80 custom field columns, the Free plan can't handle them all. Check this before you spend an hour formatting your file.

Preparing Your CSV File

The Only Required Column

Task Name. That's it. You can import a file with nothing but task names and ClickUp will create tasks from every row. Everything else -- status, priority, dates, assignees -- is optional.

Supported File Formats

ClickUp's importer is actually called the "Spreadsheets importer" because it handles more than CSV:

• CSV (.csv)
• Excel (.xls, .xlsx)
• XML (.xml)
• JSON (.json)
• TSV (.tsv)
• Text (.txt)

Excel files work if you want to dodge delimiter headaches. CSV is still the most portable format when exporting from other tools, though.

CSV Format Rules

• Header row recommended: Each column needs a unique heading
• Column order: Doesn't matter. You map columns during import
• Assignees: Use email addresses, not display names. pm@company.com works. Pat Martinez does not. This one catches people all the time.
• Multiple values: Separate with commas or pipes. tag1, tag2 or tag1|tag2
• Formulas: Only the calculated value imports. The formula itself is gone
• Subtasks: Only first-level subtasks import. Nested subtasks? Not happening.

Sample CSV Template

Here's a ready-to-use template with the common fields:

Task Name,Status,Priority,Due Date,Start Date,Assignee,Description,Subtasks,Tags,Time Estimate,Checklist,Task Type
Set up project workspace,To Do,2,03/15/2026,03/01/2026,pm@company.com,Create the workspace and configure settings,Create Space|Set up Lists|Add team members,setup|onboarding,2 hr,Review requirements|Check permissions|Verify access,Task
Design homepage wireframe,In Progress,2,03/20/2026,03/10/2026,designer@company.com,Create wireframes for the new homepage layout,,design|ui,8 hr,Gather inspiration|Draft layout|Review with team,Task
Write API documentation,To Do,3,03/25/2026,03/15/2026,writer@company.com,Document all API endpoints and parameters,,docs|api,4 hr,List endpoints|Write examples|Proofread,Task
Fix login bug,Urgent,1,03/12/2026,,dev@company.com,Users unable to log in with SSO,,bug|critical,1 hr 30 m,,Bug
Sprint review,Done,4,03/01/2026,03/01/2026,pm@company.com,Review sprint progress and demo features,,meeting,30 m,,Milestone

See that Priority column? Numbers, not text. 1 = Urgent, 2 = High, 3 = Normal, 4 = Low. If you write "High" instead of "2", it won't map correctly. This trips everyone up.

Supported Task Fields

Here's the full list of fields you can include:

Fair warning: descriptions import as plain text only. Rich text, HTML, Markdown -- all of it shows up as raw text in ClickUp. No formatting survives the trip.

Date and Time Formats

ClickUp supports six date formats. You pick yours at the start of the import:

For times, append to any date format:

ClickUp also accepts Unix timestamps in milliseconds (like 1609428600000) and ISO 8601 format (2025-12-31T13:30:00.123Z). Handy if you're pulling from a database or API.

Custom Fields

Supported Custom Field Types

ClickUp handles 13 custom field types:

Unsupported Custom Field Types

These flat-out cannot be imported via CSV. No workaround in the importer -- you'll have to fill them in manually or hit the API after import:

• Button
• Files
• Formula
• Location
• People
• Relationships
• Rollup
• Signature
• Voting

Honestly, this is frustrating. If you rely on Relationship or People fields, the CSV import just leaves those blank. You're filling them in by hand, one by one.

Step-by-Step Import Process

Step 1: Open the Importer

1. Click your Workspace avatar in the upper-left corner
2. Select Settings
3. In the sidebar, click Imports / Exports
4. Click Import items
5. If this is your first import, select Spreadsheet from the source list

Step 2: Set Your Destination and Date Format

1. Select a Space from the dropdown. This is where your tasks will land
2. Choose your date format from the Year-Month-Day dropdown
3. Drag and drop your file or click to upload

Step 3: Map Your Fields

The importer shows a mapping page with your CSV columns on one side and ClickUp fields on the other. ClickUp's auto-mapper learns from your previous imports, so if you've imported similar files before, it'll pre-fill some mappings.

Still, check every mapping. The auto-mapper gets it wrong more often than you'd expect, especially with custom column names like "Owner" or "ETA" that don't match ClickUp's field labels exactly.

Step 4: Map Data Values

For Status, Priority, and Task Type fields, you need to map your CSV values to the values that exist in ClickUp. If your CSV says "In Progress" but your Space uses "Working On It", this is where you connect them.

Important gotcha: statuses must already exist in your target Space. The importer won't create new statuses for you. If everything ends up as "To Do" after import, your status values didn't match. I've seen this confuse people more than anything else in the process.

Step 5: Review and Import

The final screen shows your data in a spreadsheet preview. This part is actually pretty good -- you can:

• Filter by Valid/Invalid to spot problems
• Search across all values
• Find and replace text in a column
• Delete rows you do not want
• Replace empty values in bulk

Yellow cells mean formatting issues. Red cells mean the value can't import at all. Double-click any cell to fix it inline.

Once it all looks right, click Import into ClickUp.

Step 6: Map Custom Fields (If Applicable)

If your CSV had custom field columns, a Custom Fields Mapping page pops up after the main import. Map each field to an existing custom field or create new ones on the spot.

Step 7: Find Your Imported Tasks

Your tasks land in the selected Space under a List called Imported from Spreadsheet. Rename it, move tasks around -- do whatever you need from there.

Migrating from Other Project Management Tools

If you're coming from another tool, you might not need CSV at all. ClickUp has built-in importers for:

Asana, Basecamp, Confluence, Jira, Monday.com, Notion, Todoist, Teamwork, Trello, Slack, and Wrike.

These importers handle tool-specific data and usually preserve more metadata than a CSV round-trip would. If your source tool is on that list, try the direct importer first. Seriously -- it'll save you time.

CSV still makes sense when your source tool isn't listed, when you need to transform data before importing, or when the direct importer misses fields you care about. I haven't tested every direct importer exhaustively, but the Jira and Trello ones work reasonably well in my experience.

Programmatic Import via the ClickUp API

For large or recurring imports, the API gives you way more control than the UI importer. It's also more work.

Create Task Endpoint

POST /api/v2/list/{list_id}/task

Authentication requires a Personal API Token or OAuth2. Rate limit: 100 requests per minute per token.

Here's a basic example:

const CLICKUP_API = 'https://api.clickup.com/api/v2';
const API_TOKEN = process.env.CLICKUP_API_TOKEN;

async function createTask(listId, taskData) {
  const response = await fetch(`${CLICKUP_API}/list/${listId}/task`, {
    method: 'POST',
    headers: {
      'Authorization': API_TOKEN,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: taskData.name,
      description: taskData.description,
      assignees: [taskData.assigneeId],
      status: taskData.status,
      priority: taskData.priority, // 1=Urgent, 2=High, 3=Normal, 4=Low
      due_date: taskData.dueDate, // Unix timestamp in ms
      start_date: taskData.startDate,
      custom_fields: taskData.customFields
    })
  });
  return response.json();
}

// Rate-limited bulk import
async function importCSVToClickUp(tasks, listId) {
  for (const task of tasks) {
    await createTask(listId, task);
    // 100 req/min = ~600ms between requests
    await new Promise(resolve => setTimeout(resolve, 700));
  }
}

API Trade-offs

The API bypasses some annoying UI limitations. No 10,000 row cap. You can set field types like Relationships that the UI importer ignores. You can create subtasks by passing a parent task ID.

But the downsides are real:

For a one-time migration, just use the UI importer. For recurring imports or building the import into your own tools, the API is worth the setup cost.

Third-Party Automation Options

Zapier

Connect a Google Sheet or CSV upload trigger to ClickUp task creation. No coding required. The catch: Zapier creates one task per trigger event. No bulk mode. Good for ongoing automation ("every time a row lands in this spreadsheet, create a task"), but terrible for migrating thousands of rows at once.

Make (formerly Integromat)

Similar idea to Zapier but with more room to transform data. You can parse a CSV, reshape it, and push to ClickUp. Better when you need to split, merge, or reformat fields before they hit ClickUp. Still not great for large one-off imports -- execution time limits get in the way.

Troubleshooting Common Errors

"Task name required" (Red Error)

No column is mapped to Task Name. Go back to the mapping step and assign the right column. You'll probably see this at least once. The fix is always the same.

Yellow Highlighted Cells

Formatting issue. Usually a date that doesn't match your selected format, or a value that's technically valid but looks off. Double-click the cell, fix the value. You can import with yellow cells, but you'll probably get weird results.

Red Highlighted Cells

Invalid value. Can't be imported at all. Fix it, change it, or set the column to "Do not import" to skip it.

Statuses All Default to "To Do"

Your CSV's status values don't match the statuses in your ClickUp Space. ClickUp won't create statuses during import -- you have to set them up first. Go to Space settings, add the statuses you need, then run the import again and map them properly.

Assignee Not Mapping

The email in your CSV doesn't match any user in your Workspace. Three options: keep the value (it'll be ignored), skip the assignee column, or invite the user to your Workspace before importing.

Custom Fields Not Visible After Import

This one's a head-scratcher. Imported custom fields are hidden by default in List view. Your data is there -- it's just invisible. Click the + icon above your List columns, select Add existing fields, and search for the field name. Problem solved, but ClickUp really should surface these automatically.

Large File Freezes or Times Out

Your file probably exceeds 10,000 rows, or your browser is choking on memory. Split the file into batches under 10,000 rows. Close other tabs. Chrome is especially bad at this -- the spreadsheet preview alone can eat a couple gigs of RAM.

Key Limitations to Know

Before you build a workflow around this, know the hard limits:

• No update or merge: Every import creates new tasks. Import the same file twice? Duplicate tasks. There's no deduplication.
• No nested subtasks: Only first-level subtask names and parent relations come through. Deeper nesting is manual work after import.
• Plain text descriptions: Rich text, HTML, Markdown -- all flattened. Gone.
• 10,000 row maximum: No exceptions.
• Web app only: Can't import from desktop or mobile.
• 60 imports per day: Workspace-level, not per-user.

When the Built-in Importer Falls Short

ClickUp's importer works fine for straightforward migrations. But the gaps show up fast in real projects: splitting large datasets at the 10,000 row line, no way to run incremental syncs, and you're stuck in the web app.

ImportCSV fills those gaps. No row limits -- it streams files of any size. A visual column mapper that your end users can actually figure out without a walkthrough. Built-in validation that catches formatting problems before they reach ClickUp. And it works anywhere you can embed a component, not just inside ClickUp's settings page.

If you're building an app that needs to accept CSV uploads from users and push that data to ClickUp (or any other backend), take a look.