r/TVTime

If you have been looking for a way to recover your TV Time library, followed shows, watch history, and cached metadata from the iOS app, I wanted to share how I managed to recover and export my data into a CSV file.

This method worked for me after the TV Time service was shut down and I could no longer access my data normally. I used iMazing to extract the local TV Time app data from my iPhone, then analyzed the extracted files with a small Python script.

I am sharing this in case it can help other people who lost access to their TV Time data.

OVERVIEW

TV Time does not provide a simple built-in way to export all of your cached library information and watch-related metadata.

After extracting the local app data with iMazing, I found that the TV Time app had stored a significant amount of information locally inside its Documents directory.

The most useful file I found was:

DioCache.db

This is an SQLite database used by the app's HTTP client, Dio. It contains cached API responses and other locally stored information.

Depending on the data that was still available in the local cache, I was able to recover information such as:

Show and movie names
Show IDs
Watched episode counts
Total episode counts
Follow information
Watch status
Show status
Country
Day of the week
Ratings
Follower counts
Hashtags
Poster URLs
Fanart URLs
Various timestamps and dates

I also found several binary files beginning with the bplist00 header. These are Apple Binary Property List files and may contain additional cached application data.

STEP 1: EXTRACTING THE TV TIME DATA WITH IMAZING

1. Connect your iPhone or iPad to your computer.
2. Open iMazing.
3. Find the TV Time app in the Apps section.
4. Use the available app data extraction or file browsing options to access the TV Time app container.
5. Export or copy the Documents folder to your computer.

In my case, the extracted Documents folder contained DioCache.db along with many other files with names similar to random hexadecimal hashes.

I recommend keeping the original extracted data untouched and making a backup copy before running any scripts.

STEP 2: EXAMINING THE DATA

The main database I worked with was DioCache.db.

The database contains a table called cache_dio. The content column contains cached data returned by the app's network requests.

Many of these entries are JSON data stored as text or binary data.

The Python script below scans the database, attempts to decode the cached JSON responses, looks for show and movie information, and also checks the other files in the Documents directory for Binary Property List data.

The script then combines the recovered records, removes duplicates, and exports the result to a CSV file.

STEP 3: RUNNING THE PYTHON SCRIPT

The script uses only Python's standard library. No third-party packages are required.

Save the script below as:

parse_tvtime.py

Place it in the same directory as your Documents folder.

The directory structure should look like this:

parse_tvtime.py
Documents
DioCache.db
other extracted files

Then run:

python parse_tvtime.py

If everything works correctly, the script will create:

tvtime_export.csv

The CSV file is saved using UTF-8-SIG encoding, which makes it easier to open correctly in Microsoft Excel when the data contains characters from different languages.

PYTHON SCRIPT

import os
import re
import json
import sqlite3
import plistlib
import csv
from datetime import datetime BASE_DIR = os.path.dirname(os.path.abspath(file))
DOCS_DIR = os.path.join(BASE_DIR, "Documents")
DB_PATH = os.path.join(DOCS_DIR, "DioCache.db")
OUTPUT_CSV = os.path.join(BASE_DIR, "tvtime_export.csv")
 
def format_timestamp(val):
"""Convert Unix timestamps or ISO 8601 dates to YYYY-MM-DD HH:MM:SS."""

if not val:
    return ""

if isinstance(val, (int, float)) or (
    isinstance(val, str) and val.isdigit()
):
    try:
        ts = float(val)

        if ts > 1e11:
            ts /= 1000.0

        return datetime.fromtimestamp(ts).strftime(
            "%Y-%m-%d %H:%M:%S"
        )

    except Exception:
        return str(val)

if isinstance(val, str):
    val_clean = val.replace("Z", "+00:00")

    try:
        dt = datetime.fromisoformat(val_clean)
        return dt.strftime("%Y-%m-%d %H:%M:%S")

    except Exception:
        if "T" in val:
            return val.split("T")[0]

        return val

return str(val)

def extract_image_url(images, img_type="poster"):
if not images or not isinstance(images, list):
return ""

for img in images:
    if isinstance(img, dict) and img.get("type") == img_type:
        return (
            img.get("url")
            or img.get("versions", {}).get("big", "")
        )

return ""

def process_item_dict(d, source_name="DioCache.db"):
if not isinstance(d, dict):
return None

item_data = (
    d.get("meta")
    if isinstance(d.get("meta"), dict)
    else d
)

