Why Arp-Hansen was fined DKK 1,000,000: customer data kept past its own deletion deadlines
If your privacy policy or retention schedule says customer data is deleted after a set period, something has to delete it when the period ends, and a retention constant that no code reads deletes nothing. In September 2023 a Danish court fined Arp-Hansen Hotel Group A/S, a hotel chain, DKK 1,000,000. According to the Danish data protection authority, the chain did not keep to deletion deadlines it had set itself, and about 500,000 customer profiles should already have been deleted.
The decision
- Country: Denmark. Company: Arp-Hansen Hotel Group A/S, a hotel chain.
- Who decided: a court. In Denmark the data protection authority (Datatilsynet) cannot impose GDPR fines itself; it reports the company to the police with a proposed amount, and a court decides [1]. The authority reported the company on 28 July 2020 and proposed DKK 1,100,000 (≈ €147,000). The district court in Lyngby found the company guilty, but a majority of its judges decided on no penalty, and the prosecution appealed [2].
- Court and date: Østre Landsret (High Court of Eastern Denmark), judgment of 20 September 2023.
- Amount: DKK 1,000,000 (≈ €134,000).
- Final or under appeal: according to the authority, the judgment "kan i udgangspunktet ikke ankes" (as a rule cannot be appealed (our translation)), and the company could ask the Appeals Permission Board for leave to go to the Supreme Court [2]. We found no Supreme Court case, so it is final as far as we could find, as of November 2026.
- Official texts: the authority's 2020 decision page, updated with the outcome [1] and its 2023 news item on the judgment [2]. Every quote about the case below is the authority's.
What the decision says the software did
During an inspection visit the authority went through several systems to see whether the company had procedures that keep personal data from being stored longer than necessary ([1], paragraph 2). What it found ([1], paragraph 3, company name replaced with a bracket):
"særligt et bookingsystem indeholdt mange personoplysninger, som burde have været slettet i henhold til [virksomhedens] egne fastsatte slettefrister. […] der var såkaldte kundeprofiler, som – efter [virksomhedens] egne slettefrister – burde være blevet slettet flere år tidligere. […] ca. 500.000 kundeprofiler burde have været slettet på tidspunktet for tilsynsbesøget."
(Our translation: "a booking system in particular contained a lot of personal data that should have been deleted under the deletion deadlines [the company] had set itself. […] there were so-called customer profiles which, under [the company's] own deletion deadlines, should have been deleted several years earlier. […] about 500,000 customer profiles should have been deleted at the time of the inspection visit.")
The page names the booking system as one place where data was overdue and gives the 500,000 profiles as a separate count.
What this looks like in code
In code, the gap looks like this: the deadline is written down and nothing acts on it. The example uses Django.
This is not Arp-Hansen's code. The decision does not publish any code; this reproduces the behaviour it describes.
# hotel/settings.py
from datetime import timedelta
# Our deletion deadline: a guest profile goes three years after the last stay.
GUEST_PROFILE_RETENTION = timedelta(days=3 * 365)
# bookings/models.py
from django.db import models
class Guest(models.Model):
email = models.EmailField(unique=True)
full_name = models.CharField(max_length=200)
phone = models.CharField(max_length=40, blank=True)
date_of_birth = models.DateField(null=True, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
last_stay = models.DateField(null=True, blank=True)
class Booking(models.Model):
guest = models.ForeignKey(Guest, on_delete=models.CASCADE, related_name="bookings")
check_in = models.DateField()
check_out = models.DateField()
special_requests = models.TextField(blank=True)
grep -rn GUEST_PROFILE_RETENTION . returns one line: the definition. Nothing in the project is scheduled to delete anything, so every guest row stays until someone deletes it by hand. A second gap: a guest who booked and never stayed has last_stay = NULL, and a job that filters on last_stay < cutoff never deletes that row.
The database shows the result. We filled the reproduction with five years of synthetic guests and ran this query, which counts profiles past the deadline, including guests who never stayed and leaving out guests with an upcoming stay:
-- :cutoff = today minus the retention period, minus two days of slack
SELECT count(*) AS overdue, min(g.last_stay) AS oldest_stay
FROM bookings_guest g
WHERE (g.last_stay < :cutoff
OR (g.last_stay IS NULL AND g.created_at < :cutoff))
AND NOT EXISTS (SELECT 1 FROM bookings_booking b
WHERE b.guest_id = g.id AND b.check_out >= :cutoff);
-- reproduction, 2,000 synthetic guests, cutoff 2023-11-16:
-- overdue = 232, oldest_stay = 2022-02-07
-- after one run of the job below: overdue = 0
Part of this would not show in code. A crontab on the production server or a schedule in a hosting dashboard decides whether a job runs, and the repository cannot show that it is installed or still running. Data copied out of the main system, into a spreadsheet export or a newsletter tool, is a separate copy that the job never touches, and so are backups.
Why it was a violation
The authority's page cites one provision, GDPR Article 5(1)(e), the storage limitation principle: personal data shall be "kept in a form which permits identification of data subjects for no longer than is necessary for the purposes for which the personal data are processed" [3].
It proposed the fine "for ikke at have levet op til forordningens krav om sletning (opbevaringsbegrænsning) i artikel 5, stk. 1, litra e" ([1], paragraph 6). (Our translation: "for not having complied with the Regulation's requirement of deletion (storage limitation) in Article 5(1)(e)".)
The head of its inspection unit gave the reason for the police report: in the authority's view the company "ikke har kunnet fremkomme med saglige grunde til den omfattende opbevaring af oplysninger" ([1], paragraph 5). (Our translation: "has not been able to put forward objective reasons for the extensive storage of data".)
After the judgment the authority described the offence: "Overtrædelsen bestod i, at hotelkæden ikke efterlevede de slettefrister, den selv havde fastsat." ([2], under "Manglede at slette oplysninger"). (Our translation: "The violation consisted in the hotel chain not complying with the deletion deadlines it had set itself.")
The fix
Give the deadline a job that deletes on it, and a check that fails when the job stops. In bookings/management/commands/purge_expired_guests.py:
from datetime import timedelta
from django.conf import settings
from django.core.management.base import BaseCommand, CommandError
from django.db.models import Q
from django.utils import timezone
from bookings.models import Guest, RetentionRun
def expired_guests(now=None):
cutoff = (now or timezone.now()) - settings.GUEST_PROFILE_RETENTION
return Guest.objects.filter(
Q(last_stay__lt=cutoff.date())
| Q(last_stay__isnull=True, created_at__lt=cutoff) # booked, never stayed
).exclude(bookings__check_out__gte=cutoff.date()) # keep upcoming stays
class Command(BaseCommand):
def add_arguments(self, parser):
parser.add_argument("--check", action="store_true")
def handle(self, *args, check=False, **options):
if check: # for monitoring: one day of slack between runs
grace = timezone.now() - timedelta(days=2)
if not RetentionRun.objects.filter(ran_at__gte=grace).exists():
raise CommandError("guest purge has not run in the last 2 days")
if expired_guests(now=grace).exists():
raise CommandError("guest profiles 2+ days past the retention period")
return
deleted, _ = expired_guests().delete() # bookings go too (CASCADE)
RetentionRun.objects.create(deleted=deleted)
RetentionRun is a model with ran_at (auto_now_add=True) and deleted. Schedule the purge daily, for example 15 3 * * * cd /srv/hotel && .venv/bin/python manage.py purge_expired_guests. --check exits non-zero when the purge has not run for two days or a profile is more than two days overdue. Run it from your monitoring system, separately from that crontab, so that a cron line lost in a server move raises an alert. A guest with a booking that ends after the cutoff, including a stay next month, is kept. If part of a booking must be kept longer for another purpose, such as accounting, move that part into its own table with its own stated period.
The test, in bookings/tests.py, fails on a version of the job without the .exclude(...) line, which deletes the returning guest and next month's booking:
from datetime import date, timedelta
from django.core.management import call_command
from django.test import TestCase
from django.utils import timezone
from bookings.models import Booking, Guest
FOUR_YEARS = timedelta(days=4 * 365)
class PurgeExpiredGuestsTest(TestCase):
def test_purge_keeps_only_current_guests(self):
today = date.today()
Guest.objects.create(email="overdue@x.test", last_stay=today - FOUR_YEARS)
Guest.objects.create(email="never-stayed@x.test")
back = Guest.objects.create(email="returning@x.test", last_stay=today - FOUR_YEARS)
Booking.objects.create(guest=back, check_in=today + timedelta(days=30),
check_out=today + timedelta(days=32))
Guest.objects.create(email="recent@x.test", last_stay=today - timedelta(days=100))
Guest.objects.exclude(email="recent@x.test").update(
created_at=timezone.now() - FOUR_YEARS)
call_command("purge_expired_guests")
self.assertEqual(set(Guest.objects.values_list("email", flat=True)),
{"returning@x.test", "recent@x.test"})
self.assertEqual(Booking.objects.count(), 1)
call_command("purge_expired_guests", "--check") # raises if not clean
Check your own code
- Take each period from your privacy policy or retention schedule and search for it in every form it could take:
3 * 365,1095,years=3,36months, and names likeretention,ttl,expire,purge,cleanup. For every hit, find the code that reads the value and deletes with it. - List every scheduled job the project declares:
crontabfiles,CELERY_BEAT_SCHEDULE,config/schedule.rb(whenever),sidekiq-cronentries,schedule:in.github/workflows/*.yml, KubernetesCronJobmanifests,cronsinvercel.json. If the deletion job is not on that list, the repository does not schedule it; find where it is scheduled. - For each table that holds customer data, find its delete:
.delete(),destroy_all,DELETE FROM. A table with acreated_atcolumn and no delete path keeps every row. - Check your deletion filter on two kinds of row: a
NULLdate (never deleted) and a future booking (deleted too early). - Run the overdue query above against production, with your own table names and period. It should return 0.
Sources
- Datatilsynet, decision page of 28 July 2020 (police report and proposed fine), with the update "Sådan er det gået med sagen" — https://www.datatilsynet.dk/afgoerelser/afgoerelser/2020/jul/arp-hansen-hotel-group-a/s-indstilles-til-boede
- Datatilsynet, "Landsretten giver bøde på 1. mio. kr. til hotelkæde", news item of 28 September 2023 — https://www.datatilsynet.dk/presse-og-nyheder/nyhedsarkiv/2023/sep/landsretten-giver-boede-paa-1-mio-kr-til-hotelkaede
- Regulation (EU) 2016/679 (GDPR), Article 5(1)(e) — https://eur-lex.europa.eu/eli/reg/2016/679/oj (wording checked against the text as adopted, https://www.legislation.gov.uk/eur/2016/679/article/5/adopted)
Quotations were checked against these sources on 17 November 2026.
This is general information about a published court fine, written by a software developer, and not legal advice.
This article was written with AI assistance and checked against the official sources listed above.
WolfBoy on GitHub: github.com/innit-llc/wolfboy