Who called me back when I never called? Check the claim against your own call log
"We're returning your missed call." If you never called, the claim is testable. Before you search who called me, your phone's own call history can answer a narrower question: did this device dial that number recently? Th
"We're returning your missed call." If you never called, the claim is testable. Before you search who called me, your phone's own call history can answer a narrower question: did this device dial that number recently? That check is small enough to script, and the tricky part is not the loop but normalising UK numbers so that two spellings of the same line compare equal.
Affiliation and AI note: This post is promotional editorial from the website whocallme.co.uk and was drafted with AI assistance. The Python below is an illustrative sketch. It was run locally on a synthetic log to confirm it executes, and the output shown is from that run. All numbers in the examples come from Ofcom's ranges reserved for drama and fiction.
The source note
The number page for 07890 642441 lists a mobile, allocation hint EE Limited (Orange), numbering area Mobile. Range labels describe where a number block was allocated. They do not identify the person using it, and caller ID can be spoofed.
At fetch time the page showed seven searches, one user report and a "first seen: 1 days ago" page label. That label is not the date of the note. The report is imported and its original publication date is unknown. The visitor chose the category Neutral.
The visitor wrote that the caller said they "was calling back after I left a missed call". The visitor replied that they hadn't called. The caller suggested "maybe someone is using your number". The visitor said they didn't think so and hung up.
That is the whole record. Nothing below assumes who was calling or why.
Two claims, two different checks
The exchange contains two separate assertions:
- "You called us." A claim about your outbound history. Your device keeps a log of calls it placed, so this is checkable from your side.
- "Someone may be using your number." A claim about spoofing. Calls placed elsewhere with your number shown as the caller ID would never appear in your log, so your device cannot confirm or rule this out.
Keeping these apart matters. The first is answerable with local data. The second is a suggestion you cannot verify during the call, and it should not change what you share.
Normalising UK numbers
A call log export, a contact card and a number read aloud rarely agree on format. The same mobile can appear as 07700 900123, +44 7700 900123, 0044 7700 900123 or the hybrid +44 (0)7700 900123. A naive digit strip turns the last one into 4407700900123, which matches nothing.
A small normaliser to E.164 handles the common cases and refuses to guess on the rest:
import csv, io, re
from datetime import datetime, timedelta
def to_e164_uk(raw: str):
"""Normalise a UK-style number for comparison. Returns None if unsure."""
s = raw.replace("(0)", "") # "+44 (0)7700 ..." trunk-prefix habit
digits = re.sub(r"\D", "", s)
if s.strip().startswith("+"):
return "+" + digits
if digits.startswith("00"):
return "+" + digits[2:]
if digits.startswith("0") and len(digits) in (10, 11):
return "+44" + digits[1:]
return None # don't guess
Returning None for 7700900123 (no trunk prefix, no country code) is deliberate. A false match is worse than an honest "can't tell".
Checking the claim against the log
Assume a CSV export with a timestamp, a direction, a number and a duration. Many phones and carriers let you export something similar, though column names vary. The check looks for outgoing calls to the claimed number inside a lookback window, and separately notes inbound or missed calls from it:
def load_log(text: str):
rows = []
for r in csv.DictReader(io.StringIO(text)):
rows.append({
"at": datetime.fromisoformat(r["timestamp"]),
"direction": r["direction"],
"number": to_e164_uk(r["number"]),
"seconds": int(r["duration_s"]),
})
return rows
def check_callback_claim(rows, claimed_number, claimed_at, lookback_days=7):
target = to_e164_uk(claimed_number)
if target is None:
return {"verdict": "cannot normalise claimed number"}
start = claimed_at - timedelta(days=lookback_days)
window = [r for r in rows if start <= r["at"] <= claimed_at]
out = [r for r in window if r["direction"] == "outgoing" and r["number"] == target]
inc = [r for r in window if r["direction"] in ("incoming", "missed") and r["number"] == target]
if out:
verdict = "this device did dial the number in the window"
else:
verdict = "no outgoing call to this number from this device in the window"
return {"target": target, "window_rows": len(window),
"outgoing_matches": [r["at"].isoformat() for r in out],
"earlier_inbound_from_it": [r["at"].isoformat() for r in inc],
"verdict": verdict}
The synthetic log used for the run:
timestamp,direction,number,duration_s
2026-11-03T18:42:00,outgoing,020 7946 0321,0
2026-11-05T09:10:00,incoming,+44 7700 900456,0
2026-11-07T12:00:00,outgoing,0113 496 0999,212
2026-11-08T20:15:00,missed,07700900123,0
2026-11-09T08:05:00,outgoing,+44 (0)20 7946 0321,48
Output from the local run (normaliser cases first, then three claims):
'07700 900123' -> +447700900123
'+44 (0)7700 900123' -> +447700900123
'0044 7700 900123' -> +447700900123
'7700900123' -> None
07700 900123 {'target': '+447700900123', 'window_rows': 4, 'outgoing_matches': [], 'earlier_inbound_from_it': ['2026-11-08T20:15:00'], 'verdict': 'no outgoing call to this number from this device in the window'}
020 7946 0321 {'target': '+442079460321', 'window_rows': 4, 'outgoing_matches': ['2026-11-09T08:05:00'], 'earlier_inbound_from_it': [], 'verdict': 'this device did dial the number in the window'}
0113 496 0999 {'target': '+441134960999', 'window_rows': 0, 'outgoing_matches': [], 'earlier_inbound_from_it': [], 'verdict': 'no outgoing call to this number from this device in the window'}
Three things show up in that output:
- Claim one: no outgoing call, but a missed inbound call from the same number earlier. A "callback" story can grow from the caller's own unanswered attempt.
-
Claim two: a real outgoing call, written as
+44 (0)20 ...in the log and020 ...in the claim. Without normalisation, it would have been missed. - Claim three: the window matters. The outgoing call to that number happened, but it falls outside seven days. Pick the window to fit the claim, and record which one you used.
Limits of a local log
A negative result means "this device has no record". It does not mean "you never called". Logs can be cleared, capped in length, or split across a second phone, a landline, a softphone or Wi-Fi calling on another device. If several devices share your number, check each one.
A positive result is not authentication either. Knowing that you dialled a number a few days ago tells you nothing about who answers it today.
And as noted above, the spoofing suggestion sits outside the log entirely. It is not a reason to confirm personal details to prove you are you.
A minimal decision table
| Log result | Meaning | Action |
|---|---|---|
| no outgoing match | this device did not dial it in the window | decline, end the call, note it |
| outgoing match | you did call that number | still call back via a number you looked up |
| cannot normalise | format unknown | treat as no match |
Every row ends with you choosing the channel.
Where a lookup fits
The visitor note about a missed-call callback adds context to a record like this: one other person heard a similar opening from the displayed number. It is anonymous and unverified, and it identifies nobody.
For numbers that are not yet in your log, a searchable index of reported UK lines is a quick way to add a category to the claim field. The log answers what you did. The lookup only adds what others say.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes โ full credit and traffic to the original publisher.