diff --git a/Changes b/Changes
index 126a723..400d0cf 100755
--- a/Changes
+++ b/Changes
@@ -1,4 +1,4 @@
-0.42 2021-05-19
+0.42 2021-06-09
         - Added GitHub based CI for perl.
         - Added further methods for communicating JSON Files
           with the server to the APIs (lerepp).
@@ -16,6 +16,10 @@
           and getElementsById instead of child accessors
           (lerepp).
         - List tokens of a client.
+        - Upgrade Mojolicious dependency to 9.19.
+
+        WARNING: Upgrading to Mojolicious 9.19 will
+          invalidate all sessions. This is a security update.
 
 0.41 2021-03-01
         - Introduce CORS headers to the proxy.
diff --git a/Makefile.PL b/Makefile.PL
index 56f1696..40de23c 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -16,7 +16,7 @@
   },
   LICENSE      => 'freebsd',
   PREREQ_PM => {
-    'Mojolicious' => '8.42',
+    'Mojolicious' => '9.19',
     'Mojolicious::Plugin::TagHelpers::Pagination' => 0.08,
     'Mojolicious::Plugin::TagHelpers::MailToChiffre' => 0.13,
     'Mojolicious::Plugin::ClosedRedirect' => 0.15,
diff --git a/t/match_info.t b/t/match_info.t
index 4e20fb5..1dfa55f 100644
--- a/t/match_info.t
+++ b/t/match_info.t
@@ -25,7 +25,7 @@
 $fake_backend->pattern->defaults->{app}->log($t->app->log);
 
 # Query passed
-$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&format=json')
+$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&_format=json')
   ->status_is(200)
   ->content_type_is('application/json;charset=UTF-8')
   ->json_is('/textSigle', 'WPD15/232/39681')
@@ -33,7 +33,7 @@
   ->header_isnt('X-Kalamar-Cache', 'true')
   ;
 
-$t->get_ok('/corpus/GOE/AGF/02286/p75682-75683?format=json')
+$t->get_ok('/corpus/GOE/AGF/02286/p75682-75683?_format=json')
   ->status_is(200)
   ->json_is('/textSigle', 'GOE/AGF/02286')
   ->json_is('/title','Materialien zur Geschichte der Farbenlehre')
@@ -41,13 +41,13 @@
 
 # TODO:
 #   It's surprising, that it doesn't return a 404!
-$t->get_ok('/corpus/notfound/X/X/p0-1?format=json')
+$t->get_ok('/corpus/notfound/X/X/p0-1?_format=json')
   ->status_is(200)
   ->json_is('/textSigle', 'NOTFOUND/X/X')
   ->json_is('/corpusID', undef)
   ;
 
-$t->get_ok('/corpus/fail/x/x/p0-0?format=json')
+$t->get_ok('/corpus/fail/x/x/p0-0?_format=json')
   ->status_is(400)
   ->json_is('/notifications/0/0', 'error')
   ->json_like('/notifications/0/1', qr!Unable to load query response from .+?response_matchinfo_fail_x_x_p0-0\.json!)
@@ -55,25 +55,25 @@
 
 # TODO:
 #   Should probably return a 4xx!
-$t->get_ok('/corpus/GOE/AGF/02286/p-2-0?format=json')
+$t->get_ok('/corpus/GOE/AGF/02286/p-2-0?_format=json')
   ->status_is(400)
   ->json_is('/notifications/0/0', 'error')
   ->json_is('/notifications/0/1', '730: Invalid match identifier')
   ;
 
-$t->get_ok('/corpus/notfound2/X/X/p0-1?format=json')
+$t->get_ok('/corpus/notfound2/X/X/p0-1?_format=json')
   ->status_is(404)
   ->json_is('/notifications/0/0', 'error')
   ->json_is('/notifications/0/1', '404: Not Found')
   ;
 
-$t->get_ok('/corpus/brokenerr/X/X/p0-1?format=json')
+$t->get_ok('/corpus/brokenerr/X/X/p0-1?_format=json')
   ->status_is(409)
   ->json_is('/notifications/0/0', 'error')
   ->json_is('/notifications/0/1', 'Message structure failed')
   ;
 
-$t->get_ok('/corpus/brokenwarn/X/X/p0-1?format=json')
+$t->get_ok('/corpus/brokenwarn/X/X/p0-1?_format=json')
   ->status_is(200)
   ->json_is('/notifications/0/0', 'warn')
   ->json_is('/notifications/0/1', '1: Warning 1')
@@ -81,14 +81,14 @@
   ->json_is('/notifications/1/1', 'Message structure failed')
   ;
 
-$t->get_ok('/corpus/brokenerr2/X/X/p0-1?format=json')
+$t->get_ok('/corpus/brokenerr2/X/X/p0-1?_format=json')
   ->status_is(417)
   ->json_is('/notifications/0/0', 'error')
   ->json_is('/notifications/0/1', 'Message structure failed')
   ;
 
 # Get from cache
-$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&format=json')
+$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&_format=json')
   ->status_is(200)
   ->json_is('/textSigle', 'WPD15/232/39681')
   ->json_like('/snippet', qr!<span class=\"context-left\">!)
@@ -96,12 +96,12 @@
   ;
 
 # Check for validation error
-$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=no&format=json')
+$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=no&_format=json')
   ->status_is(400)
   ->json_is('/notifications/0/1', 'Parameter "spans" invalid')
   ;
 
-$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=no&format=html')
+$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=no&_format=html')
   ->content_type_is('text/html;charset=UTF-8')
   ->status_is(400)
   ->text_is('p.no-results', 'Unable to perform the action.')
diff --git a/t/meta-robots.t b/t/meta-robots.t
index 75273b9..072d6f5 100644
--- a/t/meta-robots.t
+++ b/t/meta-robots.t
@@ -68,7 +68,7 @@
   ->header_is('X-Robots', 'noindex')
   ;
 
-$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&format=json')
+$t->get_ok('/corpus/WPD15/232/39681/p2133-2134?spans=false&foundry=*&_format=json')
   ->status_is(200)
   ->header_is('X-Robots', 'noindex')
   ;
