Find Where Your Archived Reddit Score Actually Changed

Reddit archive scores can change after collection because Reddit’s reported value changed, a mirror retrieved a newer value, or your collector overwrote the local record. An archived score is an observation, not a final vote count. First establish which two observations you are comparing.

A live Reddit page disagreeing with your archive does not mean the SQLite file changed. A refreshed SQLite score does not establish when—or why—the change occurred on Reddit.

Choose where the two scores came from; use the result to identify what to check next.

Score Changes Can Occur At Three Different Layers

Reddit Can Report A Different Value

Voting continues, and displayed values are not a reliable polling instrument. Reddit’s Reddiquette explicitly describes vote fuzzing intended to confuse spammers and cheaters. Do not interpret every small displayed fluctuation as a new human vote.

Reddit also reports revoking inauthentic votes. Its 2026 safety update says it revoked nearly two million daily over the preceding three months. That is a platform-reported aggregate, not evidence that a particular score drop was an enforcement action.

A Mirror Can Update Selected Fields

Arctic Shift’s dump documentation describes a second retrieval with a 36-hour delay. It updates fields including score, ups, downs, upvote_ratio, and num_comments, while merging metadata with the original record. The document excludes earlier Pushshift dumps—March 2023 and before—and notes that some modifications were introduced only in later dumps.

Preserved text and an archived score therefore need not describe the same moment. This documented second retrieval is not a guarantee that every mirror record is current or refreshed repeatedly.

A Collector Can Replace The Local Score

The collector’s refresh behavior determines whether a newer source value replaces the stored one. A static export stays unchanged unless something rewrites it; a working database can be refreshed.

The distinction matters when diagnosing a discrepancy: comparing a live page with an old export tests agreement between sources, while comparing two saved database snapshots tests whether the stored value changed.

RedLens Full Sync Can Replace Older Scores

The following behavior applies to RedLens v0.4.0 code as inspected on October 5, 2026:

Sync Or Write Path	Effect On Stored Scores
Default user sync	Uses creation-time cursors; does not generally refresh older scores
sync --full	Re-pulls available mirror history, including existing IDs
Existing-ID write	Replaces non-key fields, including score
Reported write count	Counts newly inserted rows, not refreshed rows

Once backfill is complete, default user sync mainly fetches newer items, with a one-second overlap at the boundary. It is not a general refresh of all older scores.

sync --full ignores those cursors and re-pulls the user’s available mirror history. It does not ask Reddit to re-observe those items. These behaviors are defined in the ingest implementation and mirror client.

When an existing post or comment is fetched again, the database write replaces its non-key fields. Because the reported write count counts newly inserted rows, a result of zero new posts does not prove nothing changed. See the database upsert implementation.

Local Ingestion Time Is Not Reddit Observation Time

RedLens stores one score per post or comment, not a score-history series. Its fetched_at is assigned locally when the model is constructed; it does not retain Arctic Shift’s retrieved_on or _meta.retrieved_2nd_on in those tables.

An absent or null source score becomes 0, so a stored zero is not necessarily an observed zero. These distinctions follow from the post and comment models.

Keep three clocks separate: content creation, mirror observation, and local ingestion. A recent fetched_at does not establish a recent Reddit observation. If the mirror returns an older observation during today’s sync, the local timestamp alone cannot reveal that age.

Preserve A Baseline Before Refreshing

For an existing RedLens archive, use a deliberate refresh rather than expecting ordinary incremental sync to update historical scores. If you are starting from scratch, follow the local user-history archive guide first.

This example assumes study.db already exists and contains the account you intend to refresh. Substitute that account for example_account. Stop other collectors writing to this database before taking the backup, and keep them stopped through the comparison.

With the SQLite command-line tool installed, run each command only after the preceding command succeeds:

redlens --version
sqlite3 study.db ".backup before-refresh.db"
redlens --db study.db sync example_account --full
sqlite3 study.db

Choose a new backup filename for each comparison. SQLite documents .backup in its command-line shell reference. The version option, full-sync flag, and placement of the global --db option are defined in the RedLens CLI.

Without a preserved baseline, the normalized score column cannot tell you its previous value. Refreshing first and attempting to reconstruct the old score afterward loses the comparison this workflow is designed to preserve.

Compare Scores For Matching Post And Comment IDs

At the SQLite prompt, attach the baseline and compare scores for IDs present in both snapshots:

ATTACH DATABASE 'before-refresh.db' AS baseline;
.headers on
.mode column

SELECT 'post' AS kind,
       n.post_id AS id,
       b.score AS score_before,
       n.score AS score_after,
       n.score - b.score AS delta,
       b.fetched_at AS fetched_before,
       n.fetched_at AS fetched_after
FROM main.post AS n
JOIN baseline.post AS b ON b.post_id = n.post_id
WHERE n.score <> b.score
UNION ALL
SELECT 'comment',
       n.comment_id,
       b.score,
       n.score,
       n.score - b.score,
       b.fetched_at,
       n.fetched_at
FROM main.comment AS n
JOIN baseline.comment AS b ON b.comment_id = n.comment_id
WHERE n.score <> b.score
ORDER BY kind, id
LIMIT 100;

The stored-score delta is score after minus score before.

The output contains up to 100 matching records whose stored scores differ, with the local ingestion timestamps on either side. This query covers the entire database, not only the refreshed account. Remove LIMIT 100 if you need the complete result rather than a preview.

It excludes new IDs and unchanged scores, and it cannot reconstruct changes between observations. The full-sync path does not delete stored rows merely because the source fails to return them, so this is not a deletion audit either.

Report A Stored-Score Delta, Not A Vote Count

Record the database filenames, account scope, software version, refresh start and end times in UTC, and the comparison query. If source-observation timing or missing-score status matters, retain the available raw mirror records separately: RedLens’s normalized tables cannot recover those distinctions later.

For score-based rankings, freeze the dataset and selection rule. Check whether your findings survive excluding score or using broad score bands. Comparing newly created and older content without a common observation-age rule can confound engagement with time available to accumulate votes.

A defensible finding is: “The same comment ID had different stored scores before and after a full mirror refresh.” It is not: “This account received exactly that many new votes,” or “Reddit caught this account manipulating votes.” Score differences alone cannot identify voters, establish intent, or prove coordination.