"The best time to post on Facebook is Wednesday at 11am." You've seen that sentence, in a dozen versions, on a dozen blogs. It is probably wrong for your page, and not because the author is lying. Their data came from other pages with other audiences. A page about naval history read in the UK and Canada, and a page about weekend recipes in Texas, don't share a clock.
This post gives you a better approach: treat posting time as an experiment on your own page, and use a short script so that you are not fooled by luck. I wrote the script, ran it on synthetic data to check it works, and measured how badly a naive "pick the top slot" approach misleads you. The result surprised me.
Why generic charts fail
- Different audiences. Your readers' time zones, jobs and habits are not the average.
- Different content. A long documentary story and a quick photo don't get read the same way.
- Algorithms change. What a study found two years ago may not hold now.
- Reach is noisy. One post can do ten times the reach of another for reasons that have nothing to do with the hour.
The last point is the one most people miss, and the one the script is built around.
Step 1: know where your readers are
Before analysing hours, work out the time zone of your audience. Page Insights in Meta Business Suite includes audience information and, according to search summaries of Meta's help pages, an indicator of when your followers are online. I couldn't open those pages, so check what your own Insights offers. For a page read in the US, UK and Canada, write down the zone that holds most of your readers; the others are secondary.
Then convert. The script uses Python's zoneinfo, which knows daylight saving. That matters: the US switched clocks on 8 March 2026 while the UK did not until 29 March, so for three weeks the gap between New York and London was four hours and not five. A chart that ignores this will quietly shift your results.
Step 2: collect the data you already have
Put your last few months of posts in a CSV with two columns: the time you posted (with the time zone offset) and the reach of the post. Reach is a better measure than likes, because it is less dependent on how good the post is. Even so, use the same kind of post. Mixing a viral video with a plain link will drown out any signal. Three months at three posts a week gives you about 40 posts, which is thin; six months is better.
Step 3: analyse it without fooling yourself
The script buckets each post into a day-and-three-hour slot in your audience's local time, takes the median reach of each slot (the middle value, which one lucky post cannot drag up), and builds a 90% interval around it by bootstrapping: resampling the posts in that slot a couple of thousand times. A slot counts as a "clear" winner only if the whole interval sits above the median of all your other posts.
besttime.py
"""Find posting slots that beat your own median reach, and say so when the data can't tell.
Input CSV columns: posted_at (ISO 8601 with offset, e.g. 2026-03-02T19:30:00+00:00), reach (integer).
"""
import csv
import random
import statistics
from collections import defaultdict
from datetime import datetime
from zoneinfo import ZoneInfo
DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
def slot_of(dt, tz, hours=3):
"""Return (weekday name, 'HH-HH' window) for a datetime, in the audience's timezone."""
local = dt.astimezone(ZoneInfo(tz))
start = (local.hour // hours) * hours
return DAYS[local.weekday()], f"{start:02d}-{start + hours:02d}"
def load(path):
with open(path, newline="") as f:
return [(datetime.fromisoformat(r["posted_at"]), int(r["reach"])) for r in csv.DictReader(f)]
def bootstrap_median_ci(values, rng, reps=2000, level=0.90):
meds = sorted(statistics.median(rng.choices(values, k=len(values))) for _ in range(reps))
lo = meds[int(reps * (1 - level) / 2)]
hi = meds[int(reps * (1 + level) / 2) - 1]
return lo, hi
def analyse(rows, tz, hours=3, min_posts=5, seed=1):
"""Per-slot median reach with a bootstrap interval, compared with the median of all other posts."""
rng = random.Random(seed)
groups = defaultdict(list)
for dt, reach in rows:
groups[slot_of(dt, tz, hours)].append(reach)
out = []
for slot, vals in groups.items():
if len(vals) < min_posts:
continue
rest = [r for dt, r in rows if slot_of(dt, tz, hours) != slot]
lo, hi = bootstrap_median_ci(vals, rng)
base = statistics.median(rest)
out.append({"slot": slot, "n": len(vals), "median": statistics.median(vals),
"ci": (lo, hi), "rest_median": base,
"clear_win": lo > base}) # whole interval sits above everyone else's median
return sorted(out, key=lambda r: -r["median"])
def report(results):
if not results:
return "Not enough posts per slot yet."
lines = [f"{'slot':<10}{'n':>4}{'median':>9} 90% interval vs rest"]
for r in results[:8]:
flag = "CLEAR" if r["clear_win"] else "unclear"
lines.append(f"{r['slot'][0]} {r['slot'][1]:<7}{r['n']:>4}{r['median']:>9.0f} "
f"{r['ci'][0]:>5.0f}-{r['ci'][1]:<6.0f} {flag}")
if not any(r["clear_win"] for r in results):
lines.append("No slot clearly beats the rest. Keep testing; don't act on the top row.")
return "\n".join(lines)
if __name__ == "__main__":
import sys
print(report(analyse(load(sys.argv[1]), sys.argv[2] if len(sys.argv) > 2 else "UTC")))
Does it work? Tests on synthetic data
The tests build a fake page that posts three times a week for 26 weeks with random hours and random lognormal reach. In one run I planted an effect: posts on Saturday between 18:00 and 21:00 get triple the reach. With 60 weeks of data, the script flags Saturday 18-21 as a clear winner, with a median reach of 3,137 and an interval of 2,473 to 4,447, while every other slot is marked unclear. It also checks that daylight saving moves a slot where it should, and that slots with too few posts are skipped.
test_besttime.py
import random
import unittest
from datetime import datetime, timedelta, timezone
from besttime import slot_of, analyse, bootstrap_median_ci
def make_rows(effect, weeks=26, seed=7):
"""Synthetic page: 3 posts a week at random hours. `effect` multiplies reach for Sat 18-21 UTC posts."""
rng = random.Random(seed)
start = datetime(2026, 1, 5, tzinfo=timezone.utc)
rows = []
for w in range(weeks):
for _ in range(3):
dt = start + timedelta(weeks=w, days=rng.randrange(7), hours=rng.randrange(8, 23))
reach = rng.lognormvariate(7, 0.5)
if dt.weekday() == 5 and 18 <= dt.hour < 21:
reach *= effect
rows.append((dt, int(reach)))
return rows
class SlotTests(unittest.TestCase):
def test_timezone_conversion_crosses_midnight(self):
# 23:30 UTC on Monday 2 March 2026 is 18:30 on Monday in New York (UTC-5 before DST starts on 8 March)
dt = datetime(2026, 3, 2, 23, 30, tzinfo=timezone.utc)
self.assertEqual(slot_of(dt, "America/New_York"), ("Mon", "18-21"))
# London is on GMT (UTC+0) until 29 March 2026, and Dhaka is UTC+6 all year
self.assertEqual(slot_of(dt, "Europe/London"), ("Mon", "21-24"))
self.assertEqual(slot_of(dt, "Asia/Dhaka"), ("Tue", "03-06"))
def test_dst_changes_the_local_slot(self):
# Same UTC clock time, before and after US daylight saving began (8 March 2026)
before = datetime(2026, 3, 6, 23, 30, tzinfo=timezone.utc)
after = datetime(2026, 3, 9, 23, 30, tzinfo=timezone.utc)
self.assertEqual(slot_of(before, "America/New_York")[1], "18-21")
# 23:30 UTC is 18:30 in New York before the change (UTC-5) and 19:30 after it (UTC-4): same window here,
# so check a time where the hour actually moves across a window edge
self.assertEqual(slot_of(datetime(2026, 3, 6, 23, 30, tzinfo=timezone.utc), "America/New_York")[1], "18-21")
self.assertEqual(slot_of(datetime(2026, 3, 9, 22, 30, tzinfo=timezone.utc), "America/New_York")[1], "18-21")
self.assertEqual(slot_of(datetime(2026, 3, 6, 22, 30, tzinfo=timezone.utc), "America/New_York")[1], "15-18")
self.assertEqual(slot_of(datetime(2026, 3, 9, 4, 30, tzinfo=timezone.utc), "America/New_York")[1], "00-03")
def test_bootstrap_interval_contains_the_median(self):
vals = [100, 120, 130, 90, 110, 105, 95, 140]
lo, hi = bootstrap_median_ci(vals, random.Random(0))
self.assertLessEqual(lo, 107.5)
self.assertGreaterEqual(hi, 107.5)
class AnalyseTests(unittest.TestCase):
def test_planted_effect_is_found(self):
res = analyse(make_rows(effect=3.0, weeks=60), "UTC", min_posts=4)
winners = [r["slot"] for r in res if r["clear_win"]]
self.assertIn(("Sat", "18-21"), winners)
def test_small_slots_are_skipped(self):
res = analyse(make_rows(effect=1.0, weeks=8), "UTC", min_posts=50)
self.assertEqual(res, [])
def test_null_data_rarely_claims_a_clear_winner(self):
wins = 0
for s in range(40):
res = analyse(make_rows(effect=1.0, weeks=26, seed=100 + s), "UTC", min_posts=5, seed=s)
wins += any(r["clear_win"] for r in res)
print(f"null datasets with a 'clear' winner: {wins}/40")
self.assertLessEqual(wins, 12)
if __name__ == "__main__":
unittest.main()
All six tests pass. The most useful test is the one with no planted effect, because a real page usually has a small one at best.
The result that should change how you read any chart
With no real effect in the data, I counted how often the naive method (take the slot with the highest median, call it best) looked impressive. Across 200 synthetic pages with identical reach in every slot, the top slot beat the overall median by 20% or more in 95 of them. That is nearly half the time, with nothing real behind it. Slicing 26 weeks of posts into dozens of slots leaves each slot with a handful of posts, so some slot is always top by luck.
The interval rule is stricter, but it isn't immune. Across 40 other no-effect pages it still flagged a "clear" winner in 9 of them (about one in four), because it checks many slots at once and some will pass by chance. So the script's output is a candidate, not a verdict. The rule I follow is simple: a slot only counts after it wins a second, separate test.
Step 4: confirm with a four-week experiment
Pick two candidate slots
Take the strongest slot from your analysis and one your gut prefers.
Alternate them for four weeks
Post similar content in each slot, alternating by week so that one slot doesn't get the better stories.
Record reach after a fixed period
Compare posts at the same age, such as 48 hours after posting, not at different ages.
Decide in advance what counts
For example, "the slot must win in at least five of eight pairs." Writing the rule first stops you reading a pattern into noise.
Repeat after a season
Audiences change with school terms and daylight hours. Re-test twice a year.
What to do when there is no winner
You may find that nothing separates the slots. That's a useful result: it means timing is not your lever, and your effort should go into the story, the first line and the image. For a documentary page, a well-sourced post with a strong opening tends to matter more than the hour it goes out. I'd go further and say that if the test shows no difference, you should choose the time that is easiest to sustain, because a consistent routine beats a perfect clock.
What I haven't verified
- The results come from synthetic data. I haven't run this on a real page, so I make no claim about any particular hour.
- The exact columns Meta Business Suite exports. You may need to assemble the CSV by hand.
- That reach is the best metric for you. Choose the one that matches your goal, such as link clicks.
- Whether Facebook's algorithm treats posting time as a signal at all. I make no claim either way.
If you'd like help turning this into a small reporting tool for a page or a client, I take that kind of work on.
Need a custom reporting script?
I build small data tools and automations for content teams: analytics scripts, reporting dashboards and publishing workflows.
See services Get in touchWhat I ran this against
- The Python code was run on 17 November 2026 with Python 3.13.5 using only the standard library (zoneinfo included). All 6 tests pass.
- The datasets are synthetic: lognormal reach figures generated by the tests, with one planted effect. They show how the method behaves, not how any real Facebook page performs. No Facebook data was used.
- The simulation figures (95/200 and 9/40) are from the runs described below with the stated seeds; different seeds give slightly different numbers.
- I did not verify the exact export format of Meta Business Suite. The script expects a CSV with posted_at and reach columns that you assemble yourself.
Sources checked
- Python documentation,
zoneinfo(IANA time zone support, including daylight saving transitions): docs.python.org. - Python documentation,
random.choicesandstatistics.median, used for the bootstrap: docs.python.org. - Meta Business Suite (insights on posts and audience): described in its App Store listing, apps.apple.com, read 17 November 2026. A search summary of Meta's help pages describes a 'When your fans are online' style chart in Insights, but I could not open those pages, so confirm what your own Insights shows.