diff --git a/client/src/components/JamiIdCard.js b/client/src/components/JamiIdCard.js
index 68c4e6c..32949d6 100644
--- a/client/src/components/JamiIdCard.js
+++ b/client/src/components/JamiIdCard.js
@@ -1,29 +1,19 @@
 import React from 'react';
 import { Box, Card, CardContent, Typography } from '@mui/material';
-import makeStyles from '@mui/styles/makeStyles';
-
-const useStyles = makeStyles({
-  title: {
-    fontSize: 14,
-  }, pos: {
-    fontSize: 14,
-  }
-});
 
 export default function JamiIdCard(props) {
-  const classes = useStyles()
   const account = props.account
   const registeredName = account.getRegisteredName()
   return <Card style={{marginBottom:16}}>
       <CardContent>
         <Box>
-        <Typography className={classes.title} color="textSecondary">
+        <Typography color="textSecondary">
           Jami ID
         </Typography>
           <Typography variant="h5" component="h2" gutterBottom noWrap>{account.getUri()}</Typography>
         </Box>
         {registeredName && <Box>
-          <Typography className={classes.title} color="textSecondary" >
+          <Typography color="textSecondary" >
           Jami username
         </Typography>
             <Typography variant="h5" component="h2" noWrap>{registeredName}</Typography>
