diff --git a/lib/hooks/qr-auth.js b/lib/hooks/qr-auth.js
index 9e647d859..ba3d9ea0a 100644
--- a/lib/hooks/qr-auth.js
+++ b/lib/hooks/qr-auth.js
@@ -1,176 +1,177 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 
 import { IdentityClientContext } from '../shared/identity-client-context.js';
 import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
 import type { BackupKeys } from '../types/backup-types.js';
 import {
   tunnelbrokerMessageTypes,
   type TunnelbrokerMessage,
 } from '../types/tunnelbroker/messages.js';
 import {
   peerToPeerMessageTypes,
   peerToPeerMessageValidator,
   type QRCodeAuthMessage,
 } from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import {
   qrCodeAuthMessageTypes,
   type QRCodeAuthMessagePayload,
 } from '../types/tunnelbroker/qr-code-auth-message-types.js';
 
 type QRAuthHandlerInput = {
   +secondaryDeviceID: ?string,
   +aesKey: ?string,
   +performSecondaryDeviceRegistration: (userID: string) => Promise<void>,
   +composeMessage: (
     encryptionKey: string,
     payload: QRCodeAuthMessagePayload,
   ) => Promise<QRCodeAuthMessage>,
   +processMessage: (
     encryptionKey: string,
     message: QRCodeAuthMessage,
   ) => Promise<?QRCodeAuthMessagePayload>,
   +performBackupRestore?: (backupKeys: BackupKeys) => Promise<void>,
 };
 
 function useQRAuth(input: QRAuthHandlerInput) {
   const {
     secondaryDeviceID,
     aesKey,
     processMessage,
     composeMessage,
     performSecondaryDeviceRegistration,
     performBackupRestore,
   } = input;
   const [primaryDeviceID, setPrimaryDeviceID] = React.useState<?string>();
   const {
     setUnauthorizedDeviceID,
     addListener,
     removeListener,
     connected: tunnelbrokerConnected,
     isAuthorized,
     sendMessage,
   } = useTunnelbroker();
 
   const identityContext = React.useContext(IdentityClientContext);
   const identityClient = identityContext?.identityClient;
 
   React.useEffect(() => {
     if (
       !secondaryDeviceID ||
       !aesKey ||
       !tunnelbrokerConnected ||
       !isAuthorized ||
       !primaryDeviceID
     ) {
       return;
     }
 
     void (async () => {
       const message = await composeMessage(aesKey, {
         type: qrCodeAuthMessageTypes.SECONDARY_DEVICE_REGISTRATION_SUCCESS,
+        requestBackupKeys: true,
       });
       await sendMessage({
         deviceID: primaryDeviceID,
         payload: JSON.stringify(message),
       });
     })();
   }, [
     tunnelbrokerConnected,
     isAuthorized,
     sendMessage,
     primaryDeviceID,
     aesKey,
     secondaryDeviceID,
     composeMessage,
   ]);
 
   const tunnelbrokerMessageListener = React.useCallback(
     async (message: TunnelbrokerMessage) => {
       invariant(identityClient, 'identity context not set');
       if (
         !aesKey ||
         message.type !== tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE
       ) {
         return;
       }
 
       let innerMessage;
       try {
         innerMessage = JSON.parse(message.payload);
       } catch {
         return;
       }
       if (
         !peerToPeerMessageValidator.is(innerMessage) ||
         innerMessage.type !== peerToPeerMessageTypes.QR_CODE_AUTH_MESSAGE
       ) {
         return;
       }
 
       let qrCodeAuthMessage;
       try {
         qrCodeAuthMessage = await processMessage(aesKey, innerMessage);
       } catch (err) {
         console.warn('Failed to decrypt Tunnelbroker QR auth message:', err);
         return;
       }
 
       if (
         qrCodeAuthMessage &&
         qrCodeAuthMessage.type ===
           qrCodeAuthMessageTypes.BACKUP_DATA_KEY_MESSAGE
       ) {
         const { backupID, backupDataKey, backupLogDataKey } = qrCodeAuthMessage;
         void performBackupRestore?.({
           backupID,
           backupDataKey,
           backupLogDataKey,
         });
         return;
       }
 
       if (
         !qrCodeAuthMessage ||
         qrCodeAuthMessage.type !==
           qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS
       ) {
         return;
       }
       const { primaryDeviceID: receivedPrimaryDeviceID, userID } =
         qrCodeAuthMessage;
       setPrimaryDeviceID(receivedPrimaryDeviceID);
 
       await performSecondaryDeviceRegistration(userID);
       setUnauthorizedDeviceID(null);
     },
     [
       setUnauthorizedDeviceID,
       identityClient,
       aesKey,
       performSecondaryDeviceRegistration,
       performBackupRestore,
       processMessage,
     ],
   );
 
   React.useEffect(() => {
     if (!secondaryDeviceID) {
       return undefined;
     }
 
     addListener(tunnelbrokerMessageListener);
     return () => {
       removeListener(tunnelbrokerMessageListener);
     };
   }, [
     secondaryDeviceID,
     addListener,
     removeListener,
     tunnelbrokerMessageListener,
   ]);
 }
 
 export { useQRAuth };