name = item_data.get("name") or item_data.get("title")

if not name or not isinstance(name, str):
    return None

if len(name.strip()) == 0:
    return None

entity_type = (
    d.get("entity_type")
    or item_data.get("type")
    or "series"
)

if entity_type not in ["series", "movie", "show"]:
    entity_type = "series"

item_id = (
    item_data.get("id")
    or item_data.get("uuid")
    or ""
)

status = item_data.get("status") or ""
country = item_data.get("country") or ""
day_of_week = item_data.get("day_of_week") or ""

extended = (
    item_data.get("extended")
    or d.get("extended")
    or {}
)

if isinstance(extended, dict):
    rating = extended.get("rating") or ""
    follower_count = (
        extended.get("follower_count") or ""
    )
else:
    rating = ""
    follower_count = ""

progress_status = ""

filters = (
    item_data.get("filters")
    or d.get("filter")
    or []
)

if isinstance(filters, list):
    for f in filters:
        if isinstance(f, dict):
            if f.get("id") == "progress":
                vals = f.get("values", [])

                if vals:
                    progress_status = ", ".join(
                        str(v) for v in vals
                    )

        elif isinstance(f, str):
            progress_status += f + " "

progress_status = progress_status.strip()

watched_episodes = (
    item_data.get("watched_episode_count")
    or item_data.get("watched_count")
    or 0
)

total_episodes = (
    item_data.get("aired_episode_count")
    or item_data.get("episode_count")
    or 0
)

is_followed = (
    d.get("is_followed")
    if "is_followed" in d
    else item_data.get("is_followed", True)
)

created_at = (
    d.get("created_at")
    or item_data.get("created_at")
    or ""
)

updated_at = (
    d.get("updated_at")
    or item_data.get("updated_at")
    or ""
)

follow_date = format_timestamp(created_at)

last_watched = None

sorting = (
    item_data.get("sorting")
    or d.get("sorting")
    or []
)

if isinstance(sorting, list):
    for s in sorting:
        if isinstance(s, dict):
            sid = s.get("id")

            if sid in [
                "watch_date",
                "last_watched",
                "follow_date"
            ]:
                val = s.get("value")

                if val and not last_watched:
                    last_watched = val

last_watched_date = format_timestamp(
    last_watched or updated_at
)

hashtag = item_data.get("hashtag") or ""

images = item_data.get("images") or []

poster_data = item_data.get("poster") or {}
background_data = item_data.get("background") or {}

poster_url = (
    extract_image_url(images, "poster")
    or (
        poster_data.get("url", "")
        if isinstance(poster_data, dict)
        else ""
    )
)

fanart_url = (
    extract_image_url(images, "fanart")
    or (
        background_data.get("url", "")
        if isinstance(background_data, dict)
        else ""
    )
)

return {
    "name": name.strip(),
    "type": entity_type,
    "id": str(item_id),
    "status": str(status),
    "progress_status": progress_status,
    "watched_episodes": watched_episodes,
    "total_episodes": total_episodes,
    "is_followed": bool(is_followed),
    "country": country,
    "day_of_week": day_of_week,
    "rating": rating,
    "follower_count": follower_count,
    "follow_date": follow_date,
    "last_watched_date": last_watched_date,
    "hashtag": hashtag,
    "poster_url": poster_url,
    "fanart_url": fanart_url,
    "data_source": source_name
}

def parse_sqlite_db(db_path):
items = []

if not os.path.exists(db_path):
    return items

conn = sqlite3.connect(db_path)
cursor = conn.cursor()

try:
    cursor.execute(
        "SELECT content FROM cache_dio"
    )

    rows = cursor.fetchall()

    for row in rows:
        raw_content = row[0]

        if not raw_content:
            continue

        if isinstance(raw_content, bytes):
            text_content = raw_content.decode(
                "utf-8",
                errors="ignore"
            )
        else:
            text_content = str(raw_content)

        try:
            data_json = json.loads(text_content)

            if isinstance(data_json, list):
                for elem in data_json:
                    res = process_item_dict(
                        elem,
                        "DioCache.db"
                    )

                    if res:
                        items.append(res)

            elif isinstance(data_json, dict):

                for key in [
                    "series",
                    "shows",
                    "movies",
                    "data",
                    "items"
                ]:
                    if (
                        key in data_json
                        and isinstance(
                            data_json[key],
                            list
                        )
                    ):
                        for elem in data_json[key]:
                            res = process_item_dict(
                                elem,
                                "DioCache.db"
                            )

                            if res:
                                items.append(res)

                res = process_item_dict(
                    data_json,
                    "DioCache.db"
                )

                if res:
                    items.append(res)

        except Exception:

            matches = re.findall(
                r'(\{"id":\d+,"name":".*?\})',
                text_content
            )

            for m in matches:
                try:
                    parsed = json.loads(m)

                    res = process_item_dict(
                        parsed,
                        "DioCache.db"
                    )

                    if res:
                        items.append(res)

                except Exception:
                    pass

