Perplexity’s collections feature lets you organize research, bookmarks, and saved searches into curated folders. If you’re considering migrating to ChatGPT Search, you need to export your collections first—Perplexity doesn’t provide a one-click migration tool, and once you stop using the platform, accessing your saved data becomes increasingly difficult. This guide covers practical methods for developers and power users to export Perplexity collections before switching, with code examples and automation strategies.

Why Export Collections Before Switching

Perplexity stores your collections on their servers as long as you maintain an active subscription. Collections include saved URLs, research threads, generated summaries, and your search history organized into custom folders. When you transition away from Perplexity, whether to ChatGPT Search or another AI-powered search tool, you lose access to this organized knowledge base unless you’ve explicitly exported it.

The 2026 landscape shows ChatGPT Search offering strong web search capabilities with the ability to save conversations and create custom GPTs, but it doesn’t import Perplexity collections natively. Your research, bookmarks, and organized findings live in Perplexity’s ecosystem until you extract them. The export process requires deliberate action—there’s no automatic sync or migration path.

Method 1: Manual Browser Export

The simplest approach uses Perplexity’s web interface. Navigate to your collections in the sidebar. Each collection displays your saved items as a list. You can manually copy-paste URLs and notes into a local file, but this becomes unwieldy with large collections.

For individual items, click on any saved result within a collection. The detail view shows the original URL, your notes, and any AI-generated summaries. Copy these manually into a markdown file or your preferred note-taking system. This method works for small collections but doesn’t scale well for power users with hundreds of saved items.

Method 2: Perplexity API for Programmatic Export

Developers can export collections programmatically using Perplexity’s API. This approach requires API access, which is available to Pro and Enterprise subscribers.

import requests
import json
from datetime import datetime

# Perplexity API configuration
API_KEY = "your_perplexity_api_key"
BASE_URL = "https://api.perplexity.ai/v1"

def get_collections():
    """Fetch all collections for the authenticated user."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    response = requests.get(
        f"{BASE_URL}/collections",
        headers=headers
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"API error: {response.status_code}")

def export_collection_items(collection_id):
    """Export all items from a specific collection."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    response = requests.get(
        f"{BASE_URL}/collections/{collection_id}/items",
        headers=headers
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"API error: {response.status_code}")

def main():
    # Get all collections
    collections = get_collections()
    
    all_data = {
        "export_date": datetime.now().isoformat(),
        "collections": []
    }
    
    # Iterate through each collection and export items
    for collection in collections.get("data", []):
        collection_id = collection["id"]
        collection_name = collection["name"]
        
        items = export_collection_items(collection_id)
        
        all_data["collections"].append({
            "id": collection_id,
            "name": collection_name,
            "items": items.get("data", [])
        })
    
    # Save to JSON file
    with open("perplexity_export.json", "w") as f:
        json.dump(all_data, f, indent=2)
    
    print(f"Exported {len(all_data['collections'])} collections")

if __name__ == "__main__":
    main()

This script fetches all collections and their items, then saves them to a JSON file. Run it with python export_script.py after installing dependencies: pip install requests.

Method 3: Browser Automation with Playwright

For users without API access, browser automation provides an alternative. Playwright can simulate user actions to scrape your collections.

from playwright.sync_api import sync_playwright
import json
import time

def export_collections_browser():
    """Export collections using browser automation."""
    
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        
        # Login to Perplexity
        page.goto("https://www.perplexity.ai/login")
        # Add your login logic here
        page.wait_for_url("**/home")
        
        # Navigate to collections
        page.goto("https://www.perplexity.ai/collections")
        time.sleep(2)
        
        collections_data = []
        
        # Find all collection elements
        collections = page.query_selector_all("[data-testid='collection-item']")
        
        for collection in collections:
            name = collection.query_selector(".collection-name").inner_text()
            items = []
            
            # Click to open collection
            collection.click()
            time.sleep(1)
            
            # Extract saved items
            item_elements = page.query_selector_all(".saved-item")
            for item in item_elements:
                item_url = item.query_selector(".item-url").inner_text()
                item_notes = item.query_selector(".item-notes").inner_text() if item.query_selector(".item-notes") else ""
                items.append({"url": item_url, "notes": item_notes})
            
            collections_data.append({
                "name": name,
                "items": items
            })
            
            # Go back to collections list
            page.go_back()
            time.sleep(1)
        
        # Save export
        with open("perplexity_collections.json", "w") as f:
            json.dump(collections_data, f, indent=2)
        
        browser.close()
        print(f"Exported {len(collections_data)} collections")

if __name__ == "__main__":
    export_collections_browser()

Install Playwright first: pip install playwright && playwright install chromium. This script opens a browser window, navigates to your collections, and extracts the data. Modify selectors based on Perplexity’s current DOM structure.

Once you’ve exported your Perplexity collections, you need to format them for import into your new tool. ChatGPT Search works best with structured conversation history and custom GPTs. Convert your JSON export to a readable format:

import json

def convert_to_markdown(export_file, output_file):
    """Convert Perplexity export to markdown for easy import."""
    
    with open(export_file, "r") as f:
        data = json.load(f)
    
    markdown_content = f"# Perplexity Collections Export\n"
    markdown_content += f"*Exported on {data['export_date']}*\n\n"
    
    for collection in data["collections"]:
        markdown_content += f"## {collection['name']}\n\n"
        
        for idx, item in enumerate(collection["items"], 1):
            markdown_content += f"### {idx}. {item.get('title', 'Untitled')}\n"
            markdown_content += f"- URL: {item.get('url', 'N/A')}\n"
            
            if item.get("notes"):
                markdown_content += f"- Notes: {item['notes']}\n"
            
            if item.get("summary"):
                markdown_content += f"- AI Summary: {item['summary']}\n"
            
            markdown_content += "\n"
    
    with open(output_file, "w") as f:
        f.write(markdown_content)
    
    print(f"Converted to {output_file}")

if __name__ == "__main__":
    convert_to_markdown("perplexity_export.json", "perplexity_export.md")

This produces a markdown file you can import into Notion, Obsidian, or use as reference when building custom GPTs in ChatGPT.

Automating Ongoing Sync

If you’re transitioning gradually, set up a scheduled export to keep your local copy updated:

# Add to crontab for daily exports
0 2 * * * cd /path/to/project && python export_script.py >> export.log 2>&1

Run this daily at 2 AM to maintain an up-to-date local backup while you transition to ChatGPT Search.

Best Practices for Data Migration

Before switching, organize your exports by collection name. Create separate folders for research topics, bookmarks, and ongoing projects. This makes it easier to reconstruct your knowledge system in ChatGPT’s interface using custom instructions and GPT configurations.

Test your export scripts on a single collection first to verify the data structure matches your expectations. Perplexity’s API and UI change periodically, so scripts may need adjustment.

Back up your exports to cloud storage (Google Drive, Dropbox, or AWS S3) in addition to local storage. This protects against data loss if your local machine fails during the transition period.

Summary

Exporting Perplexity collections before switching to ChatGPT Search requires deliberate action. The API approach works best for developers with Pro subscriptions, offering programmatic control and automation. Browser automation provides an alternative without API access. Convert exports to markdown for easy integration with your new workflow, and maintain backups throughout the transition.

Built by theluckystrike — More at zovo.one