Exporting Goodreads Library to CSV/Excel

Hey there, Darian here. A few years back, I was trying to build a personal dashboard to track my reading habits alongside some of my other productivity metrics. I found myself manually downloading and cleaning my Goodreads export every single month. It was tedious, error-prone, and exactly the kind of repetitive task that we, as engineers, are meant to automate. Realizing I was wasting a good hour every time, I wrote a simple Python script to handle it. Today, I’m sharing that workflow with you. It’s a quick win that turns a manual chore into a reliable data source.

Prerequisites

Before we jump in, make sure you have the following ready:

• A Goodreads account (of course).
• Python 3 installed on your system.
• Familiarity with installing Python packages. You’ll need pandas and openpyxl (for Excel support). I trust you know how to get those into your environment using pip.

The Guide: From Goodreads to a Clean Spreadsheet

Step 1: Download Your Goodreads Library

First, we need the raw data. Goodreads has a built-in export tool that’s perfect for this. It’s more reliable and respectful than trying to scrape the site directly.

1. Log in to your Goodreads account.
2. Navigate to “My Books”.
3. On the left-hand side, under “Tools”, click on “Import and Export”.
4. Click the “Export Library” button at the top. It might take a minute or two for Goodreads to generate the file. Once it’s ready, download the CSV file and save it to your project directory. For this guide, let’s assume you’ve named it goodreads_library_export.csv.

Pro Tip: Bookmark that export page. While this script automates the *processing*, you still need to grab the source file periodically. If you run this script on a schedule, just remember to drop the latest export file in the right place before it runs.

Step 2: Setting Up the Python Script

Now for the fun part. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. Create a new file, let’s call it process_goodreads.py.

The core of this script will be the pandas library. It’s my go-to for any kind of data manipulation in Python. It’s powerful, fast, and makes handling tabular data like a CSV file incredibly simple.

Here’s the initial code to load the data and do some basic cleanup:

import pandas as pd

def process_library(file_path):
    """
    Loads, cleans, and processes the Goodreads export file.
    """
    try:
        # Load the CSV file into a pandas DataFrame
        df = pd.read_csv(file_path)

        # Let's inspect the columns first to see what we have
        print("Original columns found:")
        print(df.columns)
        
        # --- Data Cleaning ---
        # Select only the columns I care about for my analysis
        # Your columns might vary slightly, so check the print output!
        relevant_columns = [
            'Title', 'Author', 'My Rating', 'Average Rating', 
            'Publisher', 'Number of Pages', 'Year Published', 'Date Read'
        ]
        
        # Ensure all desired columns exist before trying to select them
        # This prevents errors if Goodreads changes their export format
        existing_columns = [col for col in relevant_columns if col in df.columns]
        df_cleaned = df[existing_columns].copy()

        # Convert 'Date Read' to a datetime object for proper sorting and filtering
        # The errors='coerce' part will turn any unparseable dates into 'NaT' (Not a Time)
        df_cleaned['Date Read'] = pd.to_datetime(df_cleaned['Date Read'], errors='coerce')

        print("\nData loaded and cleaned successfully.")
        return df_cleaned

    except FileNotFoundError:
        print(f"Error: The file was not found at {file_path}")
        return None

if __name__ == "__main__":
    SOURCE_FILE = 'goodreads_library_export.csv'
    library_data = process_library(SOURCE_FILE)
    
    if library_data is not None:
        print("\nFirst 5 rows of cleaned data:")
        print(library_data.head())

Step 3: Filtering and Extracting Insights

This is where the real value comes in. A raw data dump is messy. Let’s say you only want to see the 5-star books you read in 2023. With pandas, that’s trivial. We can add a function to our script to handle this filtering.

def filter_books(df, year=None, rating=None):
    """
    Filters the DataFrame based on year read and rating.
    """
    # Make a copy to avoid modifying the original DataFrame in place
    filtered_df = df.copy()

    # Filter by year if specified
    if year:
        # We use .dt accessor for datetime properties
        filtered_df = filtered_df[filtered_df['Date Read'].dt.year == year]

    # Filter by rating if specified
    if rating:
        filtered_df = filtered_df[filtered_df['My Rating'] == rating]
        
    return filtered_df

# --- Add this to your main execution block ---
if __name__ == "__main__":
    SOURCE_FILE = 'goodreads_library_export.csv'
    library_data = process_library(SOURCE_FILE)
    
    if library_data is not None:
        print("\n--- Running Analysis ---")
        
        # Example: Get all 5-star books read in 2023
        top_books_2023 = filter_books(library_data, year=2023, rating=5)
        
        print(f"\nFound {len(top_books_2023)} five-star books read in 2023:")
        print(top_books_2023[['Title', 'Author']])

Step 4: Exporting to a New CSV or Excel File

Finally, let’s save our filtered data. In a production pipeline, this could be the input for a visualization tool or a reporting system. Exporting is just one line of code with pandas.

Pro Tip: I generally prefer exporting to Excel for stakeholders because it’s more accessible for non-technical folks. But for machine-to-machine handoffs, CSV is lighter and faster. Choose the right tool for the job.

def export_data(df, filename_prefix):
    """
    Exports the DataFrame to both CSV and Excel formats.
    """
    # Export to CSV
    csv_filename = f"{filename_prefix}.csv"
    df.to_csv(csv_filename, index=False)
    print(f"\nSuccessfully exported data to {csv_filename}")

    # Export to Excel
    excel_filename = f"{filename_prefix}.xlsx"
    df.to_excel(excel_filename, index=False, sheet_name='Filtered Books')
    print(f"Successfully exported data to {excel_filename}")

# --- Add this to your main execution block ---
if __name__ == "__main__":
    # ... (previous code from main block) ...
    
    if library_data is not None:
        # ... (previous analysis code) ...
        
        # Export the filtered data
        if not top_books_2023.empty:
            export_data(top_books_2023, 'top_books_2023_report')

Common Pitfalls

Here is where I usually messed up when I first built this:

• Column Name Changes: Goodreads might tweak their export format. The script I provided checks if the columns exist before using them, which prevents crashes, but you might get empty data if a key column like ‘Date Read’ is renamed. Always check the `print(df.columns)` output if things look weird.
• Date Parsing Errors: My script handles common date formats, but if you have unusual entries, the `pd.to_datetime` function might struggle. The `errors=’coerce’` argument is a lifesaver, as it prevents the script from crashing and instead flags problematic rows with `NaT`, which you can then filter and inspect.
• File Encoding: Very rarely, you might get a `UnicodeDecodeError` if the CSV has strange characters. If that happens, you can try specifying an encoding when you load the file, like this: pd.read_csv(file_path, encoding='latin1').

Conclusion

And that’s it. You now have a repeatable, reliable script for turning your raw Goodreads export into a clean, filtered dataset ready for analysis or reporting. From here, you can easily adapt the filtering logic for any question you want to ask about your reading habits. You could even set it up on a simple scheduler to run weekly, so all you have to do is drop in the latest export file. Happy automating!

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions