diff --git a/pages/nucleus/verify/failure.js b/pages/nucleus/verify/failure.js
index 75c2296..61b58d0 100644
--- a/pages/nucleus/verify/failure.js
+++ b/pages/nucleus/verify/failure.js
@@ -1,6 +1,5 @@
 import { Component } from 'react'
 import Header from '../../../Components/Header'
-import Link from 'next/link'
 
 class Failed extends Component {
     constructor(props) {
@@ -11,7 +10,7 @@
         return (
             <Header
                 name="Verification failed"
-                subtext={<p>Please try again, and if the error persists please contact us at <Link href="mailto:verification@clicks.codes" target="_blank" rel="noopener noreferrer">verification@clicks.codes</Link></p>}
+                subtext={<p>Please try again, and if the error persists please contact us at <a href="mailto:verification@clicks.codes" target="_blank" rel="noopener noreferrer">verification@clicks.codes</a></p>}
                 gradient={["F27878", "D96B6B"]}
                 wave="web/waves/header/nucleus"
                 buttons={[]}