diff --git a/lib/types/tunnelbroker/qr-code-auth-message-types.js b/lib/types/tunnelbroker/qr-code-auth-message-types.js
index d141d1d60..78ca6bb32 100644
--- a/lib/types/tunnelbroker/qr-code-auth-message-types.js
+++ b/lib/types/tunnelbroker/qr-code-auth-message-types.js
@@ -1,58 +1,60 @@
 // @flow
 
 import type { TInterface, TUnion } from 'tcomb';
 import t from 'tcomb';
 
 import { tShape, tString, tUserID } from '../../utils/validation-utils.js';
 
 export const qrCodeAuthMessageTypes = Object.freeze({
   DEVICE_LIST_UPDATE_SUCCESS: 'DeviceListUpdateSuccess',
   SECONDARY_DEVICE_REGISTRATION_SUCCESS: 'SecondaryDeviceRegistrationSuccess',
   BACKUP_DATA_KEY_MESSAGE: 'BackupDataKeyMessage',
 });
 
 export type DeviceListUpdateSuccess = {
   +type: 'DeviceListUpdateSuccess',
   +userID: string,
   +primaryDeviceID: string,
 };
 export const deviceListUpdateSuccessValidator: TInterface<DeviceListUpdateSuccess> =
   tShape<DeviceListUpdateSuccess>({
     type: tString(qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS),
     userID: tUserID,
     primaryDeviceID: t.String,
   });
 
 export type SecondaryDeviceRegistrationSuccess = {
   +type: 'SecondaryDeviceRegistrationSuccess',
+  +requestBackupKeys: boolean,
 };
 export const secondaryDeviceRegistrationSuccessValidator: TInterface<SecondaryDeviceRegistrationSuccess> =
   tShape<SecondaryDeviceRegistrationSuccess>({
     type: tString(qrCodeAuthMessageTypes.SECONDARY_DEVICE_REGISTRATION_SUCCESS),
+    requestBackupKeys: t.Boolean,
   });
 
 export type BackupDataKeyMessage = {
   +type: 'BackupDataKeyMessage',
   +backupID: string,
   +backupDataKey: string,
   +backupLogDataKey: string,
 };
 export const backupDataKeyMessageValidator: TInterface<BackupDataKeyMessage> =
   tShape<BackupDataKeyMessage>({
     type: tString(qrCodeAuthMessageTypes.BACKUP_DATA_KEY_MESSAGE),
     backupID: t.String,
     backupDataKey: t.String,
     backupLogDataKey: t.String,
   });
 
 export type QRCodeAuthMessagePayload =
   | DeviceListUpdateSuccess
   | SecondaryDeviceRegistrationSuccess
   | BackupDataKeyMessage;
 
 export const qrCodeAuthMessagePayloadValidator: TUnion<QRCodeAuthMessagePayload> =
   t.union([
     deviceListUpdateSuccessValidator,
     secondaryDeviceRegistrationSuccessValidator,
     backupDataKeyMessageValidator,
   ]);