finally:
    conn.close()

return items

def parse_bplist_files(docs_dir):
items = []

if not os.path.exists(docs_dir):
    return items

files = [
    f
    for f in os.listdir(docs_dir)
    if f != "DioCache.db"
]

for filename in files:

    file_path = os.path.join(
        docs_dir,
        filename
    )

    if not os.path.isfile(file_path):
        continue

    try:
        with open(file_path, "rb") as f:

            header = f.read(8)

            if header.startswith(b"bplist"):

                f.seek(0)

                plist_data = plistlib.load(f)

                if isinstance(
                    plist_data,
                    dict
                ):

                    res = process_item_dict(
                        plist_data,
                        f"bplist ({filename[:8]})"
                    )

                    if res:
                        items.append(res)

    except Exception:
        pass

return items

def merge_and_deduplicate(items):

merged = {}

for item in items:

    key = (
        item["name"].lower(),
        item["id"]
    )

    if key not in merged:
        merged[key] = item

    else:

        existing = merged[key]

        for field in [
            "status",
            "progress_status",
            "country",
            "day_of_week",
            "rating",
            "follower_count",
            "hashtag",
            "poster_url",
            "fanart_url"
        ]:

            if (
                not existing.get(field)
                and item.get(field)
            ):
                existing[field] = item[field]

        if (
            item.get("watched_episodes", 0)
            > existing.get(
                "watched_episodes",
                0
            )
        ):
            existing["watched_episodes"] = (
                item["watched_episodes"]
            )

        if (
            item.get("total_episodes", 0)
            > existing.get(
                "total_episodes",
                0
            )
        ):
            existing["total_episodes"] = (
                item["total_episodes"]
            )

        if (
            item.get("last_watched_date")
            and item["last_watched_date"]
            > existing.get(
                "last_watched_date",
                ""
            )
        ):
            existing["last_watched_date"] = (
                item["last_watched_date"]
            )

result = list(merged.values())

result.sort(
    key=lambda x: x["name"].lower()
)

return result

def export_to_csv(items, output_path):

fieldnames = [
    "name",
    "type",
    "id",
    "status",
    "progress_status",
    "watched_episodes",
    "total_episodes",
    "is_followed",
    "country",
    "day_of_week",
    "rating",
    "follower_count",
    "follow_date",
    "last_watched_date",
    "hashtag",
    "poster_url",
    "fanart_url",
    "data_source"
]

with open(
    output_path,
    "w",
    newline="",
    encoding="utf-8-sig"
) as csvfile:

    writer = csv.DictWriter(
        csvfile,
        fieldnames=fieldnames
    )

    writer.writeheader()

    for item in items:
        writer.writerow(item)

def main():

sqlite_items = parse_sqlite_db(
    DB_PATH
)

bplist_items = parse_bplist_files(
    DOCS_DIR
)

all_items = (
    sqlite_items
    + bplist_items
)

unique_items = merge_and_deduplicate(
    all_items
)

export_to_csv(
    unique_items,
    OUTPUT_CSV
)

print(
    f"Exported {len(unique_items)} "
    "unique shows/movies to "
    "tvtime_export.csv"
)

if name == "main":
main()

RESULT

The final CSV file contains the recovered records that the script was able to identify from the extracted local data.

Depending on what data is still present in your TV Time app cache, the exported file may contain information such as:

Show or movie title
TV Time or TVDB related ID
Watched episode count
Total episode count
Follow status
Watch progress
Show status
Follow date
Last watched date
Country
Day of the week
Rating
Follower count
Hashtags
Poster URL
Fanart URL
Source of the recovered record

IMPORTANT NOTES

This method does not guarantee that every piece of TV Time data can be recovered.

The results depend entirely on what information is still stored locally on the device. If the app cache was cleared, the device was reset, or the relevant data was never stored locally, the script may not be able to recover it.

