diff --git a/.yarn/patches/@sourcepoint-react-native-cmp-patch-34fca36663.patch b/.yarn/patches/@sourcepoint-react-native-cmp-patch-34fca36663.patch
new file mode 100644
index 0000000..28b1936
--- /dev/null
+++ b/.yarn/patches/@sourcepoint-react-native-cmp-patch-34fca36663.patch
@@ -0,0 +1,13 @@
+diff --git a/android/src/main/java/com/sourcepoint/reactnativecmp/RNSourcepointCmpTypes.kt b/android/src/main/java/com/sourcepoint/reactnativecmp/RNSourcepointCmpTypes.kt
+index bb8c6c37adc3d7980c7e92268b98b9d97ef8de40..3d67b3a3f44743c4542a1966e66e1af3ea93c555 100644
+--- a/android/src/main/java/com/sourcepoint/reactnativecmp/RNSourcepointCmpTypes.kt
++++ b/android/src/main/java/com/sourcepoint/reactnativecmp/RNSourcepointCmpTypes.kt
+@@ -16,7 +16,7 @@ data class SPCampaign(
+   val rawTargetingParam: ReadableMap?,
+   val supportLegacyUSPString: Boolean
+ ) {
+-  val targetingParams = rawTargetingParam?.toHashMap()?.map { TargetingParam(it.key, it.toString()) } ?: emptyList()
++  val targetingParams = rawTargetingParam?.toHashMap()?.map { TargetingParam(it.key, it.value.toString()) } ?: emptyList()
+ }
+ 
+ data class SPCampaigns(
diff --git a/package.json b/package.json
index 06acacc..19ebb73 100644
--- a/package.json
+++ b/package.json
@@ -92,7 +92,7 @@
   },
   "resolutions": {
     "@types/react": "^18.2.44",
-    "@sourcepoint/react-native-cmp@^0.3.0": "patch:@sourcepoint/react-native-cmp@npm%3A0.3.0#./.yarn/patches/@sourcepoint-react-native-cmp-npm-0.3.0-2434c31dc9.patch"
+    "@sourcepoint/react-native-cmp@^0.3.0": "patch:@sourcepoint/react-native-cmp@patch%3A@sourcepoint/react-native-cmp@npm%253A0.3.0%23./.yarn/patches/@sourcepoint-react-native-cmp-npm-0.3.0-2434c31dc9.patch%3A%3Aversion=0.3.0&hash=664e70&locator=react-native-contentpass%2540workspace%253A.#./.yarn/patches/@sourcepoint-react-native-cmp-patch-34fca36663.patch"
   },
   "peerDependencies": {
     "react": "*",
diff --git a/sharedExample/src/ContentpassUsage.tsx b/sharedExample/src/ContentpassUsage.tsx
index 5faaaaf..58aa930 100644
--- a/sharedExample/src/ContentpassUsage.tsx
+++ b/sharedExample/src/ContentpassUsage.tsx
@@ -1,7 +1,7 @@
 import { useContentpassSdk } from './ContentpassContext';
 import { Button, ScrollView, StyleSheet, Text, View } from 'react-native';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { AuthenticateResult } from 'react-native-contentpass';
+import { useEffect, useRef, useState } from 'react';
+import type { ContentpassState } from 'react-native-contentpass';
 import {
   SPConsentManager,
   type SPUserData,
@@ -13,6 +13,11 @@ const styles = StyleSheet.create({
     height: 400,
     flexGrow: 0,
   },
+  buttonsContainer: {
+    display: 'flex',
+    gap: 4,
+    marginTop: 10,
+  },
   logsView: {
     marginTop: 10,
   },
@@ -40,21 +45,13 @@ const setupSourcepoint = (hasValidSubscription: boolean) => {
 };
 
 export default function ContentpassUsage() {
-  const [authResult, setAuthResult] = useState<
-    AuthenticateResult | undefined
-  >();
+  const [authResult, setAuthResult] = useState<ContentpassState | undefined>();
   const contentpassSdk = useContentpassSdk();
   const spConsentManager = useRef<SPConsentManager | null>();
   const [sourcepointUserData, setSourcepointUserData] = useState<
     SPUserData | undefined
   >();
 
-  const authenticate = useCallback(async () => {
-    spConsentManager.current?.dispose();
-    const result = await contentpassSdk.authenticate();
-    setAuthResult(result);
-  }, [contentpassSdk]);
-
   useEffect(() => {
     spConsentManager.current = setupSourcepoint(
       authResult?.hasValidSubscription ?? false
@@ -66,7 +63,7 @@ export default function ContentpassUsage() {
 
     spConsentManager.current?.onAction((action) => {
       if (action.customActionId === "cp('login')") {
-        authenticate();
+        contentpassSdk.authenticate();
       }
     });
 
@@ -75,7 +72,18 @@ export default function ContentpassUsage() {
     return () => {
       spConsentManager.current?.dispose();
     };
-  }, [authResult, authenticate]);
+  }, [authResult, contentpassSdk]);
+
+  useEffect(() => {
+    const onContentpassStateChange = (state: ContentpassState) => {
+      setAuthResult(state);
+    };
+    contentpassSdk.registerObserver(onContentpassStateChange);
+
+    return () => {
+      contentpassSdk.unregisterObserver(onContentpassStateChange);
+    };
+  }, [contentpassSdk]);
 
   const clearSourcepointData = () => {
     spConsentManager.current?.clearLocalData();
@@ -85,7 +93,13 @@ export default function ContentpassUsage() {
 
   return (
     <>
-      <Button title={'Clear sourcepoint data'} onPress={clearSourcepointData} />
+      <View style={styles.buttonsContainer}>
+        <Button
+          title={'Clear sourcepoint data'}
+          onPress={clearSourcepointData}
+        />
+        <Button title={'Logout'} onPress={contentpassSdk.logout} />
+      </View>
       <View style={styles.logsView}>
         <Text>Authenticate result:</Text>
         <Text>{JSON.stringify(authResult, null, 2)}</Text>
diff --git a/sharedExample/src/contentpassConfig.ts b/sharedExample/src/contentpassConfig.ts
index 7347e66..5bae064 100644
--- a/sharedExample/src/contentpassConfig.ts
+++ b/sharedExample/src/contentpassConfig.ts
@@ -1,6 +1,6 @@
-import type { Config } from 'react-native-contentpass';
+import type { ContentpassConfig } from 'react-native-contentpass';
 
-export const contentpassConfig: Config = {
+export const contentpassConfig: ContentpassConfig = {
   propertyId: 'cc3fc4ad-cbe5-4d09-bf85-a49796603b19',
   redirectUrl: 'de.contentpass.demo://oauth',
   issuer: 'https://my.contentpass.dev',
diff --git a/src/OidcAuthStateStorage.ts b/src/OidcAuthStateStorage.ts
index c7c8300..74851d0 100644
--- a/src/OidcAuthStateStorage.ts
+++ b/src/OidcAuthStateStorage.ts
@@ -1,8 +1,15 @@
 import EncryptedStorage from 'react-native-encrypted-storage';
-import type { AuthorizeResult } from 'react-native-app-auth';
 
 const AUTH_STATE_KEY = 'OIDCAuthState';
 
+export type OidcAuthState = {
+  accessToken: string;
+  accessTokenExpirationDate: string;
+  idToken: string;
+  refreshToken: string | null;
+  tokenType: string;
+};
+
 export default class OidcAuthStateStorage {
   private readonly key;
 
@@ -10,11 +17,11 @@ export default class OidcAuthStateStorage {
     this.key = `de.contentpass.${clientId}-${AUTH_STATE_KEY}`;
   }
 
-  public async storeOidcAuthState(authState: AuthorizeResult) {
+  public async storeOidcAuthState(authState: OidcAuthState) {
     await EncryptedStorage.setItem(this.key, JSON.stringify(authState));
   }
 
-  public async getOidcAuthState() {
+  public async getOidcAuthState(): Promise<OidcAuthState | undefined> {
     const oidcAuthStateString = await EncryptedStorage.getItem(this.key);
 
     return oidcAuthStateString ? JSON.parse(oidcAuthStateString) : undefined;
diff --git a/src/oidcConsts.ts b/src/consts/oidcConsts.ts
similarity index 74%
rename from src/oidcConsts.ts
rename to src/consts/oidcConsts.ts
index 6adb528..21134ef 100644
--- a/src/oidcConsts.ts
+++ b/src/consts/oidcConsts.ts
@@ -1,2 +1,3 @@
 export const SCOPES = ['openid', 'offline_access', 'contentpass'];
 export const TOKEN_ENDPOINT = `/auth/oidc/token`;
+export const REFRESH_TOKEN_RETRIES = 6;
diff --git a/src/index.tsx b/src/index.tsx
index 512e36b..a7e388e 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -1,49 +1,51 @@
-import { authorize, type AuthorizeResult } from 'react-native-app-auth';
-import { SCOPES } from './oidcConsts';
-import OidcAuthStateStorage from './OidcAuthStateStorage';
-import parseContentpassToken from './utils/parseContentpassToken';
+import {
+  authorize,
+  type AuthorizeResult,
+  refresh,
+} from 'react-native-app-auth';
+import { REFRESH_TOKEN_RETRIES, SCOPES } from './consts/oidcConsts';
+import OidcAuthStateStorage, {
+  type OidcAuthState,
+} from './OidcAuthStateStorage';
 import fetchContentpassToken from './utils/fetchContentpassToken';
+import {
+  type ContentpassState,
+  ContentpassStateType,
+} from './types/ContentpassState';
+import type { ContentpassConfig } from './types/ContentpassConfig';
+import validateSubscription from './utils/validateSubscription';
+import { RefreshTokenStrategy } from './types/RefreshTokenStrategy';
 
-export type Config = {
-  propertyId: string;
-  redirectUrl: string;
-  issuer: string;
-};
-
-export enum State {
-  INITIALISING = 'INITIALISING',
-  UNAUTHENTICATED = 'UNAUTHENTICATED',
-  AUTHENTICATED = 'AUTHENTICATED',
-  ERROR = 'ERROR',
-}
-
-type ErrorAuthenticateResult = {
-  state: State.ERROR;
-  hasValidSubscription: false;
-  error: Error;
-};
+export type {
+  ContentpassState,
+  ErrorState,
+  AuthenticatedState,
+  InitialisingState,
+  UnauthenticatedState,
+} from './types/ContentpassState';
 
-type StandardAuthenticateResult = {
-  state: State;
-  hasValidSubscription: boolean;
-  error?: never;
-};
+export type { ContentpassConfig } from './types/ContentpassConfig';
 
-export type AuthenticateResult =
-  | StandardAuthenticateResult
-  | ErrorAuthenticateResult;
+export type ContentpassObserver = (state: ContentpassState) => void;
 
 export class Contentpass {
   private authStateStorage: OidcAuthStateStorage;
-  private readonly config: Config;
-  private state: State = State.INITIALISING;
+  private readonly config: ContentpassConfig;
+
+  private contentpassState: ContentpassState = {
+    state: ContentpassStateType.INITIALISING,
+  };
+  private contentpassStateObservers: ContentpassObserver[] = [];
+  private oidcAuthState: OidcAuthState | null = null;
+  private refreshTimer: NodeJS.Timeout | null = null;
 
-  constructor(config: Config) {
+  constructor(config: ContentpassConfig) {
     this.authStateStorage = new OidcAuthStateStorage(config.propertyId);
     this.config = config;
+    this.initialiseAuthState();
   }
 
-  public async authenticate(): Promise<AuthenticateResult> {
+  public authenticate = async (): Promise<void> => {
     let result: AuthorizeResult;
 
     try {
@@ -61,40 +63,161 @@ export class Contentpass {
     } catch (err: any) {
       // FIXME: logger for error
 
-      return {
-        state: State.ERROR,
-        hasValidSubscription: false,
+      this.changeContentpassState({
+        state: ContentpassStateType.ERROR,
         error: 'message' in err ? err.message : 'Unknown error',
-      };
+      });
+      return;
+    }
+
+    await this.onNewAuthState(result);
+  };
+
+  public registerObserver(observer: ContentpassObserver) {
+    if (this.contentpassStateObservers.includes(observer)) {
+      return;
+    }
+
+    observer(this.contentpassState);
+    this.contentpassStateObservers.push(observer);
+  }
+
+  public unregisterObserver(observer: ContentpassObserver) {
+    this.contentpassStateObservers = this.contentpassStateObservers.filter(
+      (o) => o !== observer
+    );
+  }
+
+  public logout = async () => {
+    await this.authStateStorage.clearOidcAuthState();
+    this.changeContentpassState({
+      state: ContentpassStateType.UNAUTHENTICATED,
+      hasValidSubscription: false,
+    });
+  };
+
+  public recoverFromError = async () => {
+    this.changeContentpassState({
+      state: ContentpassStateType.INITIALISING,
+    });
+
+    await this.initialiseAuthState();
+  };
+
+  private initialiseAuthState = async () => {
+    const authState = await this.authStateStorage.getOidcAuthState();
+    if (authState) {
+      await this.onNewAuthState(authState);
+      return;
     }
 
-    this.state = State.AUTHENTICATED;
-    await this.authStateStorage.storeOidcAuthState(result);
+    this.changeContentpassState({
+      state: ContentpassStateType.UNAUTHENTICATED,
+      hasValidSubscription: false,
+    });
+  };
+
+  private onNewAuthState = async (authState: OidcAuthState) => {
+    this.oidcAuthState = authState;
+    await this.authStateStorage.storeOidcAuthState(authState);
+
+    const strategy = this.setupRefreshTimer();
+    if (strategy !== RefreshTokenStrategy.TIMER_SET) {
+      return;
+    }
 
     try {
       const contentpassToken = await fetchContentpassToken({
         issuer: this.config.issuer,
         propertyId: this.config.propertyId,
-        idToken: result.idToken,
+        idToken: this.oidcAuthState.idToken,
       });
-      const hasValidSubscription = this.validateSubscription(contentpassToken);
-
-      return {
-        state: this.state,
+      const hasValidSubscription = validateSubscription(contentpassToken);
+      this.changeContentpassState({
+        state: ContentpassStateType.AUTHENTICATED,
         hasValidSubscription,
-      };
+      });
+    } catch (err: any) {
+      this.changeContentpassState({
+        state: ContentpassStateType.ERROR,
+        error: err.message || 'Unknown error',
+      });
+    }
+  };
+
+  private setupRefreshTimer = (): RefreshTokenStrategy => {
+    const accessTokenExpirationDate =
+      this.oidcAuthState?.accessTokenExpirationDate;
+
+    if (!accessTokenExpirationDate) {
+      return RefreshTokenStrategy.NO_REFRESH;
+    }
+
+    const now = new Date();
+    const expirationDate = new Date(accessTokenExpirationDate);
+    const timeDiff = expirationDate.getTime() - now.getTime();
+    if (timeDiff <= 0) {
+      this.refreshToken(0);
+      return RefreshTokenStrategy.INSTANTLY;
+    }
+
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+
+    this.refreshTimer = setTimeout(async () => {
+      await this.refreshToken(0);
+    }, timeDiff);
+
+    return RefreshTokenStrategy.TIMER_SET;
+  };
+
+  private refreshToken = async (counter: number) => {
+    if (!this.oidcAuthState?.refreshToken) {
+      return;
+    }
+
+    try {
+      const refreshResult = await refresh(
+        {
+          clientId: this.config.propertyId,
+          redirectUrl: this.config.redirectUrl,
+          issuer: this.config.issuer,
+          scopes: SCOPES,
+        },
+        {
+          refreshToken: this.oidcAuthState.refreshToken,
+        }
+      );
+      await this.onNewAuthState(refreshResult);
     } catch (err) {
-      // FIXME: logger for error
-      return {
-        state: this.state,
-        hasValidSubscription: false,
-      };
+      await this.onRefreshTokenError(counter, err);
     }
-  }
+  };
 
-  private validateSubscription(contentpassToken: string) {
-    const { body } = parseContentpassToken(contentpassToken);
+  // @ts-expect-error remove when err starts being used
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private onRefreshTokenError = async (counter: number, err: unknown) => {
+    // FIXME: logger for error
+    // FIXME: add handling for specific error to not retry in every case
+    if (counter <= REFRESH_TOKEN_RETRIES) {
+      const delay = counter * 1000 * 10;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      await this.refreshToken(counter + 1);
+      return;
+    }
 
-    return !!body.auth && !!body.plans.length;
-  }
+    this.changeContentpassState({
+      state: ContentpassStateType.UNAUTHENTICATED,
+      hasValidSubscription: false,
+    });
+    await this.authStateStorage.clearOidcAuthState();
+  };
+
+  private changeContentpassState = (state: ContentpassState) => {
+    this.contentpassState = state;
+    this.contentpassStateObservers.forEach((observer) => observer(state));
+
+    return this.contentpassState;
+  };
 }
diff --git a/src/types/ContentpassConfig.ts b/src/types/ContentpassConfig.ts
new file mode 100644
index 0000000..e76b326
--- /dev/null
+++ b/src/types/ContentpassConfig.ts
@@ -0,0 +1,5 @@
+export type ContentpassConfig = {
+  propertyId: string;
+  redirectUrl: string;
+  issuer: string;
+};
diff --git a/src/types/ContentpassState.ts b/src/types/ContentpassState.ts
new file mode 100644
index 0000000..34f0d84
--- /dev/null
+++ b/src/types/ContentpassState.ts
@@ -0,0 +1,36 @@
+export enum ContentpassStateType {
+  INITIALISING = 'INITIALISING',
+  UNAUTHENTICATED = 'UNAUTHENTICATED',
+  AUTHENTICATED = 'AUTHENTICATED',
+  ERROR = 'ERROR',
+}
+
+export type InitialisingState = {
+  state: ContentpassStateType.INITIALISING;
+  hasValidSubscription?: never;
+  error?: never;
+};
+
+export type UnauthenticatedState = {
+  state: ContentpassStateType.UNAUTHENTICATED;
+  hasValidSubscription: false;
+  error?: never;
+};
+
+export type AuthenticatedState = {
+  state: ContentpassStateType.AUTHENTICATED;
+  hasValidSubscription: boolean;
+  error?: never;
+};
+
+export type ErrorState = {
+  state: ContentpassStateType.ERROR;
+  hasValidSubscription?: never;
+  error: string;
+};
+
+export type ContentpassState =
+  | InitialisingState
+  | UnauthenticatedState
+  | AuthenticatedState
+  | ErrorState;
diff --git a/src/types/RefreshTokenStrategy.ts b/src/types/RefreshTokenStrategy.ts
new file mode 100644
index 0000000..6fe1923
--- /dev/null
+++ b/src/types/RefreshTokenStrategy.ts
@@ -0,0 +1,5 @@
+export enum RefreshTokenStrategy {
+  INSTANTLY = 'INSTANTLY',
+  TIMER_SET = 'TIMER_SET',
+  NO_REFRESH = 'NO_REFRESH',
+}
diff --git a/src/utils/fetchContentpassToken.ts b/src/utils/fetchContentpassToken.ts
index 34b72e0..1bc23ba 100644
--- a/src/utils/fetchContentpassToken.ts
+++ b/src/utils/fetchContentpassToken.ts
@@ -1,4 +1,4 @@
-import { TOKEN_ENDPOINT } from '../oidcConsts';
+import { TOKEN_ENDPOINT } from '../consts/oidcConsts';
 
 export default async function fetchContentpassToken({
   idToken,
diff --git a/src/utils/validateSubscription.ts b/src/utils/validateSubscription.ts
new file mode 100644
index 0000000..6be5035
--- /dev/null
+++ b/src/utils/validateSubscription.ts
@@ -0,0 +1,7 @@
+import parseContentpassToken from './parseContentpassToken';
+
+export default function validateSubscription(contentpassToken: string) {
+  const { body } = parseContentpassToken(contentpassToken);
+
+  return !!body.auth && !!body.plans.length;
+}