diff --git a/native/profile/secondary-device-qr-code-scanner.react.js b/native/profile/secondary-device-qr-code-scanner.react.js
index ae8c3656f..4102d63c4 100644
--- a/native/profile/secondary-device-qr-code-scanner.react.js
+++ b/native/profile/secondary-device-qr-code-scanner.react.js
@@ -1,287 +1,294 @@
 // @flow
 
 import { useNavigation } from '@react-navigation/native';
 import { BarCodeScanner, type BarCodeEvent } from 'expo-barcode-scanner';
 import invariant from 'invariant';
 import * as React from 'react';
 import { View } from 'react-native';
 
 import { parseDataFromDeepLink } from 'lib/facts/links.js';
 import { useBroadcastDeviceListUpdates } from 'lib/hooks/peer-list-hooks.js';
 import { addDeviceToDeviceList } from 'lib/shared/device-list-utils.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import { useTunnelbroker } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import {
   backupKeysValidator,
   type BackupKeys,
 } from 'lib/types/backup-types.js';
 import {
   tunnelbrokerMessageTypes,
   type TunnelbrokerMessage,
 } from 'lib/types/tunnelbroker/messages.js';
 import {
   peerToPeerMessageTypes,
   peerToPeerMessageValidator,
   type PeerToPeerMessage,
 } from 'lib/types/tunnelbroker/peer-to-peer-message-types.js';
 import { qrCodeAuthMessageTypes } from 'lib/types/tunnelbroker/qr-code-auth-message-types.js';
 import { rawDeviceListFromSignedList } from 'lib/utils/device-list-utils.js';
 import { assertWithValidator } from 'lib/utils/validation-utils.js';
 
 import type { ProfileNavigationProp } from './profile.react.js';
 import { getBackupSecret } from '../backup/use-client-backup.js';
 import { commCoreModule } from '../native-modules.js';
 import type { NavigationRoute } from '../navigation/route-names.js';
 import {
   composeTunnelbrokerQRAuthMessage,
   parseTunnelbrokerQRAuthMessage,
 } from '../qr-code/qr-code-utils.js';
 import { useStyles } from '../themes/colors.js';
 import Alert from '../utils/alert.js';
 
 const barCodeTypes = [BarCodeScanner.Constants.BarCodeType.qr];
 
 type Props = {
   +navigation: ProfileNavigationProp<'SecondaryDeviceQRCodeScanner'>,
   +route: NavigationRoute<'SecondaryDeviceQRCodeScanner'>,
 };
 // eslint-disable-next-line no-unused-vars
 function SecondaryDeviceQRCodeScanner(props: Props): React.Node {
   const [hasPermission, setHasPermission] = React.useState<?boolean>(null);
   const [scanned, setScanned] = React.useState(false);
 
   const styles = useStyles(unboundStyles);
   const navigation = useNavigation();
 
   const tunnelbrokerContext = useTunnelbroker();
   const identityContext = React.useContext(IdentityClientContext);
   invariant(identityContext, 'identity context not set');
 
   const aes256Key = React.useRef<?string>(null);
   const secondaryDeviceID = React.useRef<?string>(null);
 
   const broadcastDeviceListUpdates = useBroadcastDeviceListUpdates();
 
   const tunnelbrokerMessageListener = React.useCallback(
     async (message: TunnelbrokerMessage) => {
       const encryptionKey = aes256Key.current;
       const targetDeviceID = secondaryDeviceID.current;
       if (!encryptionKey || !targetDeviceID) {
         return;
       }
       if (message.type !== tunnelbrokerMessageTypes.MESSAGE_TO_DEVICE) {
         return;
       }
 
       let innerMessage: PeerToPeerMessage;
       try {
         innerMessage = JSON.parse(message.payload);
       } catch {
         return;
       }
       if (
         !peerToPeerMessageValidator.is(innerMessage) ||
         innerMessage.type !== peerToPeerMessageTypes.QR_CODE_AUTH_MESSAGE
       ) {
         return;
       }
 
       const payload = await parseTunnelbrokerQRAuthMessage(
         encryptionKey,
         innerMessage,
       );
       if (
-        payload?.type !==
-        qrCodeAuthMessageTypes.SECONDARY_DEVICE_REGISTRATION_SUCCESS
+        !payload ||
+        payload.type !==
+          qrCodeAuthMessageTypes.SECONDARY_DEVICE_REGISTRATION_SUCCESS
       ) {
         return;
       }
 
       invariant(identityContext, 'identity context not set');
       const { getAuthMetadata, identityClient } = identityContext;
       const { userID } = await getAuthMetadata();
       if (!userID) {
         throw new Error('missing auth metadata');
       }
 
       const deviceLists =
         await identityClient.getDeviceListHistoryForUser(userID);
       invariant(deviceLists.length > 0, 'received empty device list history');
 
       const lastSignedDeviceList = deviceLists[deviceLists.length - 1];
       const deviceList = rawDeviceListFromSignedList(lastSignedDeviceList);
 
       await broadcastDeviceListUpdates(
         deviceList.devices,
         lastSignedDeviceList,
       );
 
+      if (!payload.requestBackupKeys) {
+        Alert.alert('Device added', 'Device registered successfully', [
+          { text: 'OK' },
+        ]);
+      }
+
       const backupSecret = await getBackupSecret();
       const backupKeysResponse =
         await commCoreModule.retrieveBackupKeys(backupSecret);
       const backupKeys = assertWithValidator<BackupKeys>(
         JSON.parse(backupKeysResponse),
         backupKeysValidator,
       );
 
       const backupKeyMessage = await composeTunnelbrokerQRAuthMessage(
         encryptionKey,
         {
           type: qrCodeAuthMessageTypes.BACKUP_DATA_KEY_MESSAGE,
           ...backupKeys,
         },
       );
       await tunnelbrokerContext.sendMessage({
         deviceID: targetDeviceID,
         payload: JSON.stringify(backupKeyMessage),
       });
 
       Alert.alert('Device added', 'Device registered successfully', [
         { text: 'OK' },
       ]);
     },
     [identityContext, broadcastDeviceListUpdates, tunnelbrokerContext],
   );
 
   React.useEffect(() => {
     tunnelbrokerContext.addListener(tunnelbrokerMessageListener);
 
     return () => {
       tunnelbrokerContext.removeListener(tunnelbrokerMessageListener);
     };
   }, [tunnelbrokerMessageListener, tunnelbrokerContext]);
 
   React.useEffect(() => {
     void (async () => {
       const { status } = await BarCodeScanner.requestPermissionsAsync();
       setHasPermission(status === 'granted');
 
       if (status !== 'granted') {
         Alert.alert(
           'No access to camera',
           'Please allow Comm to access your camera in order to scan the QR code.',
           [{ text: 'OK' }],
         );
 
         navigation.goBack();
       }
     })();
   }, [navigation]);
 
   const onConnect = React.useCallback(
     async (barCodeEvent: BarCodeEvent) => {
       const { data } = barCodeEvent;
       const parsedData = parseDataFromDeepLink(data);
       const keysMatch = parsedData?.data?.keys;
 
       if (!parsedData || !keysMatch) {
         Alert.alert(
           'Scan failed',
           'QR code does not contain a valid pair of keys.',
           [{ text: 'OK' }],
         );
         return;
       }
 
       const keys = JSON.parse(decodeURIComponent(keysMatch));
       const { aes256, ed25519 } = keys;
       aes256Key.current = aes256;
       secondaryDeviceID.current = ed25519;
 
       try {
         const { deviceID: primaryDeviceID, userID } =
           await identityContext.getAuthMetadata();
         if (!primaryDeviceID || !userID) {
           throw new Error('missing auth metadata');
         }
         await addDeviceToDeviceList(
           identityContext.identityClient,
           userID,
           ed25519,
         );
         const message = await composeTunnelbrokerQRAuthMessage(aes256, {
           type: qrCodeAuthMessageTypes.DEVICE_LIST_UPDATE_SUCCESS,
           userID,
           primaryDeviceID,
         });
         await tunnelbrokerContext.sendMessage({
           deviceID: ed25519,
           payload: JSON.stringify(message),
         });
       } catch (err) {
         console.log('Primary device error:', err);
         Alert.alert(
           'Adding device failed',
           'Failed to update the device list',
           [{ text: 'OK' }],
         );
         navigation.goBack();
       }
     },
     [tunnelbrokerContext, identityContext, navigation],
   );
 
   const onCancelScan = React.useCallback(() => setScanned(false), []);
 
   const handleBarCodeScanned = React.useCallback(
     (barCodeEvent: BarCodeEvent) => {
       setScanned(true);
       Alert.alert(
         'Connect with this device?',
         'Are you sure you want to allow this device to log in to your account?',
         [
           {
             text: 'Cancel',
             style: 'cancel',
             onPress: onCancelScan,
           },
           {
             text: 'Connect',
             onPress: () => onConnect(barCodeEvent),
           },
         ],
         { cancelable: false },
       );
     },
     [onCancelScan, onConnect],
   );
 
   if (hasPermission === null) {
     return <View />;
   }
 
   // Note: According to the BarCodeScanner Expo docs, we should adhere to two
   // guidances when using the BarCodeScanner:
   // 1. We should specify the potential barCodeTypes we want to scan for to
   //    minimize battery usage.
   // 2. We should set the onBarCodeScanned callback to undefined if it scanned
   //    in order to 'pause' the scanner from continuing to scan while we
   //    process the data from the scan.
   // See: https://docs.expo.io/versions/latest/sdk/bar-code-scanner
   return (
     <View style={styles.container}>
       <BarCodeScanner
         onBarCodeScanned={scanned ? undefined : handleBarCodeScanned}
         barCodeTypes={barCodeTypes}
         style={styles.scanner}
       />
     </View>
   );
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
     flexDirection: 'column',
     justifyContent: 'center',
   },
   scanner: {
     position: 'absolute',
     top: 0,
     left: 0,
     right: 0,
     bottom: 0,
   },
 };
 
 export default SecondaryDeviceQRCodeScanner;