Date errors in scraped data rarely look like errors. A value such as 03/04/2026 parses without complaint, a timestamp without a time zone lands in the right column, and a listing marked "2 days ago" becomes a valid date. The mistakes surface weeks later, as a spike on the wrong day or a trend that shifts by a few hours. The seven problems below cause most of them. For each, there is a concrete check with a hypothetical example, and a note on what the check catches and what it misses.
One principle applies to all seven: keep the original text exactly as collected, next to the normalized value. When a parsing rule turns out to be wrong, you can re-parse from the original instead of collecting again. Storing normalized timestamps in UTC with the source's time zone recorded is the usual target format, and the items below are about getting there correctly.
1. Relative dates such as "3 hours ago" or "yesterday"
Many pages show age rather than a date: "posted 3 hours ago", "yesterday", "last week". Converting these requires an anchor, and the only correct anchor is the moment the page was fetched, not the moment the parser ran. If pages are parsed in a later batch, using the parsing time shifts every record by the delay between the two.
The fix: store the fetch timestamp with every raw page, and convert relative expressions against it. Record the precision as well: "3 hours ago" is accurate to about an hour, "last week" only to several days, and the normalized field should not pretend otherwise. A separate precision field, or a range with an earliest and latest possible time, keeps that honest.
Check: suppose a hypothetical batch of pages was fetched at 09:00 and parsed at 15:00. Re-parse a sample using both anchors; if your stored dates match the 15:00 version, the anchor is wrong. This check catches a wrong anchor; it does not catch pages that round ages inconsistently, such as switching from hours to "1 day" after 24 hours.
2. Day and month in an ambiguous order
03/04/2026 is the 4th of March in the United States and the 3rd of April in much of the rest of the world. A parser that guesses will get one convention right and silently scramble the other, and the error only becomes visible when the day is above 12.
The fix: set the date format per source, based on the site's locale, and never rely on automatic detection across sources. The same applies to month names in other languages and to formats such as 4 Mar 2026 or 2026-03-04: write the expected pattern for each source and reject values that do not match it, instead of letting a lenient parser accept them.
Check: for each source, count how many parsed dates have a day value above 12. If a source has none over several weeks, its dates are probably being read with day and month swapped, or failing over to a default. This catches a swapped order; it cannot detect a swap in the first twelve days of a month on its own, which is why the per-source format must be set explicitly.
3. Times with no time zone
A page that says "Published 10:30" is usually showing local time, either the site's own time zone or the visitor's, and it rarely says which. Treating it as UTC shifts every record by several hours, enough to move items across a day boundary and distort daily counts.
The fix: determine each source's time zone once, from the site's stated location, from a timestamp in structured data that includes an offset, or by comparing a displayed time with a machine-readable one on the same page. Store it as a named time zone, such as America/Chicago, rather than a fixed offset, so daylight saving changes are applied correctly. If the page shows a time adjusted to the visitor's location, note the location your requests come from, because that is the time zone you were shown.
Check: plot the hour of day for a week of records from one source. Activity that peaks at 3 in the morning for a business that publishes during office hours usually means the time zone is wrong. This catches large offsets; a one-hour error can hide inside normal variation.
4. Daylight saving gaps and repeats
When clocks move forward, one local hour does not exist; in the United States, for example, local times between 2:00 and 3:00 are skipped on the spring change date. When clocks move back, one hour happens twice. A record stamped 1:30 on the autumn change date could be either of two moments.
The fix: convert using a time zone library that follows the official time zone rules, and decide explicitly what to do with nonexistent and repeated times. A common choice is to flag them and pick the earlier interpretation for repeats. If the source offers a timestamp with an offset anywhere on the page, prefer it, because the offset resolves the ambiguity.
Check: after each daylight saving change in the source's time zone, look for records whose local time falls in the skipped hour, which cannot be real, and for a doubled count in the repeated hour. This catches the conversion errors around the change; it does not tell you which of two repeated moments was intended.
5. Dates without a year
Listings and events often show "Mar 4" or "Friday, 14:00" with no year. The parser fills in the current year, which is right most of the time and wrong around the turn of the year: an event page fetched on December 28 that says "Jan 3" refers to next year, and a post fetched on January 2 marked "Dec 30" refers to last year.
The fix: infer the year from the fetch date and the kind of date. A publication date cannot be in the future, so a result after the fetch date belongs to the previous year. An event or deadline date usually lies ahead, so a result well before the fetch date belongs to the next year. Store a flag that the year was inferred.
Check: after the first week of January, count publication dates later than their fetch date and event dates more than a few weeks before their fetch date. Either count above zero points to a rollover error. This check depends on knowing which kind of date each field holds, which is the subject of the last item.
6. Epoch timestamps in seconds and milliseconds
Pages and embedded data often carry timestamps as a count since 1 January 1970 UTC. Some systems count seconds, others milliseconds, and the two are easy to confuse: a seconds value read as milliseconds lands in January 1970, and a milliseconds value read as seconds lands tens of thousands of years in the future.
The fix: decide the unit per field, from the number of digits and the source's behavior, and reject values outside a plausible range rather than storing them. For current dates, a seconds value has 10 digits and a milliseconds value has 13.
Check: set a plausible range for each date field, for example from the source's launch year to a few days after the fetch date for publication dates, and count values outside it. Dates in 1970 or in a distant future are almost always a unit error. This catches unit confusion; it misses a date that is wrong but plausible.
7. One date, several meanings
A page can show a publication date, an update date, an event date, an expiry date, and the site may change which one appears in a given spot. Collecting "the date" without knowing which one it is produces a column that mixes meanings, and every later analysis inherits the confusion. A news article updated today with a "date" field holding the update time will look like a new article.
The fix: name each date field after its meaning, such as published_at, updated_at and event_start, and record the label the page displayed next to the value. Keep the fetch time as its own field too, since it is the only date you know for certain. Where structured data on the page labels dates explicitly, prefer it over visible text.
Check: for each source, compare published_at and updated_at on a sample. If they are always identical, or if published_at keeps moving forward for the same record across runs, the field probably holds an update date. The same comparison is a useful monitoring signal at scale, and it matters for social platforms, where edited posts carry several timestamps. If ScrapingIsNotACrime or any other provider delivers part of your data, ask for the original date text and the fetch time in each record, so these seven checks can be run on delivered data as well.