Have you ever panicked about losing years of work stored in Trello? I certainly have. Whether it’s because your subscription is ending, your company is switching tools, or you just want to archive old projects, getting your data out of Trello in a usable format is surprisingly difficult.

Sure, Trello gives you a JSON export, but let’s be honest—when was the last time you enjoyed reading raw JSON? Plus, all those important attachments stay as remote URLs that might disappear tomorrow.

In my case, I have been deleting accounts I no longer use and migrating a lot of my accounts to Proton Mail with Simple Login and Proton Pass (that’s a topic for an upcoming article) and as part of the process I have been deleting accounts I no longer use.

The Problem: Your Data is Trapped

Here’s what happens when you try to preserve your Trello boards using the built-in export:

The Reality Check:

• Raw JSON is basically unreadable by humans
• Attachments are just URLs—and those links have a habit of breaking when you need them most
• Zero organization—everything is just dumped into one big file
• Completely platform-dependent

I learned this the hard way when trying to archive a project board with lots of comments and attachments. The export was technically complete but practically useless.

The Solution

I decided to build a tool to translate the JSON export into a more usable and human readable structure. The

The main goals:

• Organize the information in a readable way
• Download and preserve the attachments on the cards

The expected result:

• Markdown files that open anywhere
• All attachments downloaded locally—no more broken links
• Organized folder structure that mirrors your board layout
• Standard formats that work on any device.

How It Works

src/
├── trello_extractor.rb      # The main conductor
└── lib/
    ├── card_markdown_builder.rb    # Makes pretty markdown
    ├── attachment_downloader.rb    # Downloads all your files  
    ├── readme_builder.rb          # Creates board summaries
    ├── metadata_builder.rb        # Preserves the details
    └── trello_config.rb           # Handles authentication

Step 1: Making Sense of the Data

First, the tool parses that JSON export and organizes it like a human would think about it :

def build_lookups
  @board_data['lists']&.each { |list| @lists_by_id[list['id']] = list }
  
  @board_data['cards']&.each do |card|
    next if card['closed']
    
    list_id = card['idList']
    @cards_by_list[list_id] ||= []
    @cards_by_list[list_id] << card
  end
end

This creates lookup tables thatsimplify the complicated structure that Trello provides.

Step 2: Creating a Folder Structure

Then tool creates folders that mirror the simplified structure.

extracted/
└── my-awesome-project/
    ├── README.md                    # Quick overview
    ├── lists/
    │   ├── todo/
    │   │   ├── fix-that-bug.md     # Individual cards
    │   │   └── attachments/        # Your files, safe and sound
    │   └── done/
    └── metadata/
        ├── board_info.json         # All the nerdy details
        ├── labels.json             # Color coding preserved
        └── members.json            # Who worked on what

Step 3: The Magic of Content Processing

Cards Become Beautiful Markdown

Every card gets transformed into a rich document that’s actually pleasant to read:

• All the metadata you care about (dates, labels, who did what)
• Original descriptions with formatting intact
• Downloaded attachments or clear instructions if downloads failed

Smart Attachment Downloading (The Tricky Part)

This is where things get interesting. Downloading attachments from Trello had some complications:

def try_download_methods
  if authenticated?
    return true if try_api_endpoint
    return true if try_direct_download_with_auth
  end
  
  return true if try_direct_download_no_auth
  
  false
end

The tool tries multiple strategies:

• API download when you have credentials (most reliable)
• Direct download with authentication
• Public URL fallback when all else fails
• Graceful error handling because stuff breaks, and that’s okay

Flexible Authentication

You can provide your Trello credentials in different ways:

1. Command line (for quick one-offs)
2. Environment variables (for scripts and automation)
3. Config file (for repeated use)

I am planning to reuse this pattern in future tools.

Error Handling

Because things go wrong, and the tool deals with it gracefully:

• Network hiccups? It retries automatically
• Authentication issues? Clear error messages
• Permission problems? It finds another way or tells you exactly what’s wrong
• Corrupted data? Validation and recovery where possible

Performance

The tool handles boards of different sizes:

• Small boards (under 50 cards): Done in seconds
• Medium boards (50-200 cards): About a minute
• Large boards (200+ cards): Progress bars so you know it’s working

This also depends on the amount and size of attachments. The biggest board I have processed so far was around 500 cards and almos 8GB of attachments, took about 15 minutes but processed completely without errors

Why This Actually Matters

Your work history is valuable, but it can be trapped in formats that won’t age well. By converting everything to standard formats (Markdown, JSON, common image types), your data becomes truly portable.

Think about it: 10 years from now, you’ll still be able to open these files on whatever device you’re using. In reality you probably won’t but it is a good option to have.

Your archives can be:

• Stored in Git for version control
• Imported into other tools when you inevitably switch platforms
• Shared with anyone without requiring Trello access
• Preserved indefinitely without platform dependency

---

Key Takeaway

This is really about the power of software development to solve your own problems. When platforms don’t do what you need, you can often build tools that do exactly what you want.

Platforms and SaaS tools can be incredibly useful—they solve problems quickly and let you focus on your actual work. But here’s the thing: they’re controlled by someone else. Features get removed, pricing changes overnight, companies get acquired by bigger corporations that don’t care about your use case, or worse—they just shut down entirely.

Being able to write code gives you a superpower: the ability to create solutions that work exactly how you need them to work. This tool exists because no one else was going to solve this very specific problem. Trello had no incentive to make data export easier—quite the opposite, actually. But with some Ruby knowledge and a weekend, the problem got solved for me and hopefully this can be useful to someone else.

Your digital work deserves better than being held hostage by platform decisions. Sometimes the best solution is to build your own bridge.

---

Want to try Trello Extractor or help improve it? Check out the project on GitHub at https://github.com/vdaluz/trello-extractor. Feel free to report bugs, suggest features, or contribute code—open source works best when we build together.