Also, the database structure and cached API responses may differ between TV Time app versions. The script is therefore intended as a starting point for analyzing an extracted TV Time app container rather than a guaranteed universal recovery tool.

In my case, iMazing allowed me to access the local app data that was still available on my device, and analyzing the SQLite database and other cached files helped me recover a significant amount of my TV Time library information.

If you still have an old iPhone or iPad that had TV Time installed, it may be worth checking whether the app's local data is still available before deleting the app or resetting the device.

I hope this helps anyone trying to recover their TV Time library or watch history.

Seeing a lot of "the app won't open, I lost everything" posts this week. Most of you probably haven't lost it. TV Time cached your whole history locally on the device, separate from the export a lot of people missed. If the app is still installed, that cache is very likely still there and recoverable.

Writing this up in one place because the same questions keep coming around.

Before anything else — do NOT do these:

• Don't uninstall the app
• Don't update it
• Don't factory reset or "clear cache/storage"

Any of those wipes the local copy, and right now it's the only copy left. Get the file off the device first, decide what to do with it second.

iPhone / iPad

The file is DioCache.db, an SQLite database inside TV Time's app container (it's the cache for the app's HTTP client, "Dio"). To pull it:

• Install iMazing (free trial, Windows or Mac).
• Plug in the phone, find TV Time under Apps, browse into its Documents folder, and export DioCache.db out.
• 3uTools works too if you'd rather not use iMazing.

An old iPhone backup works as a source as well, if you have one lying around.

Android

Harder, and honestly a coin flip. Without root, try:

adb backup -noapk com.tvshowtime.tvshowtime

It only works if the app allows backups, and newer Android versions often refuse. If it produces a file, the .ab is a zlib-wrapped tar — strip the 24-byte header, inflate, untar — and the same DioCache.db is inside. If backups are blocked and you're not rooted, I don't have a clean answer, but the file is still on the device, so hang onto the phone until a tool shows up.

What's actually in it

Show and movie names, TVDB/TV Time IDs, watched episode counts, per-episode watch flags and dates, follow status, ratings, poster URLs. One honest caveat people keep running into: the cache reliably knows how many episodes you watched of a show, but not always exactly which ones — so if you jumped around out of order, that part comes back approximate. Watched-in-order histories come back clean.

Where to take it once you have it

A few of us have been building parsers and importers this week — search this sub for "DioCache" and you'll find them, including a browser-only extractor by u/Joemag_xD where nothing leaves your machine. Several trackers now read it or the official GDPR zip directly.

Disclosure since it's relevant and I'd rather say it up front: I build one of them (bobinapp.com — free, no ads). It takes DioCache.db as-is and keeps your original watch dates. But the recovery steps above are the part that matters and they work no matter which app you land on — Trakt, Simkl, Serializd, whatever fits you. Get the file out first. That's the thing that isn't recoverable later.

So I did download my backup a week back, and got some files. I don't want to upload them to a new app so thought of just manually going over the files and adding to a Google sheet.

There's a bunch of files for TV shows but none for my movies!

Am I missing anything? Maybe they are not visible in the csv files??

Is there any bug with the latest update or something? I am trying to open this app on my samsung phobe since morning and i can't. I even tried opening in my ipad now and still can't log in. I dont know what happened, it was working fine until this weekend but then it requested for a re login and now it isn't working!

Now I watching tv shows and i can't see people theory or jokes...make me very sad because i'm an loner and for me, it was like a social app combine to a hobbies. Rip.

I was able to get the DioCache.db from my iphone backup and I was also able to import the data into a Google DOC file. Can we do anything with the DioCache.db to make imports easer.

I had no idea tv show time was ending. Opened my app yesterday and everything was just gone! Lowkey I’m devastated RIP all my show data…

Today I wanted to log a series that I was watching and to my surprise it was gone. Is there a way to somehow retrieve it? I was hoping at least they would send me an email with my exported files. I watched almost 8 months of series and now I have to try to somehow remember everything? Ouch.

I'm still terribly disappointed and frustrated. My entire history of watched TV shows—and even the ones I planned to watch—is just gone. I didn't get any notification that they were planning to close the service. Honestly, I used the browser version every single day, so why wasn't there an email or something? I know it probably seems like a minor issue to some, but I feel really bad about it.

Can i access my TV time account via email log in or is it too late 😔
I need my lists back if anyone knows how to track back