diff --git a/packages/apps/human-app/frontend/src/api/api-client.ts b/packages/apps/human-app/frontend/src/api/api-client.ts
deleted file mode 100644
index 59d6dd5fe2..0000000000
--- a/packages/apps/human-app/frontend/src/api/api-client.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { createFetcher } from '@/api/fetcher';
-import { env } from '@/shared/env';
-
-export const apiClient = createFetcher({
-  baseUrl: env.VITE_API_URL,
-  options: () => {
-    const headers = new Headers({ 'Content-Type': 'application/json' });
-
-    return {
-      headers,
-    };
-  },
-});
diff --git a/packages/apps/human-app/frontend/src/api/api-paths.ts b/packages/apps/human-app/frontend/src/api/api-paths.ts
deleted file mode 100644
index 87596f3a44..0000000000
--- a/packages/apps/human-app/frontend/src/api/api-paths.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-export const apiPaths = {
-  test: {
-    path: '/test',
-  },
-  worker: {
-    signIn: {
-      path: '/auth/signin',
-    },
-    signUp: {
-      path: '/auth/signup',
-    },
-    obtainAccessToken: {
-      path: '/auth/refresh',
-    },
-    sendResetLink: {
-      path: '/password-reset/forgot-password',
-    },
-    resetPassword: {
-      path: '/password-reset/restore-password',
-    },
-    verifyEmail: {
-      path: '/email-confirmation/email-verification',
-      withAuthRetry: true,
-    },
-    resendEmailVerification: {
-      path: '/email-confirmation/resend-email-verification',
-      withAuthRetry: true,
-    },
-    kycStart: {
-      path: '/kyc/start',
-      withAuthRetry: true,
-    },
-    oracles: {
-      path: '/oracles',
-    },
-    jobs: {
-      path: '/jobs',
-    },
-    myJobs: {
-      path: '/assignment/job',
-    },
-    assignJob: {
-      path: '/assignment/job',
-    },
-    resignJob: {
-      path: '/assignment/resign-job',
-    },
-    refreshJob: {
-      path: '/assignment/refresh',
-    },
-    registerAddress: {
-      path: '/user/register-address',
-      withAuthRetry: true,
-    },
-    signedAddress: {
-      path: '/kyc/on-chain',
-      withAuthRetry: true,
-    },
-    enableHCaptchaLabeling: {
-      path: '/labeling/h-captcha/enable',
-    },
-    verifyHCaptchaLabeling: {
-      path: '/labeling/h-captcha/verify',
-    },
-    hCaptchaUserStats: {
-      path: '/labeling/h-captcha/user-stats',
-    },
-    dailyHmtSpend: {
-      path: '/labeling/h-captcha/daily-hmt-spent',
-    },
-    registrationInExchangeOracle: {
-      path: '/exchange-oracle-registration',
-    },
-    uiConfig: {
-      path: '/ui-config',
-    },
-  },
-  operator: {
-    web3Auth: {
-      prepareSignature: {
-        path: '/prepare-signature',
-      },
-      signUp: {
-        path: '/auth/web3/signup',
-      },
-      signIn: {
-        path: '/auth/web3/signin',
-      },
-      stats: {
-        path: '/stats',
-      },
-    },
-    disableOperator: {
-      path: '/disable-operator',
-      withAuthRetry: true,
-    },
-    enableOperator: {
-      path: '/enable-operator',
-      withAuthRetry: true,
-    },
-  },
-} as const;
diff --git a/packages/apps/human-app/frontend/src/api/auth-service.ts b/packages/apps/human-app/frontend/src/api/auth-service.ts
new file mode 100644
index 0000000000..cbca5247f3
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/api/auth-service.ts
@@ -0,0 +1,117 @@
+import { jwtDecode } from 'jwt-decode';
+import { type SignInDto } from '@/modules/signin/worker/schemas';
+import { browserAuthProvider } from '@/shared/contexts/browser-auth-provider';
+import {
+  type AuthTokensSuccessResponse,
+  authTokensSuccessResponseSchema,
+} from '@/shared/schemas';
+import { type BrowserAuthProvider } from '@/shared/types/browser-auth-provider';
+import { type HttpApiClient } from './http-api-client';
+import { commonApiPaths } from './common-api-paths';
+
+export interface AuthProvider {
+  getAccessToken: () => Promise<string | null>;
+  refreshAccessToken: () => Promise<void>;
+}
+
+const apiPaths = {
+  worker: {
+    signIn: {
+      path: '/auth/signin',
+    },
+  },
+} as const;
+
+export class AuthService implements AuthProvider {
+  private readonly browserAuthProvider: BrowserAuthProvider =
+    browserAuthProvider;
+
+  private static refreshPromise: Promise<AuthTokensSuccessResponse | null> | null =
+    null;
+
+  constructor(private readonly httpClient: HttpApiClient) {}
+
+  async signIn(data: SignInDto): Promise<void> {
+    const res = await this.httpClient.post<AuthTokensSuccessResponse>(
+      apiPaths.worker.signIn.path,
+      {
+        successSchema: authTokensSuccessResponseSchema,
+        body: data,
+      }
+    );
+
+    this.browserAuthProvider.signIn(res, 'web2');
+  }
+
+  async getAccessToken(): Promise<string | null> {
+    const accessToken = this.browserAuthProvider.getAccessToken();
+
+    if (!accessToken) {
+      return null;
+    }
+
+    const decodedToken = jwtDecode<{ exp: number }>(accessToken);
+    const currentTime = Math.floor(Date.now() / 1000);
+    const tokenExpiration = decodedToken.exp;
+
+    if (tokenExpiration && tokenExpiration - currentTime < 30) {
+      await this.refreshAccessToken();
+
+      const newAccessToken = this.browserAuthProvider.getAccessToken();
+
+      if (!newAccessToken) {
+        return null;
+      }
+
+      return newAccessToken;
+    }
+
+    return accessToken;
+  }
+
+  async refreshAccessToken(): Promise<void> {
+    const authType = this.browserAuthProvider.getAuthType();
+
+    if (!authType) {
+      throw new Error('Auth type not found');
+    }
+
+    if (!AuthService.refreshPromise) {
+      AuthService.refreshPromise = this.fetchTokenRefresh();
+    }
+
+    const tokens = await AuthService.refreshPromise;
+
+    AuthService.refreshPromise = null;
+
+    if (tokens === null) {
+      throw new Error('Failed to refresh access token');
+    }
+
+    browserAuthProvider.signIn(tokens, authType);
+  }
+
+  private async fetchTokenRefresh(): Promise<AuthTokensSuccessResponse | null> {
+    const refreshToken = this.browserAuthProvider.getRefreshToken();
+
+    if (!refreshToken) {
+      return null;
+    }
+
+    try {
+      const response = await this.httpClient.post<AuthTokensSuccessResponse>(
+        commonApiPaths.auth.refresh.path,
+        {
+          body: {
+            // eslint-disable-next-line camelcase
+            refresh_token: refreshToken,
+          },
+        }
+      );
+
+      return response;
+    } catch (error) {
+      return null;
+    }
+  }
+}
diff --git a/packages/apps/human-app/frontend/src/api/authorized-http-api-client.ts b/packages/apps/human-app/frontend/src/api/authorized-http-api-client.ts
new file mode 100644
index 0000000000..92a427d161
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/api/authorized-http-api-client.ts
@@ -0,0 +1,41 @@
+import { env } from '@/shared/env';
+import {
+  HttpApiClient,
+  humanAppApiClient,
+  type RequestConfig,
+} from './http-api-client';
+import { AuthService, type AuthProvider } from './auth-service';
+
+export class AuthorizedHttpApiClient extends HttpApiClient {
+  constructor(
+    baseUrl: string,
+    private readonly authProvider: AuthProvider
+  ) {
+    super(baseUrl);
+  }
+
+  protected async makeRequest<T = unknown>(
+    method: string,
+    path: string,
+    config: RequestConfig
+  ): Promise<T> {
+    const token = await this.authProvider.getAccessToken();
+
+    const _config = {
+      ...config,
+      headers: {
+        ...config.headers,
+        Authorization: `Bearer ${token}`,
+      },
+    };
+
+    return super.makeRequest(method, path, _config);
+  }
+}
+
+export const authService = new AuthService(humanAppApiClient);
+
+export const authorizedHumanAppApiClient = new AuthorizedHttpApiClient(
+  env.VITE_API_URL,
+  authService
+);
diff --git a/packages/apps/human-app/frontend/src/api/common-api-paths.ts b/packages/apps/human-app/frontend/src/api/common-api-paths.ts
new file mode 100644
index 0000000000..ed28ab1e4b
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/api/common-api-paths.ts
@@ -0,0 +1,7 @@
+export const commonApiPaths = {
+  auth: {
+    refresh: {
+      path: '/auth/refresh',
+    },
+  },
+} as const;
diff --git a/packages/apps/human-app/frontend/src/api/fetch-refresh-token.ts b/packages/apps/human-app/frontend/src/api/fetch-refresh-token.ts
deleted file mode 100644
index 2f99243801..0000000000
--- a/packages/apps/human-app/frontend/src/api/fetch-refresh-token.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { apiPaths } from '@/api/api-paths';
-import { browserAuthProvider } from '@/shared/contexts/browser-auth-provider';
-import { authTokensSuccessResponseSchema } from '@/shared/schemas';
-
-export const fetchTokenRefresh = async (baseUrl: string) => {
-  const response = await fetch(
-    `${baseUrl}${apiPaths.worker.obtainAccessToken.path}`,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        // eslint-disable-next-line camelcase -- camel case defined by api
-        refresh_token: browserAuthProvider.getRefreshToken(),
-      }),
-    }
-  );
-
-  if (!response.ok) {
-    return null;
-  }
-
-  const data: unknown = await response.json();
-
-  const refetchAccessTokenSuccess = authTokensSuccessResponseSchema.parse(data);
-
-  return refetchAccessTokenSuccess;
-};
diff --git a/packages/apps/human-app/frontend/src/api/fetcher.ts b/packages/apps/human-app/frontend/src/api/fetcher.ts
deleted file mode 100644
index 275a9932e3..0000000000
--- a/packages/apps/human-app/frontend/src/api/fetcher.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-import merge from 'lodash/merge';
-import { ZodError, type ZodType, type ZodTypeDef } from 'zod';
-import type { ResponseError } from '@/shared/types/global.type';
-import { browserAuthProvider } from '@/shared/contexts/browser-auth-provider';
-import { env } from '@/shared/env';
-import { normalizeBaseUrl } from '@/shared/helpers/url';
-import { type AuthTokensSuccessResponse } from '@/shared/schemas';
-import { fetchTokenRefresh } from './fetch-refresh-token';
-
-const appendHeader = (
-  fetcherOptionsWithDefaults: RequestInit | undefined,
-  newHeaders: Record<string, string>
-) => {
-  const headers = new Headers(fetcherOptionsWithDefaults?.headers);
-
-  for (const [key, value] of Object.entries(newHeaders)) {
-    headers.set(key, value);
-  }
-
-  return {
-    ...fetcherOptionsWithDefaults,
-    headers,
-  };
-};
-
-export class FetchError extends Error {
-  status: number;
-  data: unknown;
-
-  constructor({
-    message,
-    data,
-    status,
-  }: {
-    message: string;
-    status: number;
-    data: unknown;
-  }) {
-    super(message);
-    this.status = status;
-    this.data = data;
-  }
-}
-
-export type FetcherOptionsWithValidation<SuccessInput, SuccessOutput> =
-  Readonly<{
-    options?: RequestInit;
-    successSchema: ZodType<SuccessOutput, ZodTypeDef, SuccessInput>;
-    skipValidation?: false | undefined;
-    authenticated?: boolean;
-    withAuthRetry?: boolean;
-    baseUrl?: string;
-  }>;
-
-export type FetcherOptionsWithoutValidation = Readonly<{
-  options?: RequestInit;
-  skipValidation: true;
-  authenticated?: boolean;
-  withAuthRetry?: boolean;
-  baseUrl?: string;
-}>;
-
-export type FetcherOptions<SuccessInput, SuccessOutput> =
-  | FetcherOptionsWithValidation<SuccessInput, SuccessOutput>
-  | FetcherOptionsWithoutValidation;
-
-export type FetcherUrl = string | URL;
-
-let refreshPromise: Promise<AuthTokensSuccessResponse | null> | null = null;
-
-export async function refreshToken(): Promise<{
-  access_token: string;
-  refresh_token: string;
-} | null> {
-  if (!refreshPromise) {
-    refreshPromise = fetchTokenRefresh(normalizeBaseUrl(env.VITE_API_URL));
-  }
-
-  const result = await refreshPromise;
-
-  refreshPromise = null;
-
-  if (result) {
-    browserAuthProvider.signIn(result, browserAuthProvider.authType);
-  } else {
-    browserAuthProvider.signOut({ triggerSignOutSubscriptions: true });
-  }
-
-  return result;
-}
-
-export function createFetcher(defaultFetcherConfig?: {
-  options?: RequestInit | (() => RequestInit);
-  baseUrl: FetcherUrl | (() => FetcherUrl);
-}) {
-  async function fetcher<SuccessInput, SuccessOutput>(
-    url: string | URL,
-    fetcherOptions: FetcherOptionsWithValidation<SuccessInput, SuccessOutput>,
-    abortSignal?: AbortSignal
-  ): Promise<SuccessOutput>;
-
-  async function fetcher(
-    url: FetcherUrl,
-    fetcherOptions: FetcherOptionsWithoutValidation,
-    abortSignal?: AbortSignal
-  ): Promise<unknown>;
-
-  async function fetcher<SuccessInput, SuccessOutput>(
-    url: FetcherUrl,
-    fetcherOptions: FetcherOptions<SuccessInput, SuccessOutput>,
-    abortSignal?: AbortSignal
-    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents -- required unknown for correct type intellisense
-  ): Promise<SuccessOutput | unknown> {
-    let fetcherOptionsWithDefaults = defaultFetcherConfig?.options
-      ? merge(
-          {},
-          (() => {
-            const options = defaultFetcherConfig.options;
-            if (options instanceof Function) return options();
-            return options;
-          })(),
-          fetcherOptions.options
-        )
-      : fetcherOptions.options;
-    if (fetcherOptions.authenticated) {
-      fetcherOptionsWithDefaults = appendHeader(fetcherOptionsWithDefaults, {
-        Authorization: `Bearer ${browserAuthProvider.getAccessToken()}`,
-      });
-    }
-
-    if (abortSignal) {
-      fetcherOptionsWithDefaults = {
-        ...fetcherOptionsWithDefaults,
-        signal: abortSignal,
-      };
-    }
-
-    const baseUrl = (() => {
-      const currentUrl = fetcherOptions.baseUrl
-        ? () => fetcherOptions.baseUrl
-        : defaultFetcherConfig?.baseUrl;
-      if (currentUrl instanceof Function) return currentUrl();
-      return currentUrl;
-    })();
-
-    function fetchUrlToString(fetchUrl: string | URL): string;
-    function fetchUrlToString(fetchUrl: undefined): undefined;
-    function fetchUrlToString(
-      fetchUrl: string | URL | undefined
-    ): string | undefined;
-    function fetchUrlToString(
-      fetchUrl: string | URL | undefined
-    ): string | undefined {
-      if (!fetchUrl) return undefined;
-      if (fetchUrl instanceof URL) return fetchUrl.href;
-      return fetchUrl;
-    }
-
-    const fetcherUrl = (() => {
-      const urlAsString = fetchUrlToString(baseUrl);
-      if (!urlAsString) return url;
-      const normalizedUrl = fetchUrlToString(url).replace(/\//, '');
-      const normalizedBaseUrl = normalizeBaseUrl(urlAsString);
-
-      return `${normalizedBaseUrl}/${normalizedUrl}`;
-    })();
-
-    let response: Response | undefined;
-
-    response = await fetch(fetcherUrl, fetcherOptionsWithDefaults);
-
-    if (
-      !response.ok &&
-      response.status === 401 &&
-      fetcherOptions.authenticated &&
-      fetcherOptions.withAuthRetry
-    ) {
-      const refetchAccessTokenSuccess = await refreshToken();
-
-      if (!refetchAccessTokenSuccess) {
-        return;
-      }
-
-      const newHeaders = appendHeader(fetcherOptionsWithDefaults, {
-        Authorization: `Bearer ${refetchAccessTokenSuccess.access_token}`,
-      });
-
-      response = await fetch(fetcherUrl, newHeaders);
-
-      if (!response.ok) {
-        browserAuthProvider.signOut({ triggerSignOutSubscriptions: true });
-        return;
-      }
-    }
-
-    let data: unknown = null;
-    try {
-      data = await response.json();
-    } catch {
-      try {
-        data = await response.text();
-      } catch (error) {
-        data = null;
-      }
-    }
-
-    if (!response.ok) {
-      throw new FetchError({
-        status: response.status,
-        message: response.statusText,
-        data,
-      });
-    }
-
-    if (fetcherOptions.skipValidation) {
-      return data;
-    }
-
-    try {
-      return fetcherOptions.successSchema.parse(data);
-    } catch (error) {
-      if (error instanceof ZodError) {
-        // eslint-disable-next-line no-console -- ...
-        console.error('Invalid response');
-        error.errors.forEach((e) => {
-          // eslint-disable-next-line no-console -- ...
-          console.error(e);
-        });
-      }
-      throw error;
-    }
-  }
-
-  return fetcher;
-}
-
-export const isFetcherError = (error: ResponseError): error is FetchError =>
-  error instanceof FetchError;
diff --git a/packages/apps/human-app/frontend/src/api/hooks/use-access-token-refresh.ts b/packages/apps/human-app/frontend/src/api/hooks/use-access-token-refresh.ts
index 2f2a291eee..95a3f79409 100644
--- a/packages/apps/human-app/frontend/src/api/hooks/use-access-token-refresh.ts
+++ b/packages/apps/human-app/frontend/src/api/hooks/use-access-token-refresh.ts
@@ -5,21 +5,14 @@ import { browserAuthProvider } from '@/shared/contexts/browser-auth-provider';
 import type { AuthType } from '@/shared/types/browser-auth-provider';
 import { useWeb3Auth } from '@/modules/auth-web3/hooks/use-web3-auth';
 import { routerPaths } from '@/router/router-paths';
-import { refreshToken } from '@/api/fetcher';
+import { authService } from '../authorized-http-api-client';
 
 export function useAccessTokenRefresh() {
   const queryClient = useQueryClient();
   const navigate = useNavigate();
-  const {
-    signIn: signInWeb2,
-    signOut: web2SignOut,
-    user: web2User,
-  } = useAuth();
-  const {
-    signIn: signInWeb3,
-    signOut: web3SignOut,
-    user: web3User,
-  } = useWeb3Auth();
+  const { signOut: web2SignOut, user: web2User } = useAuth();
+
+  const { signOut: web3SignOut, user: web3User } = useWeb3Auth();
 
   const mutation = useMutation({
     mutationFn: async ({
@@ -30,18 +23,10 @@ export function useAccessTokenRefresh() {
       throwExpirationModalOnSignOut?: boolean;
     }) => {
       try {
-        const refetchAccessTokenSuccess = await refreshToken();
-
-        if (!refetchAccessTokenSuccess) {
-          throw new Error('Failed to refresh access token.');
-        }
-
-        if (authType === 'web2') {
-          signInWeb2(refetchAccessTokenSuccess);
-        } else {
-          signInWeb3(refetchAccessTokenSuccess);
-        }
+        await authService.refreshAccessToken();
       } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(error);
         if (authType === 'web2' && web2User) {
           web2SignOut({ throwExpirationModal: false });
         }
diff --git a/packages/apps/human-app/frontend/src/api/hooks/use-prepare-signature.ts b/packages/apps/human-app/frontend/src/api/hooks/use-prepare-signature.ts
deleted file mode 100644
index 506850b033..0000000000
--- a/packages/apps/human-app/frontend/src/api/hooks/use-prepare-signature.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { z } from 'zod';
-import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-
-export enum PrepareSignatureType {
-  SIGN_UP = 'signup',
-  SIGN_IN = 'signin',
-  DISABLE_OPERATOR = 'disable_operator',
-  ENABLE_OPERATOR = 'enable_operator',
-  REGISTER_ADDRESS = 'register_address',
-}
-
-export const prepareSignatureSuccessSchema = z.object({
-  from: z.string(),
-  to: z.string(),
-  contents: z.string(),
-  nonce: z.unknown(),
-});
-
-export type SignatureData = z.infer<typeof prepareSignatureSuccessSchema>;
-export interface PrepareSignatureBody {
-  address: string;
-  type: PrepareSignatureType;
-}
-
-export const prepareSignature = (body: PrepareSignatureBody) => {
-  return apiClient(apiPaths.operator.web3Auth.prepareSignature.path, {
-    successSchema: prepareSignatureSuccessSchema,
-    options: { method: 'POST', body: JSON.stringify(body) },
-  });
-};
-
-export function usePrepareSignature(body: PrepareSignatureBody) {
-  return useQuery({
-    queryFn: () => prepareSignature(body),
-    refetchInterval: 0,
-    queryKey: ['prepareSignature'],
-  });
-}
diff --git a/packages/apps/human-app/frontend/src/api/http-api-client.ts b/packages/apps/human-app/frontend/src/api/http-api-client.ts
new file mode 100644
index 0000000000..92bb8a87a2
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/api/http-api-client.ts
@@ -0,0 +1,161 @@
+import { ZodError, type ZodType } from 'zod';
+import { env } from '@/shared/env';
+
+export class ApiClientError extends Error {
+  constructor(
+    public readonly message: string,
+    public readonly status: number,
+    public readonly data: unknown
+  ) {
+    super(message);
+  }
+}
+
+export interface RequestConfig {
+  queryParams?: Record<string, unknown>;
+  body?:
+    | string
+    | Record<string, unknown>
+    | unknown[]
+    | ArrayBuffer
+    | Blob
+    | File
+    | FormData;
+  headers?: Record<string, string | number | boolean | null>;
+  abortSignal?: AbortSignal;
+  successSchema?: ZodType;
+}
+
+type HttpApiClientMethod = <T = unknown>(
+  path: string,
+  config?: Omit<RequestConfig, 'body'>
+) => Promise<T>;
+
+type HttpApiClientMethodWithBody = <T = unknown>(
+  path: string,
+  config: RequestConfig
+) => Promise<T>;
+
+export class HttpApiClient {
+  constructor(protected baseUrl?: string) {}
+  protected async makeRequest<T = unknown>(
+    method: string,
+    path: string,
+    config: RequestConfig
+  ): Promise<T> {
+    const url = new URL(path, this.baseUrl);
+
+    const { queryParams, body, headers, successSchema, abortSignal } = config;
+
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (!value) return;
+
+        if (Array.isArray(value)) {
+          value
+            .filter((i) => i !== undefined)
+            .forEach((item) => {
+              url.searchParams.append(key, String(item));
+            });
+          return;
+        }
+
+        url.searchParams.append(key, String(value));
+      });
+    }
+
+    const lowercasedHeaders = Object.fromEntries(
+      Object.entries(headers ?? {}).map(([k, v]) => [k.toLowerCase(), v])
+    );
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'content-type': 'application/json',
+        ...lowercasedHeaders,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: abortSignal,
+    });
+
+    const text = await response.text();
+
+    const responseBody: unknown = text.length > 0 ? JSON.parse(text) : null;
+
+    if (!response.ok) {
+      const errorMessage = this.getErrorMessageForResponse(
+        responseBody,
+        response.statusText
+      );
+
+      throw new ApiClientError(errorMessage, response.status, responseBody);
+    }
+
+    if (successSchema) {
+      try {
+        // Zod defaulty type is any, but parsing will return the correct type
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return successSchema.parse(responseBody);
+      } catch (error) {
+        if (error instanceof ZodError) {
+          // eslint-disable-next-line no-console
+          console.error('Response parsing error: ', error.errors);
+          throw new Error('Response schema validation error.');
+        }
+
+        // eslint-disable-next-line no-console
+        console.error('Unexpected error while parsing response body: ', error);
+        throw new Error(`Error parsing response body.`);
+      }
+    }
+
+    return responseBody as T;
+  }
+
+  private getErrorMessageForResponse(
+    responseBody: unknown,
+    statusText: string
+  ): string {
+    if (typeof responseBody === 'string') {
+      return responseBody;
+    }
+
+    if (typeof responseBody === 'object' && responseBody !== null) {
+      if ('message' in responseBody) {
+        if (Array.isArray(responseBody.message)) {
+          return responseBody.message.join(', ');
+        }
+
+        if (typeof responseBody.message === 'string') {
+          return responseBody.message;
+        }
+      }
+
+      return 'Unknown request error.';
+    }
+
+    if (statusText.length) {
+      return statusText;
+    }
+
+    return 'Unknown request error.';
+  }
+
+  get: HttpApiClientMethod = async (path, config = {}) => {
+    return this.makeRequest('GET', path, config);
+  };
+  post: HttpApiClientMethodWithBody = async (path, config = {}) => {
+    return this.makeRequest('POST', path, config);
+  };
+  patch: HttpApiClientMethodWithBody = async (path, config = {}) => {
+    return this.makeRequest('PATCH', path, config);
+  };
+  put: HttpApiClientMethodWithBody = async (path, config = {}) => {
+    return this.makeRequest('PUT', path, config);
+  };
+  delete: HttpApiClientMethod = async (path, config = {}) => {
+    return this.makeRequest('DELETE', path, config);
+  };
+}
+
+export const humanAppApiClient = new HttpApiClient(env.VITE_API_URL);
diff --git a/packages/apps/human-app/frontend/src/api/index.ts b/packages/apps/human-app/frontend/src/api/index.ts
new file mode 100644
index 0000000000..f7df62cc91
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/api/index.ts
@@ -0,0 +1,7 @@
+export * from './authorized-http-api-client';
+export {
+  HttpApiClient,
+  ApiClientError,
+  humanAppApiClient,
+} from './http-api-client';
+export * from './auth-service';
diff --git a/packages/apps/human-app/frontend/src/api/utils/test.schema.ts b/packages/apps/human-app/frontend/src/api/utils/test.schema.ts
deleted file mode 100644
index 04c6b07050..0000000000
--- a/packages/apps/human-app/frontend/src/api/utils/test.schema.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { z } from 'zod';
-import { testDataSchema } from '@/shared/types/entity.type';
-
-export const testSchema = z.object({
-  requestId: z.string(),
-  timestamp: testDataSchema,
-});
diff --git a/packages/apps/human-app/frontend/src/api/utils/test.service.ts b/packages/apps/human-app/frontend/src/api/utils/test.service.ts
deleted file mode 100644
index d2d6facd50..0000000000
--- a/packages/apps/human-app/frontend/src/api/utils/test.service.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '../api-client';
-import { apiPaths } from '../api-paths';
-import { testSchema } from './test.schema';
-
-function getTest() {
-  return apiClient(apiPaths.test.path, {
-    options: { method: 'GET' },
-    successSchema: testSchema,
-  });
-}
-
-export function useGetTest() {
-  return useQuery({
-    queryKey: ['test'],
-    retry: false,
-    queryFn: getTest,
-  });
-}
diff --git a/packages/apps/human-app/frontend/src/modules/auth/index.ts b/packages/apps/human-app/frontend/src/modules/auth/index.ts
deleted file mode 100644
index 0e551ad9cd..0000000000
--- a/packages/apps/human-app/frontend/src/modules/auth/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { useAuth, useAuthenticatedUser } from './hooks/index';
diff --git a/packages/apps/human-app/frontend/src/modules/homepage/components/operator-sign-in.tsx b/packages/apps/human-app/frontend/src/modules/homepage/components/operator-sign-in.tsx
index 92d38e947b..2c215be780 100644
--- a/packages/apps/human-app/frontend/src/modules/homepage/components/operator-sign-in.tsx
+++ b/packages/apps/human-app/frontend/src/modules/homepage/components/operator-sign-in.tsx
@@ -7,7 +7,6 @@ import { useWalletConnect } from '@/shared/contexts/wallet-connect';
 import { useWeb3Auth } from '@/modules/auth-web3/hooks/use-web3-auth';
 import { routerPaths } from '@/router/router-paths';
 import { getErrorMessageForError } from '@/shared/errors';
-import { PrepareSignatureType } from '@/api/hooks/use-prepare-signature';
 import { useWeb3SignIn } from '../hooks';
 
 export function OperatorSignIn() {
@@ -22,7 +21,7 @@ export function OperatorSignIn() {
 
   useEffect(() => {
     if (isConnected && modalWasOpened.current) {
-      signInMutation({ address, type: PrepareSignatureType.SIGN_IN });
+      signInMutation();
     }
   }, [address, isConnected, signInMutation]);
 
@@ -77,7 +76,7 @@ export function OperatorSignIn() {
       <Button
         fullWidth
         onClick={() => {
-          signInMutation({ address, type: PrepareSignatureType.SIGN_IN });
+          signInMutation();
         }}
         size="large"
         variant="outlined"
diff --git a/packages/apps/human-app/frontend/src/modules/homepage/hooks/use-web3-signin.ts b/packages/apps/human-app/frontend/src/modules/homepage/hooks/use-web3-signin.ts
index 8641645e07..06bc28fa34 100644
--- a/packages/apps/human-app/frontend/src/modules/homepage/hooks/use-web3-signin.ts
+++ b/packages/apps/human-app/frontend/src/modules/homepage/hooks/use-web3-signin.ts
@@ -2,13 +2,12 @@
 import { useMutation } from '@tanstack/react-query';
 import { z } from 'zod';
 import { useNavigate } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useWeb3Auth } from '@/modules/auth-web3/hooks/use-web3-auth';
 import { routerPaths } from '@/router/router-paths';
 import { useWalletConnect } from '@/shared/contexts/wallet-connect';
-import type { PrepareSignatureBody } from '@/api/hooks/use-prepare-signature';
-import { prepareSignature } from '@/api/hooks/use-prepare-signature';
+import { usePrepareSignature } from '@/shared/hooks';
+import { PrepareSignatureType } from '@/shared/services/signature.service';
+import * as homepageService from '../services/homepage.service';
 
 export const web3SignInSuccessResponseSchema = z.object({
   access_token: z.string(),
@@ -23,24 +22,30 @@ export function useWeb3SignIn() {
   const { address, chainId, signMessage } = useWalletConnect();
   const { signIn } = useWeb3Auth();
   const navigate = useNavigate();
+  const { prepareSignature } = usePrepareSignature(
+    PrepareSignatureType.SIGN_IN
+  );
+
   return useMutation({
-    mutationFn: async (body: PrepareSignatureBody) => {
-      const dataToSign = await prepareSignature(body);
+    mutationFn: async () => {
+      const data = await prepareSignature();
+
+      const signature = await signMessage(JSON.stringify(data));
 
-      const signature = await signMessage(JSON.stringify(dataToSign));
+      if (!signature || !address) {
+        throw new Error('Failed to sign message: missing arguments.');
+      }
 
-      return apiClient(apiPaths.operator.web3Auth.signIn.path, {
-        successSchema: web3SignInSuccessResponseSchema,
-        options: {
-          method: 'POST',
-          body: JSON.stringify({ address, signature }),
-        },
+      return homepageService.web3SignIn({
+        address,
+        signature,
       });
     },
     onSuccess: (successResponse) => {
       signIn(successResponse);
       navigate(routerPaths.operator.profile);
     },
+
     mutationKey: ['web3SignIn', address, chainId],
   });
 }
diff --git a/packages/apps/human-app/frontend/src/modules/homepage/services/homepage.service.ts b/packages/apps/human-app/frontend/src/modules/homepage/services/homepage.service.ts
new file mode 100644
index 0000000000..98c44f091a
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/homepage/services/homepage.service.ts
@@ -0,0 +1,28 @@
+import { ApiClientError, humanAppApiClient } from '@/api';
+import { type Web3SignInSuccessResponse } from '../hooks';
+
+const apiPaths = {
+  web3Auth: {
+    signIn: '/auth/web3/signin',
+  },
+};
+
+async function web3SignIn(data: { signature: string; address: string }) {
+  try {
+    const result = await humanAppApiClient.post<Web3SignInSuccessResponse>(
+      apiPaths.web3Auth.signIn,
+      {
+        body: data,
+      }
+    );
+    return result;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to log in using web3.');
+  }
+}
+
+export { web3SignIn };
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/components/operator-stats.tsx b/packages/apps/human-app/frontend/src/modules/operator/profile/components/operator-stats.tsx
index 729eabc9f6..a0a8b06723 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/components/operator-stats.tsx
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/components/operator-stats.tsx
@@ -3,7 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { ProfileListItem } from '@/shared/components/ui/profile';
 import { useColorMode } from '@/shared/contexts/color-mode';
 import { useIsMobile } from '@/shared/hooks/use-is-mobile';
-import { type OperatorStatsResponse } from '../hooks';
+import { type OperatorStatsResponse } from '../types';
 
 export function OperatorStats({
   statsData,
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-disable-button.tsx b/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-disable-button.tsx
index 8878fd6b98..fd6798bd39 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-disable-button.tsx
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-disable-button.tsx
@@ -1,49 +1,51 @@
 import { t } from 'i18next';
-import { Typography } from '@mui/material';
+import { useEffect } from 'react';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
 import { Button } from '@/shared/components/ui/button';
-import type { SignatureData } from '@/api/hooks/use-prepare-signature';
 import {
-  PrepareSignatureType,
+  TopNotificationType,
+  useNotification,
   usePrepareSignature,
-} from '@/api/hooks/use-prepare-signature';
+} from '@/shared/hooks';
+import { PrepareSignatureType } from '@/shared/services/signature.service';
 import { useDisableWeb3Operator } from '../hooks';
 
 export function ProfileDisableButton() {
-  const { address, signMessage } = useConnectedWallet();
+  const { signMessage } = useConnectedWallet();
   const {
-    data: signatureData,
-    isError: isSignatureDataError,
+    prepareSignature,
     isPending: isSignatureDataPending,
-  } = usePrepareSignature({
-    address,
-    type: PrepareSignatureType.DISABLE_OPERATOR,
-  });
+    error: signatureDataError,
+  } = usePrepareSignature(PrepareSignatureType.DISABLE_OPERATOR);
 
   const {
     mutate: disableOperatorMutation,
-    isError: isDisableOperatorError,
+    error: disableOperatorError,
     isPending: isDisableOperatorPending,
   } = useDisableWeb3Operator();
 
-  const disableOperator = async (signaturePayload: SignatureData) => {
+  const { showNotification } = useNotification();
+
+  useEffect(() => {
+    if (Boolean(signatureDataError) || Boolean(disableOperatorError)) {
+      showNotification({
+        message: t('operator.profile.disable.cannotDisable'),
+        type: TopNotificationType.WARNING,
+      });
+    }
+  }, [signatureDataError, disableOperatorError, showNotification]);
+
+  const disableOperator = async () => {
+    const signaturePayload = await prepareSignature();
     const signature = await signMessage(JSON.stringify(signaturePayload));
     disableOperatorMutation({ signature: signature ?? '' });
   };
 
-  if (isSignatureDataError || isDisableOperatorError) {
-    return (
-      <Typography>{t('operator.profile.disable.cannotDisable')}</Typography>
-    );
-  }
-
   return (
     <Button
       loading={isSignatureDataPending || isDisableOperatorPending}
       onClick={() => {
-        if (signatureData) {
-          void disableOperator(signatureData);
-        }
+        void disableOperator();
       }}
       variant="contained"
     >
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-enable-button.tsx b/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-enable-button.tsx
index 91193ce7d3..7773f5577f 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-enable-button.tsx
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/components/profile-enable-button.tsx
@@ -1,49 +1,51 @@
 import { t } from 'i18next';
-import { Typography } from '@mui/material';
+import { useEffect } from 'react';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
 import { Button } from '@/shared/components/ui/button';
-import type { SignatureData } from '@/api/hooks/use-prepare-signature';
 import {
-  PrepareSignatureType,
+  TopNotificationType,
+  useNotification,
   usePrepareSignature,
-} from '@/api/hooks/use-prepare-signature';
+} from '@/shared/hooks';
+import { PrepareSignatureType } from '@/shared/services/signature.service';
 import { useEnableWeb3Operator } from '../hooks';
 
 export function ProfileEnableButton() {
-  const { address, signMessage } = useConnectedWallet();
+  const { signMessage } = useConnectedWallet();
   const {
-    data: signatureData,
-    isError: isSignatureDataError,
+    prepareSignature,
+    error: signatureDataError,
     isPending: isSignatureDataPending,
-  } = usePrepareSignature({
-    address,
-    type: PrepareSignatureType.ENABLE_OPERATOR,
-  });
+  } = usePrepareSignature(PrepareSignatureType.ENABLE_OPERATOR);
 
   const {
     mutate: enableOperatorMutation,
-    isError: isEnableOperatorError,
+    error: enableOperatorError,
     isPending: isEnableOperatorPending,
   } = useEnableWeb3Operator();
 
-  const enableOperator = async (signaturePayload: SignatureData) => {
+  const { showNotification } = useNotification();
+
+  useEffect(() => {
+    if (Boolean(signatureDataError) || Boolean(enableOperatorError)) {
+      showNotification({
+        message: t('operator.profile.activate.cannotActivate'),
+        type: TopNotificationType.WARNING,
+      });
+    }
+  }, [signatureDataError, enableOperatorError, showNotification]);
+
+  const enableOperator = async () => {
+    const signaturePayload = await prepareSignature();
     const signature = await signMessage(JSON.stringify(signaturePayload));
     enableOperatorMutation({ signature: signature ?? '' });
   };
 
-  if (isSignatureDataError || isEnableOperatorError) {
-    return (
-      <Typography>{t('operator.profile.activate.cannotActivate')}</Typography>
-    );
-  }
-
   return (
     <Button
       loading={isSignatureDataPending || isEnableOperatorPending}
       onClick={() => {
-        if (signatureData) {
-          void enableOperator(signatureData);
-        }
+        void enableOperator();
       }}
       variant="contained"
     >
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-disable-operator.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-disable-operator.ts
index fa407468dd..ac378ec1d0 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-disable-operator.ts
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-disable-operator.ts
@@ -1,32 +1,21 @@
 import { useMutation } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
-import { useAccessTokenRefresh } from '@/api/hooks/use-access-token-refresh';
 import { OperatorStatus } from '@/modules/auth-web3/context/web3-auth-context';
 import { useWeb3AuthenticatedUser } from '@/modules/auth-web3/hooks/use-web3-authenticated-user';
+import { authService } from '@/api';
+import * as operatorProfileService from '../services/profile.service';
 
 export function useDisableWeb3Operator() {
   const { address, chainId } = useConnectedWallet();
-  const { refreshAccessTokenAsync } = useAccessTokenRefresh();
   const { updateUserData } = useWeb3AuthenticatedUser();
   return useMutation({
     mutationFn: async ({ signature }: { signature: string }) => {
-      const result = await apiClient(apiPaths.operator.disableOperator.path, {
-        skipValidation: true,
-        authenticated: true,
-        withAuthRetry: apiPaths.operator.disableOperator.withAuthRetry,
-        options: {
-          method: 'POST',
-          body: JSON.stringify({ signature }),
-        },
-      });
+      await operatorProfileService.disableOperator(signature);
+
+      await authService.refreshAccessToken();
 
-      await refreshAccessTokenAsync({ authType: 'web3' });
       // eslint-disable-next-line camelcase
       updateUserData({ operator_status: OperatorStatus.INACTIVE });
-
-      return result;
     },
     mutationKey: ['disableOperator', address, chainId],
   });
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-enable-operator.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-enable-operator.ts
index 220f1664e8..f3a826d98c 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-enable-operator.ts
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-enable-operator.ts
@@ -1,32 +1,21 @@
 import { useMutation } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
-import { useAccessTokenRefresh } from '@/api/hooks/use-access-token-refresh';
 import { useWeb3AuthenticatedUser } from '@/modules/auth-web3/hooks/use-web3-authenticated-user';
 import { OperatorStatus } from '@/modules/auth-web3/context/web3-auth-context';
+import { authService } from '@/api';
+import * as operatorProfileService from '../services/profile.service';
 
 export function useEnableWeb3Operator() {
   const { address, chainId } = useConnectedWallet();
-  const { refreshAccessTokenAsync } = useAccessTokenRefresh();
   const { updateUserData } = useWeb3AuthenticatedUser();
   return useMutation({
     mutationFn: async ({ signature }: { signature: string }) => {
-      const result = await apiClient(apiPaths.operator.enableOperator.path, {
-        skipValidation: true,
-        authenticated: true,
-        withAuthRetry: apiPaths.operator.enableOperator.withAuthRetry,
-        options: {
-          method: 'POST',
-          body: JSON.stringify({ signature }),
-        },
-      });
+      await operatorProfileService.enableOperator(signature);
+
+      await authService.refreshAccessToken();
 
-      await refreshAccessTokenAsync({ authType: 'web3' });
       // eslint-disable-next-line camelcase
       updateUserData({ operator_status: OperatorStatus.ACTIVE });
-
-      return result;
     },
     mutationKey: ['enableOperator', address, chainId],
   });
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-get-stats.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-get-stats.ts
index 8bc801b898..f6cc9448d0 100644
--- a/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-get-stats.ts
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/hooks/use-get-stats.ts
@@ -1,20 +1,9 @@
 /* eslint-disable camelcase -- ... */
 import { useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import { apiClient } from '@/api/api-client';
 import { useGetKeys } from '@/modules/operator/hooks/use-get-keys';
+import * as operatorProfileService from '../services/profile.service';
 
-const operatorStatsSuccessResponseSchema = z.object({
-  workers_total: z.number(),
-  assignments_completed: z.number(),
-  assignments_expired: z.number(),
-  assignments_rejected: z.number(),
-  escrows_processed: z.number(),
-  escrows_active: z.number(),
-  escrows_cancelled: z.number(),
-});
-
-const failedResponse = {
+export const failedResponse = {
   workers_total: '-',
   assignments_completed: '-',
   assignments_expired: '-',
@@ -24,16 +13,6 @@ const failedResponse = {
   escrows_cancelled: '-',
 };
 
-type OperatorStatsSuccessResponse = z.infer<
-  typeof operatorStatsSuccessResponseSchema
->;
-
-type OperatorStatsFailedResponse = typeof failedResponse;
-
-export type OperatorStatsResponse =
-  | OperatorStatsSuccessResponse
-  | OperatorStatsFailedResponse;
-
 export function useGetOperatorStats() {
   const { data: keysData } = useGetKeys();
 
@@ -42,13 +21,9 @@ export function useGetOperatorStats() {
       if (!keysData?.url) {
         return failedResponse;
       }
-      return apiClient(`/stats`, {
-        baseUrl: keysData.url,
-        successSchema: operatorStatsSuccessResponseSchema,
-        options: {
-          method: 'GET',
-        },
-      }).catch(() => failedResponse);
+      return operatorProfileService
+        .getStats(keysData.url)
+        .catch(() => failedResponse);
     },
     queryKey: ['getOperatorStats', keysData?.url],
   });
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/schemas.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/schemas.ts
new file mode 100644
index 0000000000..a51a770b0e
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/schemas.ts
@@ -0,0 +1,12 @@
+/* eslint-disable camelcase */
+import { z } from 'zod';
+
+export const operatorStatsSuccessResponseSchema = z.object({
+  workers_total: z.number(),
+  assignments_completed: z.number(),
+  assignments_expired: z.number(),
+  assignments_rejected: z.number(),
+  escrows_processed: z.number(),
+  escrows_active: z.number(),
+  escrows_cancelled: z.number(),
+});
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/services/profile.service.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/services/profile.service.ts
new file mode 100644
index 0000000000..588a15a106
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/services/profile.service.ts
@@ -0,0 +1,60 @@
+import {
+  ApiClientError,
+  authorizedHumanAppApiClient,
+  HttpApiClient,
+} from '@/api';
+import { type OperatorStatsSuccessResponse } from '../types';
+import { operatorStatsSuccessResponseSchema } from '../schemas';
+
+const apiPaths = {
+  enableOperator: '/enable-operator',
+  disableOperator: '/disable-operator',
+  stats: '/stats',
+};
+
+async function enableOperator(signature: string) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.enableOperator, {
+      body: { signature },
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to enable operator');
+  }
+}
+
+async function disableOperator(signature: string) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.disableOperator, {
+      body: { signature },
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to disable operator');
+  }
+}
+
+async function getStats(statsBaseUrl: string) {
+  const httpClient = new HttpApiClient(statsBaseUrl);
+
+  try {
+    const result = await httpClient.get<OperatorStatsSuccessResponse>(
+      apiPaths.stats,
+      {
+        successSchema: operatorStatsSuccessResponseSchema,
+      }
+    );
+
+    return result;
+  } catch (error) {
+    throw new Error('Failed to get stats');
+  }
+}
+
+export { enableOperator, disableOperator, getStats };
diff --git a/packages/apps/human-app/frontend/src/modules/operator/profile/types.ts b/packages/apps/human-app/frontend/src/modules/operator/profile/types.ts
new file mode 100644
index 0000000000..971dd3a0ae
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/operator/profile/types.ts
@@ -0,0 +1,13 @@
+import { type z } from 'zod';
+import { type failedResponse } from './hooks';
+import { type operatorStatsSuccessResponseSchema } from './schemas';
+
+export type OperatorStatsSuccessResponse = z.infer<
+  typeof operatorStatsSuccessResponseSchema
+>;
+
+type OperatorStatsFailedResponse = typeof failedResponse;
+
+export type OperatorStatsResponse =
+  | OperatorStatsSuccessResponse
+  | OperatorStatsFailedResponse;
diff --git a/packages/apps/human-app/frontend/src/modules/signin/worker/sign-in.page.tsx b/packages/apps/human-app/frontend/src/modules/signin/worker/sign-in.page.tsx
index c650c09fb7..f7f216dc4d 100644
--- a/packages/apps/human-app/frontend/src/modules/signin/worker/sign-in.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/signin/worker/sign-in.page.tsx
@@ -2,14 +2,14 @@ import { t } from 'i18next';
 import { PageCard } from '@/shared/components/ui/page-card';
 import { Alert } from '@/shared/components/ui/alert';
 import { getErrorMessageForError } from '@/shared/errors';
-import { FetchError } from '@/api/fetcher';
+import { ApiClientError } from '@/api';
 import { useSignIn } from './use-sign-in';
 import { SignInForm } from './sign-in-form';
 
 function formattedSignInErrorMessage(
   unknownError: unknown
 ): string | undefined {
-  if (unknownError instanceof FetchError && unknownError.status === 400) {
+  if (unknownError instanceof ApiClientError && unknownError.status === 401) {
     return t('worker.signInForm.errors.invalidCredentials');
   }
 }
diff --git a/packages/apps/human-app/frontend/src/modules/signin/worker/use-sign-in-mutation.ts b/packages/apps/human-app/frontend/src/modules/signin/worker/use-sign-in-mutation.ts
index 2b54f8e727..b2665890cd 100644
--- a/packages/apps/human-app/frontend/src/modules/signin/worker/use-sign-in-mutation.ts
+++ b/packages/apps/human-app/frontend/src/modules/signin/worker/use-sign-in-mutation.ts
@@ -1,31 +1,24 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { routerPaths } from '@/router/router-paths';
-import { useAuth } from '@/modules/auth/hooks/use-auth';
-import { authTokensSuccessResponseSchema } from '@/shared/schemas';
+import { env } from '@/shared/env';
+import { AuthService, HttpApiClient } from '@/api';
 import { type SignInDto } from './schemas';
 
 function signInMutationFn(data: SignInDto) {
-  return apiClient(apiPaths.worker.signIn.path, {
-    successSchema: authTokensSuccessResponseSchema,
-    options: {
-      method: 'POST',
-      body: JSON.stringify(data),
-    },
-  });
+  const httpClient = new HttpApiClient(env.VITE_API_URL);
+  const auth = new AuthService(httpClient);
+
+  return auth.signIn(data);
 }
 
 export function useSignInMutation() {
   const queryClient = useQueryClient();
   const navigate = useNavigate();
-  const { signIn } = useAuth();
 
   return useMutation({
     mutationFn: signInMutationFn,
-    onSuccess: async (data) => {
-      signIn(data);
+    onSuccess: async () => {
       navigate(routerPaths.worker.profile);
       window.location.reload();
       await queryClient.invalidateQueries();
diff --git a/packages/apps/human-app/frontend/src/modules/signup/operator/hooks/use-web3-signup.ts b/packages/apps/human-app/frontend/src/modules/signup/operator/hooks/use-web3-signup.ts
index bae23c38dd..d0592b6479 100644
--- a/packages/apps/human-app/frontend/src/modules/signup/operator/hooks/use-web3-signup.ts
+++ b/packages/apps/human-app/frontend/src/modules/signup/operator/hooks/use-web3-signup.ts
@@ -1,21 +1,9 @@
-/* eslint-disable camelcase -- ...*/
 import { useMutation } from '@tanstack/react-query';
-import { z } from 'zod';
 import { useNavigate } from 'react-router-dom';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useWeb3Auth } from '@/modules/auth-web3/hooks/use-web3-auth';
 import { routerPaths } from '@/router/router-paths';
-
-export const web3SignInSuccessResponseSchema = z.object({
-  access_token: z.string(),
-  refresh_token: z.string(),
-});
-
-export type Web3SignInSuccessResponse = z.infer<
-  typeof web3SignInSuccessResponseSchema
->;
+import * as signupService from '@/modules/signup/services/signup.service';
 
 export function useWeb3SignUp() {
   const { address, chainId } = useConnectedWallet();
@@ -23,12 +11,9 @@ export function useWeb3SignUp() {
   const navigate = useNavigate();
   return useMutation({
     mutationFn: async ({ signature }: { signature: string }) =>
-      apiClient(apiPaths.operator.web3Auth.signUp.path, {
-        successSchema: web3SignInSuccessResponseSchema,
-        options: {
-          method: 'POST',
-          body: JSON.stringify({ address, signature }),
-        },
+      signupService.operatorWeb3SignUp({
+        signature,
+        address,
       }),
     onSuccess: (successResponse) => {
       signIn(successResponse);
diff --git a/packages/apps/human-app/frontend/src/modules/signup/operator/views/edit-existing-keys-success.page.tsx b/packages/apps/human-app/frontend/src/modules/signup/operator/views/edit-existing-keys-success.page.tsx
index 4c8bfac94d..f7560bfcef 100644
--- a/packages/apps/human-app/frontend/src/modules/signup/operator/views/edit-existing-keys-success.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/signup/operator/views/edit-existing-keys-success.page.tsx
@@ -7,26 +7,23 @@ import {
 } from '@/shared/components/ui/page-card';
 import { Button } from '@/shared/components/ui/button';
 import { getErrorMessageForError } from '@/shared/errors';
-import type { SignatureData } from '@/api/hooks/use-prepare-signature';
-import {
-  PrepareSignatureType,
-  usePrepareSignature,
-} from '@/api/hooks/use-prepare-signature';
 import { Alert } from '@/shared/components/ui/alert';
 import { useConnectedWallet } from '@/shared/contexts/wallet-connect';
+import { usePrepareSignature } from '@/shared/hooks';
+import {
+  PrepareSignatureType,
+  type SignatureData,
+} from '@/shared/services/signature.service';
 import { useWeb3SignUp } from '../hooks';
 
 export function EditExistingKeysSuccessPage() {
-  const { address, signMessage } = useConnectedWallet();
+  const { signMessage } = useConnectedWallet();
   const {
-    data: signatureData,
+    prepareSignature,
     isError: isSignatureDataError,
     error: errorSignatureDataError,
     isPending: isSignatureDataPending,
-  } = usePrepareSignature({
-    address,
-    type: PrepareSignatureType.SIGN_UP,
-  });
+  } = usePrepareSignature(PrepareSignatureType.SIGN_UP);
 
   const {
     mutate: web3SignUpMutation,
@@ -35,7 +32,8 @@ export function EditExistingKeysSuccessPage() {
     isPending: web3SignUpPending,
   } = useWeb3SignUp();
 
-  const createSignature = async (data: SignatureData) => {
+  const handleWeb3SignUp = async () => {
+    const data: SignatureData = await prepareSignature();
     const signature = await signMessage(JSON.stringify(data));
     web3SignUpMutation({ signature: signature ?? '' });
   };
@@ -78,7 +76,7 @@ export function EditExistingKeysSuccessPage() {
           fullWidth
           loading={web3SignUpPending}
           onClick={() => {
-            void createSignature(signatureData);
+            void handleWeb3SignUp();
           }}
           variant="contained"
         >
diff --git a/packages/apps/human-app/frontend/src/modules/signup/services/signup.service.ts b/packages/apps/human-app/frontend/src/modules/signup/services/signup.service.ts
new file mode 100644
index 0000000000..8ee29402a7
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/signup/services/signup.service.ts
@@ -0,0 +1,65 @@
+/* eslint-disable camelcase */
+import { z } from 'zod';
+import { ApiClientError, humanAppApiClient } from '@/api';
+import { type SignUpDto } from '../worker/schema';
+
+const apiPaths = {
+  worker: {
+    signUp: '/auth/signup',
+  },
+  operator: {
+    web3Auth: {
+      signUp: '/auth/web3/signup',
+    },
+  },
+};
+
+const web3SignInSuccessResponseSchema = z.object({
+  access_token: z.string(),
+  refresh_token: z.string(),
+});
+
+type Web3SignInSuccessResponse = z.infer<
+  typeof web3SignInSuccessResponseSchema
+>;
+
+async function workerSignUp(data: Omit<SignUpDto, 'confirmPassword'>) {
+  try {
+    const result = await humanAppApiClient.post(apiPaths.worker.signUp, {
+      body: {
+        email: data.email,
+        password: data.password,
+        h_captcha_token: data.hCaptchaToken,
+      },
+    });
+
+    return result;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to sign up worker');
+  }
+}
+
+async function operatorWeb3SignUp(data: {
+  signature: string;
+  address: string;
+}) {
+  try {
+    const result = await humanAppApiClient.post<Web3SignInSuccessResponse>(
+      apiPaths.operator.web3Auth.signUp,
+      {
+        body: data,
+      }
+    );
+    return result;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to sign up operator with web3');
+  }
+}
+
+export { workerSignUp, operatorWeb3SignUp };
diff --git a/packages/apps/human-app/frontend/src/modules/signup/worker/hooks/use-sign-up-mutation.ts b/packages/apps/human-app/frontend/src/modules/signup/worker/hooks/use-sign-up-mutation.ts
index 325b951b1e..62dc24cace 100644
--- a/packages/apps/human-app/frontend/src/modules/signup/worker/hooks/use-sign-up-mutation.ts
+++ b/packages/apps/human-app/frontend/src/modules/signup/worker/hooks/use-sign-up-mutation.ts
@@ -1,26 +1,17 @@
-import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { routerPaths } from '@/router/router-paths';
+import * as signupService from '@/modules/signup/services/signup.service';
 import { type SignUpDto } from '../schema';
 
-const signUpSuccessResponseSchema = z.unknown();
-
-async function signUpMutationFn(data: Omit<SignUpDto, 'confirmPassword'>) {
-  await apiClient(apiPaths.worker.signUp.path, {
-    successSchema: signUpSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
-
 export function useSignUpMutation() {
   const queryClient = useQueryClient();
   const navigate = useNavigate();
 
   return useMutation({
-    mutationFn: signUpMutationFn,
+    mutationFn: async (data: Omit<SignUpDto, 'confirmPassword'>) => {
+      return signupService.workerSignUp(data);
+    },
     onSuccess: async (_, { email }) => {
       navigate(routerPaths.worker.verifyEmail, {
         state: { routerState: { email } },
diff --git a/packages/apps/human-app/frontend/src/modules/signup/worker/schema.ts b/packages/apps/human-app/frontend/src/modules/signup/worker/schema.ts
index 1aa96aa028..a69da06768 100644
--- a/packages/apps/human-app/frontend/src/modules/signup/worker/schema.ts
+++ b/packages/apps/human-app/frontend/src/modules/signup/worker/schema.ts
@@ -4,11 +4,7 @@ import { z } from 'zod';
 export const signUpDtoSchema = z
   .object({
     email: z.string().email(t('validation.invalidEmail')),
-    // eslint-disable-next-line camelcase -- export vite config
-    h_captcha_token: z
-      .string()
-      .min(1, t('validation.captcha'))
-      .default('token'),
+    hCaptchaToken: z.string().min(1, t('validation.captcha')).default('token'),
   })
   .and(
     z
diff --git a/packages/apps/human-app/frontend/src/modules/signup/worker/views/sign-up-worker.page.tsx b/packages/apps/human-app/frontend/src/modules/signup/worker/views/sign-up-worker.page.tsx
index af647203b7..c2f8f63f0b 100644
--- a/packages/apps/human-app/frontend/src/modules/signup/worker/views/sign-up-worker.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/signup/worker/views/sign-up-worker.page.tsx
@@ -13,8 +13,8 @@ import { getErrorMessageForError } from '@/shared/errors';
 import { Alert } from '@/shared/components/ui/alert';
 import { HCaptchaForm } from '@/shared/components/hcaptcha';
 import { useResetMutationErrors } from '@/shared/hooks/use-reset-mutation-errors';
-import { FetchError } from '@/api/fetcher';
 import { useSignUpWorker } from '@/modules/signup/worker/hooks/use-sign-up-worker';
+import { ApiClientError } from '@/api';
 import { signUpDtoSchema } from '../schema';
 
 export function SignUpWorkerPage() {
@@ -25,8 +25,7 @@ export function SignUpWorkerPage() {
       email: '',
       password: '',
       confirmPassword: '',
-      // eslint-disable-next-line camelcase -- export vite config
-      h_captcha_token: '',
+      hCaptchaToken: '',
     },
     resolver: zodResolver(signUpDtoSchema),
   });
@@ -34,7 +33,7 @@ export function SignUpWorkerPage() {
   useResetMutationErrors(methods.watch, reset);
 
   const handleSignupError = (unknownError: unknown) => {
-    if (unknownError instanceof FetchError && unknownError.status === 409) {
+    if (unknownError instanceof ApiClientError && unknownError.status === 409) {
       return t('worker.signUpForm.errors.emailTaken');
     }
   };
@@ -89,7 +88,7 @@ export function SignUpWorkerPage() {
                 />
               </Typography>
             </Grid>
-            <HCaptchaForm error={error} name="h_captcha_token" />
+            <HCaptchaForm error={error} name="hCaptchaToken" />
             <Button
               fullWidth
               loading={isLoading}
diff --git a/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/resend-email-verification.ts b/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/resend-email-verification.ts
index ffd11f0306..1ec3ef6476 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/resend-email-verification.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/resend-email-verification.ts
@@ -1,27 +1,20 @@
-import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { t } from 'i18next';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useAuth } from '@/modules/auth/hooks/use-auth';
 import { type ResendEmailVerificationDto } from '../schemas';
-
-const ResendEmailVerificationSuccessResponseSchema = z.unknown();
+import * as emailVerificationService from '../services/email-verification.service';
 
 async function resendEmailVerificationMutationFn(
-  data: ResendEmailVerificationDto,
+  _data: ResendEmailVerificationDto,
   isAuthenticated: boolean
 ) {
   if (!isAuthenticated) {
     throw new Error(t('worker.verifyEmail.authError'));
   }
 
-  return apiClient(apiPaths.worker.resendEmailVerification.path, {
-    authenticated: true,
-    withAuthRetry: apiPaths.worker.resendEmailVerification.withAuthRetry,
-    successSchema: ResendEmailVerificationSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
+  return emailVerificationService.resendEmailVerification(
+    _data.h_captcha_token
+  );
 }
 
 const resendEmailVerificationKey = 'resendEmailVerification';
diff --git a/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/use-email-verification-query.ts b/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/use-email-verification-query.ts
index 5f2b02c2e2..0402ab3ed7 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/use-email-verification-query.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/email-verification/hooks/use-email-verification-query.ts
@@ -1,7 +1,6 @@
 import { z } from 'zod';
 import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
+import * as emailVerificationService from '../services/email-verification.service';
 
 export const verifyEmailDtoSchema = z.object({
   token: z.string(),
@@ -9,20 +8,11 @@ export const verifyEmailDtoSchema = z.object({
 
 export type VerifyDto = z.infer<typeof verifyEmailDtoSchema>;
 
-const VerifyEmailSuccessResponseSchema = z.unknown();
-
-async function verifyEmailQueryFn(data: VerifyDto) {
-  return apiClient(apiPaths.worker.verifyEmail.path, {
-    authenticated: true,
-    withAuthRetry: apiPaths.worker.verifyEmail.withAuthRetry,
-    successSchema: VerifyEmailSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+export const VerifyEmailSuccessResponseSchema = z.unknown();
 
 export function useVerifyEmailQuery({ token }: { token: string }) {
   return useQuery({
-    queryFn: () => verifyEmailQueryFn({ token }),
+    queryFn: () => emailVerificationService.verifyEmail(token),
     queryKey: [token],
     refetchInterval: 0,
   });
diff --git a/packages/apps/human-app/frontend/src/modules/worker/email-verification/services/email-verification.service.ts b/packages/apps/human-app/frontend/src/modules/worker/email-verification/services/email-verification.service.ts
new file mode 100644
index 0000000000..25bb03bed6
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/email-verification/services/email-verification.service.ts
@@ -0,0 +1,37 @@
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+
+const apiPaths = {
+  verifyEmail: '/email-confirmation/email-verification',
+  resendEmailVerification: '/email-confirmation/resend-email-verification',
+};
+
+async function verifyEmail(token: string) {
+  try {
+    await authorizedHumanAppApiClient.get(
+      `${apiPaths.verifyEmail}?token=${token}`
+    );
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to verify email');
+  }
+}
+
+async function resendEmailVerification(token: string) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.resendEmailVerification, {
+      body: {
+        // eslint-disable-next-line camelcase
+        h_captcha_token: token,
+      },
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to resend email verification');
+  }
+}
+
+export { verifyEmail, resendEmailVerification };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-details.tsx b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-details.tsx
index f4982699d6..d7d68daa7c 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-details.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-details.tsx
@@ -3,7 +3,7 @@ import { t } from 'i18next';
 import { RefreshIcon } from '@/shared/components/ui/icons';
 import { onlyDarkModeColor } from '@/shared/styles/dark-color-palette';
 import { useColorMode } from '@/shared/contexts/color-mode';
-import { type HCaptchaUserStatsSuccess } from '../hooks/use-hcaptcha-user-stats';
+import { type HCaptchaUserStatsSuccess } from '../types';
 
 export function UserStatsDetails({
   stats,
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-drawer.tsx b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-drawer.tsx
index de0f0c4f19..1551856712 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-drawer.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/components/user-stats-drawer.tsx
@@ -6,7 +6,8 @@ import { t } from 'i18next';
 import { Loader } from '@/shared/components/ui/loader';
 import { Alert } from '@/shared/components/ui/alert';
 import { getErrorMessageForError } from '@/shared/errors';
-import { type HCaptchaUserStatsSuccess, useHCaptchaUserStats } from '../hooks';
+import { type HCaptchaUserStatsSuccess } from '../types';
+import { useHCaptchaUserStats } from '../hooks';
 import { UserStatsDetails } from './user-stats-details';
 
 export interface UserStatsDrawerNavigationProps {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/enable-hcaptcha-labeling.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/enable-hcaptcha-labeling.ts
index 2d7cf8074e..7f0e3a5e62 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/enable-hcaptcha-labeling.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/enable-hcaptcha-labeling.ts
@@ -1,19 +1,8 @@
-/* eslint-disable camelcase -- ...*/
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
-import { z } from 'zod';
 import { routerPaths } from '@/router/router-paths';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useAccessTokenRefresh } from '@/api/hooks/use-access-token-refresh';
-
-const enableHCaptchaLabelingSuccessSchema = z.object({
-  site_key: z.string(),
-});
-
-export type EnableHCaptchaLabelingSuccessResponse = z.infer<
-  typeof enableHCaptchaLabelingSuccessSchema
->;
+import * as hCaptchaLabelingService from '../services/hcaptcha-labeling.service';
 
 export function useEnableHCaptchaLabelingMutation() {
   const queryClient = useQueryClient();
@@ -21,15 +10,10 @@ export function useEnableHCaptchaLabelingMutation() {
   const { refreshAccessTokenAsync } = useAccessTokenRefresh();
   const mutation = useMutation({
     mutationFn: async () => {
-      const result = await apiClient(
-        apiPaths.worker.enableHCaptchaLabeling.path,
-        {
-          successSchema: enableHCaptchaLabelingSuccessSchema,
-          authenticated: true,
-          options: { method: 'POST' },
-        }
-      );
+      const result = await hCaptchaLabelingService.enableHCaptchaLabeling();
+
       await refreshAccessTokenAsync({ authType: 'web2' });
+
       return result;
     },
     onSuccess: async () => {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-daily-hmt-spent.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-daily-hmt-spent.ts
index c3b748a676..50bb0fd7be 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-daily-hmt-spent.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-daily-hmt-spent.ts
@@ -1,25 +1,10 @@
-import { z } from 'zod';
 import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-
-const dailyHmtSpentSchema = z.object({
-  spend: z.number(),
-});
-
-type DailyHmtSpentResponse = z.infer<typeof dailyHmtSpentSchema>;
-
-async function fetchDailyHmtSpent(): Promise<DailyHmtSpentResponse> {
-  return apiClient(apiPaths.worker.dailyHmtSpend.path, {
-    successSchema: dailyHmtSpentSchema,
-    authenticated: true,
-    options: { method: 'GET' },
-  });
-}
+import * as hCaptchaLabelingService from '../services/hcaptcha-labeling.service';
+import { type DailyHmtSpentResponse } from '../types';
 
 export function useDailyHmtSpent() {
   return useQuery<DailyHmtSpentResponse>({
     queryKey: ['dailyHmtSpent'],
-    queryFn: fetchDailyHmtSpent,
+    queryFn: async () => hCaptchaLabelingService.getDailyHmtSpent(),
   });
 }
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-hcaptcha-user-stats.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-hcaptcha-user-stats.ts
index 96b4ae996a..8598c89fc6 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-hcaptcha-user-stats.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-hcaptcha-user-stats.ts
@@ -1,41 +1,9 @@
-import { z } from 'zod';
 import { useQuery } from '@tanstack/react-query';
-import { apiPaths } from '@/api/api-paths';
-import { apiClient } from '@/api/api-client';
-
-const hcaptchaUserStatsSchema = z.object({
-  balance: z.object({
-    available: z.number(),
-    estimated: z.number(),
-    recent: z.number(),
-    total: z.number(),
-  }),
-  served: z.number(),
-  solved: z.number(),
-  verified: z.number(),
-  currentDateStats: z.object({
-    // eslint-disable-next-line camelcase
-    billing_units: z.number(),
-    bypass: z.number(),
-    served: z.number(),
-    solved: z.number(),
-  }),
-  currentEarningsStats: z.number(),
-});
-
-export type HCaptchaUserStatsSuccess = z.infer<typeof hcaptchaUserStatsSchema>;
-
-async function getHCaptchaUsersStats() {
-  return apiClient(apiPaths.worker.hCaptchaUserStats.path, {
-    authenticated: true,
-    successSchema: hcaptchaUserStatsSchema,
-    options: { method: 'GET' },
-  });
-}
+import * as hCaptchaLabelingService from '../services/hcaptcha-labeling.service';
 
 export function useHCaptchaUserStats() {
   return useQuery({
-    queryFn: getHCaptchaUsersStats,
+    queryFn: async () => hCaptchaLabelingService.getHCaptchaUserStats(),
     queryKey: ['getHCaptchaUsersStats'],
   });
 }
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-solve-hcaptcha-mutation.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-solve-hcaptcha-mutation.ts
index 11cef7917c..06c402810f 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-solve-hcaptcha-mutation.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/hooks/use-solve-hcaptcha-mutation.ts
@@ -1,16 +1,7 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { z } from 'zod';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import type { ResponseError } from '@/shared/types/global.type';
-
-function solveHCaptcha({ token }: { token: string }) {
-  return apiClient(apiPaths.worker.verifyHCaptchaLabeling.path, {
-    successSchema: z.unknown(),
-    authenticated: true,
-    options: { method: 'POST', body: JSON.stringify({ token }) },
-  });
-}
+import * as hCaptchaLabelingService from '../services/hcaptcha-labeling.service';
+import { type VerifyHCaptchaLabelingBody } from '../types';
 
 export function useSolveHCaptchaMutation(callbacks?: {
   onSuccess?: (() => void) | (() => Promise<void>);
@@ -21,7 +12,8 @@ export function useSolveHCaptchaMutation(callbacks?: {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: solveHCaptcha,
+    mutationFn: async (data: VerifyHCaptchaLabelingBody) =>
+      hCaptchaLabelingService.verifyHCaptchaLabeling(data),
     onSuccess: async () => {
       if (callbacks?.onSuccess) {
         await callbacks.onSuccess();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/schemas.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/schemas.ts
new file mode 100644
index 0000000000..24d30cceb9
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/schemas.ts
@@ -0,0 +1,29 @@
+/* eslint-disable camelcase */
+import { z } from 'zod';
+
+export const enableHCaptchaLabelingResponseSchema = z.object({
+  site_key: z.string(),
+});
+
+export const dailyHmtSpentResponseSchema = z.object({
+  spend: z.number(),
+});
+
+export const hcaptchaUserStatsResponseSchema = z.object({
+  balance: z.object({
+    available: z.number(),
+    estimated: z.number(),
+    recent: z.number(),
+    total: z.number(),
+  }),
+  served: z.number(),
+  solved: z.number(),
+  verified: z.number(),
+  currentDateStats: z.object({
+    billing_units: z.number(),
+    bypass: z.number(),
+    served: z.number(),
+    solved: z.number(),
+  }),
+  currentEarningsStats: z.number(),
+});
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/services/hcaptcha-labeling.service.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/services/hcaptcha-labeling.service.ts
new file mode 100644
index 0000000000..6dde6e306d
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/services/hcaptcha-labeling.service.ts
@@ -0,0 +1,93 @@
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+import {
+  enableHCaptchaLabelingResponseSchema,
+  hcaptchaUserStatsResponseSchema,
+  dailyHmtSpentResponseSchema,
+} from '../schemas';
+import {
+  type EnableHCaptchaLabelingSuccessResponse,
+  type HCaptchaUserStatsSuccess,
+  type DailyHmtSpentResponse,
+  type VerifyHCaptchaLabelingBody,
+} from '../types';
+
+const apiPaths = {
+  enableHCaptchaLabeling: '/labeling/h-captcha/enable',
+  verifyHCaptchaLabeling: '/labeling/h-captcha/verify',
+  hCaptchaUserStats: '/labeling/h-captcha/user-stats',
+  dailyHmtSpend: '/labeling/h-captcha/daily-hmt-spent',
+};
+
+async function enableHCaptchaLabeling() {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.post<EnableHCaptchaLabelingSuccessResponse>(
+        apiPaths.enableHCaptchaLabeling,
+        {
+          successSchema: enableHCaptchaLabelingResponseSchema,
+        }
+      );
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to enable hCaptcha labeling');
+  }
+}
+
+async function verifyHCaptchaLabeling(data: VerifyHCaptchaLabelingBody) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.verifyHCaptchaLabeling, {
+      body: { ...data },
+    });
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to verify hCaptcha labeling');
+  }
+}
+
+async function getHCaptchaUserStats() {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.get<HCaptchaUserStatsSuccess>(
+        apiPaths.hCaptchaUserStats,
+        {
+          successSchema: hcaptchaUserStatsResponseSchema,
+        }
+      );
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to get hCaptcha user stats');
+  }
+}
+
+async function getDailyHmtSpent() {
+  try {
+    const result = await authorizedHumanAppApiClient.get<DailyHmtSpentResponse>(
+      apiPaths.dailyHmtSpend,
+      {
+        successSchema: dailyHmtSpentResponseSchema,
+      }
+    );
+
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to get daily HMT spent');
+  }
+}
+
+export {
+  enableHCaptchaLabeling,
+  verifyHCaptchaLabeling,
+  getHCaptchaUserStats,
+  getDailyHmtSpent,
+};
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/types.ts b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/types.ts
new file mode 100644
index 0000000000..04cd71bc38
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/hcaptcha-labeling/types.ts
@@ -0,0 +1,20 @@
+import { type z } from 'zod';
+import {
+  type enableHCaptchaLabelingResponseSchema,
+  type dailyHmtSpentResponseSchema,
+  type hcaptchaUserStatsResponseSchema,
+} from './schemas';
+
+export type EnableHCaptchaLabelingSuccessResponse = z.infer<
+  typeof enableHCaptchaLabelingResponseSchema
+>;
+
+export type DailyHmtSpentResponse = z.infer<typeof dailyHmtSpentResponseSchema>;
+
+export type HCaptchaUserStatsSuccess = z.infer<
+  typeof hcaptchaUserStatsResponseSchema
+>;
+
+export interface VerifyHCaptchaLabelingBody {
+  token: string;
+}
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hooks/use-get-oracles.ts b/packages/apps/human-app/frontend/src/modules/worker/hooks/use-get-oracles.ts
index f15e55945d..345439d159 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hooks/use-get-oracles.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hooks/use-get-oracles.ts
@@ -1,102 +1,12 @@
-/* eslint-disable camelcase -- ..*/
-import { z } from 'zod';
 import { useQuery } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-import { stringifyUrlQueryObject } from '@/shared/helpers/transfomers';
-import { env } from '@/shared/env';
-import { MainnetChains, TestnetChains } from '@/modules/smart-contracts/chains';
 import { useJobsTypesOraclesFilterStore } from '../jobs/hooks';
-
-const OracleSchema = z.object({
-  address: z.string(),
-  chainId: z.number(),
-  role: z.string(),
-  url: z.string(),
-  jobTypes: z.array(z.string()),
-  registrationNeeded: z.boolean().optional().nullable(),
-  registrationInstructions: z.string().optional().nullable(),
-});
-
-const OraclesDiscoverySuccessSchema = z.array(OracleSchema);
-
-export type Oracle = z.infer<typeof OracleSchema> & {
-  name: string;
-};
-
-const OracleNameToUrls = {
-  CVAT: [
-    'https://stg-exchange-oracle.humanprotocol.org',
-    'https://exchange-oracle.humanprotocol.org',
-  ],
-  Fortune: ['https://stg-fortune-exchange-oracle-server.humanprotocol.org'],
-} as const;
-
-const oracleUrlToNameMap = new Map<string, string>();
-for (const [oracleName, oracleUrls] of Object.entries(OracleNameToUrls)) {
-  for (const oracleUrl of oracleUrls) {
-    oracleUrlToNameMap.set(oracleUrl, oracleName);
-  }
-}
-
-const isTestnet = env.VITE_NETWORK === 'testnet';
-
-const H_CAPTCHA_ORACLE: Oracle = {
-  address: env.VITE_H_CAPTCHA_ORACLE_ADDRESS,
-  chainId: isTestnet ? TestnetChains[0].chainId : MainnetChains[0].chainId,
-  jobTypes: env.VITE_H_CAPTCHA_ORACLE_TASK_TYPES,
-  role: env.VITE_H_CAPTCHA_ORACLE_ROLE,
-  url: env.VITE_H_CAPTCHA_ORACLE_ANNOTATION_TOOL,
-  name: 'hCaptcha',
-  registrationNeeded: false,
-};
-
-async function getOracles({
-  selected_job_types,
-  signal,
-}: {
-  selected_job_types: string[];
-  signal: AbortSignal;
-}) {
-  let oracles: Oracle[] = [];
-  if (
-    selected_job_types.length === 0 ||
-    selected_job_types.some((selected_job_type) =>
-      H_CAPTCHA_ORACLE.jobTypes.includes(selected_job_type)
-    )
-  ) {
-    oracles.push(H_CAPTCHA_ORACLE);
-  }
-
-  if (env.VITE_FEATURE_FLAG_JOBS_DISCOVERY) {
-    const queryParams = selected_job_types.length
-      ? `?${stringifyUrlQueryObject({ selected_job_types })}`
-      : '';
-
-    const results = await apiClient(
-      `${apiPaths.worker.oracles.path}${queryParams}`,
-      {
-        successSchema: OraclesDiscoverySuccessSchema,
-        options: { method: 'GET' },
-      },
-      signal
-    );
-
-    oracles = oracles.concat(
-      results.map((oracle) => ({
-        ...oracle,
-        name: oracleUrlToNameMap.get(oracle.url) ?? '',
-      }))
-    );
-  }
-
-  return oracles;
-}
+import * as oraclesService from '../services/oracles.service';
 
 export function useGetOracles() {
-  const { selected_job_types } = useJobsTypesOraclesFilterStore();
+  const { selectedJobTypes } = useJobsTypesOraclesFilterStore();
+
   return useQuery({
-    queryFn: ({ signal }) => getOracles({ selected_job_types, signal }),
-    queryKey: ['oracles', selected_job_types],
+    queryFn: async () => oraclesService.getOracles(selectedJobTypes),
+    queryKey: ['oracles', selectedJobTypes],
   });
 }
diff --git a/packages/apps/human-app/frontend/src/modules/worker/hooks/use-register-address.ts b/packages/apps/human-app/frontend/src/modules/worker/hooks/use-register-address.ts
index aac4236781..1ce85f9e5e 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/hooks/use-register-address.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/hooks/use-register-address.ts
@@ -1,60 +1,34 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { t } from 'i18next';
-import { z } from 'zod';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { useAuthenticatedUser } from '@/modules/auth/hooks/use-authenticated-user';
 import { useAccessTokenRefresh } from '@/api/hooks/use-access-token-refresh';
-import {
-  PrepareSignatureType,
-  prepareSignature,
-} from '@/api/hooks/use-prepare-signature';
 import type { ResponseError } from '@/shared/types/global.type';
 import { useWalletConnect } from '@/shared/contexts/wallet-connect';
+import { usePrepareSignature } from '@/shared/hooks';
+import { PrepareSignatureType } from '@/shared/services/signature.service';
+import * as profileService from '../profile/services/profile.service';
 
 interface RegisterAddressCallbacks {
   onSuccess?: () => void | Promise<void>;
   onError?: (error: ResponseError) => void | Promise<void>;
 }
 
-interface RegisterAddressParams {
-  address: string;
-  signature: string;
-}
-
-const RegisterAddressSuccessSchema = z.unknown();
-
-const registerAddressRequest = async (
-  params: RegisterAddressParams
-): Promise<unknown> => {
-  return apiClient(apiPaths.worker.registerAddress.path, {
-    authenticated: true,
-    withAuthRetry: apiPaths.worker.registerAddress.withAuthRetry,
-    successSchema: RegisterAddressSuccessSchema,
-    options: {
-      method: 'POST',
-      body: JSON.stringify(params),
-    },
-  });
-};
-
 function useRegisterAddressMutation(callbacks?: RegisterAddressCallbacks) {
   const queryClient = useQueryClient();
-  const { user } = useAuthenticatedUser();
+  const { user, updateUserData } = useAuthenticatedUser();
   const { refreshAccessTokenAsync } = useAccessTokenRefresh();
-  const { address, signMessage } = useWalletConnect();
+  const { address, chainId, signMessage } = useWalletConnect();
+  const { prepareSignature } = usePrepareSignature(
+    PrepareSignatureType.REGISTER_ADDRESS
+  );
 
   const mutationFn = async () => {
     if (!address) {
       throw new Error(t('errors.noAddress'));
     }
 
-    const dataToSign = await prepareSignature({
-      address,
-      type: PrepareSignatureType.REGISTER_ADDRESS,
-    });
-
-    const messageToSign = JSON.stringify(dataToSign);
+    const data = await prepareSignature();
+    const messageToSign = JSON.stringify(data);
     const signature = await signMessage(messageToSign);
 
     if (!signature) {
@@ -63,8 +37,12 @@ function useRegisterAddressMutation(callbacks?: RegisterAddressCallbacks) {
 
     // wallet address is part of the JWT payload
     // so we need to refresh the token after the address is registered
-    await registerAddressRequest({ address, signature });
+    await profileService.registerAddress({ address, chainId, signature });
     await refreshAccessTokenAsync({ authType: 'web2' });
+    updateUserData({
+      // eslint-disable-next-line camelcase
+      wallet_address: address,
+    });
   };
 
   const onSuccess = async () => {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-desktop.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-desktop.tsx
index 7111c46d80..712e80b411 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-desktop.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-desktop.tsx
@@ -5,7 +5,7 @@ import {
 import { createTableDarkMode } from '@/shared/styles/create-table-dark-mode';
 import { useColorMode } from '@/shared/contexts/color-mode';
 import { useOraclesTableColumns } from '../hooks/use-oracles-table-columns';
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 
 interface OraclesTableDesktopProps {
   isOraclesDataPending: boolean;
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-item-mobile.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-item-mobile.tsx
index e68f086405..87ead63a17 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-item-mobile.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/components/oracles-table-item-mobile.tsx
@@ -7,7 +7,7 @@ import type { JobType } from '@/modules/smart-contracts/EthKVStore/config';
 import { useColorMode } from '@/shared/contexts/color-mode';
 import { useSelectOracleNavigation } from '../hooks/use-select-oracle-navigation';
 import { EvmAddress } from '../../jobs/components';
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 
 interface OraclesTableItemMobileProps {
   oracle: Oracle;
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.spec.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.spec.ts
index b13736a403..7183909993 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.spec.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { faker } from '@faker-js/faker';
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 import { shouldNavigateToRegistration } from './should-navigate-to-registration';
 
 describe('shouldNavigateToRegistration Helper', () => {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.ts
index 4390786d84..964fa16590 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/helpers/should-navigate-to-registration.ts
@@ -1,4 +1,4 @@
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 
 interface RegistrationResult {
   oracle_addresses: string[];
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-get-registration-data-oracles.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-get-registration-data-oracles.ts
index cadcceaa27..f1ef7a7554 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-get-registration-data-oracles.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-get-registration-data-oracles.ts
@@ -1,24 +1,9 @@
-/* eslint-disable camelcase */
 import { useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-
-const RegisteredOraclesSuccessResponseSchema = z.object({
-  oracle_addresses: z.array(z.string()),
-});
-
-async function getRegistrationDataInOracles() {
-  return apiClient(apiPaths.worker.registrationInExchangeOracle.path, {
-    authenticated: true,
-    successSchema: RegisteredOraclesSuccessResponseSchema,
-    options: { method: 'GET' },
-  });
-}
+import * as jobsDiscoveryService from '../services/jobs-discovery.service';
 
 export function useGetRegistrationDataInOracles() {
   return useQuery({
-    queryFn: () => getRegistrationDataInOracles(),
+    queryFn: async () => jobsDiscoveryService.getRegistrationDataOracles(),
     queryKey: ['getRegistrationDataInOracles'],
     refetchOnMount: false,
     refetchOnWindowFocus: false,
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-oracles-table-columns.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-oracles-table-columns.tsx
index ab9386d8bc..abd22f746c 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-oracles-table-columns.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-oracles-table-columns.tsx
@@ -6,7 +6,7 @@ import { Chips } from '@/shared/components/ui/chips';
 import { TableButton } from '@/shared/components/ui/table-button';
 import { type JobType } from '@/modules/smart-contracts/EthKVStore/config';
 import { EvmAddress } from '../../jobs/components';
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 import { useSelectOracleNavigation } from './use-select-oracle-navigation';
 
 export const useOraclesTableColumns = (): MRT_ColumnDef<Oracle>[] => {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-select-oracle-navigation.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-select-oracle-navigation.ts
index 48a39887e8..1c81650c57 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-select-oracle-navigation.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/hooks/use-select-oracle-navigation.ts
@@ -3,7 +3,7 @@ import { useCallback, useMemo } from 'react';
 import { useAuthenticatedUser } from '@/modules/auth/hooks/use-authenticated-user';
 import { routerPaths } from '@/router/router-paths';
 import { shouldNavigateToRegistration, isHCaptchaOracle } from '../helpers';
-import { type Oracle } from '../../hooks';
+import { type Oracle } from '../../services/oracles.service';
 import { useGetRegistrationDataInOracles } from './use-get-registration-data-oracles';
 
 const getHCaptchaPagePath = (siteKey: string | null | undefined): string =>
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/services/jobs-discovery.service.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/services/jobs-discovery.service.ts
new file mode 100644
index 0000000000..119c0cf689
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs-discovery/services/jobs-discovery.service.ts
@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+
+const apiPaths = {
+  registrationInExchangeOracle: '/exchange-oracle-registration',
+};
+
+const registeredOraclesSuccessResponseSchema = z.object({
+  // eslint-disable-next-line camelcase
+  oracle_addresses: z.array(z.string()),
+});
+
+type RegisteredOraclesSuccessResponse = z.infer<
+  typeof registeredOraclesSuccessResponseSchema
+>;
+
+async function getRegistrationDataOracles() {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.get<RegisteredOraclesSuccessResponse>(
+        apiPaths.registrationInExchangeOracle,
+        {
+          successSchema: registeredOraclesSuccessResponseSchema,
+        }
+      );
+
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to get oracle registration data.');
+  }
+}
+
+export { getRegistrationDataOracles };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-assign-job-button-mobile.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-assign-job-button-mobile.tsx
index 98cfd6cd51..d49bf27802 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-assign-job-button-mobile.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-assign-job-button-mobile.tsx
@@ -1,10 +1,8 @@
 import { t } from 'i18next';
 import { TableButton } from '@/shared/components/ui/table-button';
 import { useJobsNotifications } from '../../../hooks';
-import {
-  type AssignJobBody,
-  useAssignJobMutation,
-} from '../../hooks/use-assign-job';
+import { useAssignJobMutation } from '../../hooks/use-assign-job';
+import { type AssignJobBody } from '../../../types';
 
 export function AvailableJobsAssignJobButtonMobile({
   assignJobPayload,
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-list-mobile.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-list-mobile.tsx
index 73d12ac553..b25c4e45b9 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-list-mobile.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/components/mobile/available-jobs-list-mobile.tsx
@@ -13,11 +13,9 @@ import { useColorMode } from '@/shared/contexts/color-mode';
 import { getErrorMessageForError } from '@/shared/errors';
 import { useCombinePages } from '@/shared/hooks';
 import { useJobsFilterStore } from '../../../hooks';
-import {
-  useInifiniteGetAvailableJobsData,
-  type AvailableJob,
-} from '../../hooks/use-get-available-jobs-data';
+import { useInifiniteGetAvailableJobsData } from '../../hooks/use-get-available-jobs-data';
 import { EvmAddress, RewardAmount } from '../../../components';
+import { type AvailableJob } from '../../../types';
 import { AvailableJobsAssignJobButtonMobile } from './available-jobs-assign-job-button-mobile';
 
 export function AvailableJobsListMobile() {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-assign-job.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-assign-job.ts
index 94ef5a5805..68e11c9aae 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-assign-job.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-assign-job.ts
@@ -4,23 +4,10 @@ import {
   useMutation,
   useQueryClient,
 } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
+import * as jobsService from '../../services/jobs.service';
+import { type AssignJobBody } from '../../types';
 
-export interface AssignJobBody {
-  escrow_address: string;
-  chain_id: number;
-}
-
-const AssignJobBodySuccessResponseSchema = z.unknown();
-
-function assignJob(data: AssignJobBody) {
-  return apiClient(apiPaths.worker.assignJob.path, {
-    authenticated: true,
-    successSchema: AssignJobBodySuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+export const AssignJobBodySuccessResponseSchema = z.unknown();
 
 export function useAssignJobMutation(
   callbacks?: {
@@ -32,7 +19,7 @@ export function useAssignJobMutation(
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: assignJob,
+    mutationFn: async (data: AssignJobBody) => jobsService.assignJob(data),
     onSuccess: async () => {
       await queryClient.invalidateQueries();
       callbacks?.onSuccess();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-available-jobs-filter-modal.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-available-jobs-filter-modal.tsx
index dfcaaf9de4..f90e919961 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-available-jobs-filter-modal.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-available-jobs-filter-modal.tsx
@@ -1,6 +1,6 @@
 import { useModal } from '@/shared/contexts/modal-context';
+import { useGetUiConfig } from '@/shared/hooks';
 import { AvailableJobsFilterModal } from '../available-jobs-filter-modal';
-import { useGetUiConfig } from '../../hooks';
 
 export function useAvailableJobsFilterModal() {
   const { openModal, closeModal } = useModal();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-columns.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-columns.tsx
index a47869a1a9..4528ac7992 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-columns.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-columns.tsx
@@ -15,7 +15,7 @@ import {
   AvailableJobsRewardAmountSort,
   AvailableJobsJobTypeFilter,
 } from '../components';
-import { type AvailableJob } from './use-get-available-jobs-data';
+import { type AvailableJob } from '../../types';
 import { useAssignJobMutation } from './use-assign-job';
 
 const COL_SIZE = 100;
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-data.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-data.ts
index 212a919a29..c6fec588e5 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-data.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/available-jobs/hooks/use-get-available-jobs-data.ts
@@ -1,60 +1,19 @@
-/* eslint-disable camelcase -- api response*/
+/* eslint-disable camelcase */
 import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
 import { useParams } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-import { stringifyUrlQueryObject } from '@/shared/helpers/transfomers';
-import { createPaginationSchema } from '@/shared/helpers/pagination';
-import { type JobsFilterStoreProps, useJobsFilterStore } from '../../hooks';
-
-const availableJobSchema = z.object({
-  escrow_address: z.string(),
-  chain_id: z.number(),
-  job_type: z.string(),
-  status: z.string(),
-  job_description: z.string().optional(),
-  reward_amount: z.string().optional(),
-  reward_token: z.string().optional(),
-});
-
-const availableJobsSuccessResponseSchema =
-  createPaginationSchema(availableJobSchema);
-
-export type AvailableJob = z.infer<typeof availableJobSchema>;
-export type AvailableJobsSuccessResponse = z.infer<
-  typeof availableJobsSuccessResponseSchema
->;
-
-type JobTableQueryParams = JobsFilterStoreProps['filterParams'] & {
-  oracle_address: string;
-};
-
-const getAvailableJobsTableData = async (
-  params: JobTableQueryParams,
-  abortSignal: AbortSignal
-) => {
-  const endpoint = `${apiPaths.worker.jobs.path}?${stringifyUrlQueryObject(params)}`;
-
-  return apiClient(
-    endpoint,
-    {
-      authenticated: true,
-      successSchema: availableJobsSuccessResponseSchema,
-      options: { method: 'GET' },
-    },
-    abortSignal
-  );
-};
+import { useJobsFilterStore } from '../../hooks';
+import * as jobsService from '../../services/jobs.service';
+import { type AvailableJobsSuccessResponse } from '../../types';
 
 export function useGetAvailableJobsData() {
   const { filterParams } = useJobsFilterStore();
   const { address: oracle_address } = useParams<{ address: string }>();
-  const dto = { ...filterParams, oracle_address: oracle_address ?? '' };
+  const queryParams = { ...filterParams, oracle_address: oracle_address ?? '' };
 
   return useQuery({
-    queryKey: ['availableJobs', dto],
-    queryFn: ({ signal }) => getAvailableJobsTableData(dto, signal),
+    queryKey: ['availableJobs', queryParams],
+    queryFn: async ({ signal }) =>
+      jobsService.fetchAvailableJobs({ queryParams, signal }),
   });
 }
 
@@ -69,7 +28,8 @@ export function useInifiniteGetAvailableJobsData() {
 
   return useInfiniteQuery<AvailableJobsSuccessResponse>({
     queryKey: ['availableJobsInfinite', queryParams],
-    queryFn: ({ signal }) => getAvailableJobsTableData(queryParams, signal),
+    queryFn: async ({ signal }) =>
+      jobsService.fetchAvailableJobs({ queryParams, signal }),
     initialPageParam: 0,
     getNextPageParam: (lastPage) =>
       lastPage.total_pages - 1 <= lastPage.page ? undefined : lastPage.page,
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/components/escrow-address-search-form.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/components/escrow-address-search-form.tsx
index 6d288d9be9..77cebcfca9 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/components/escrow-address-search-form.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/components/escrow-address-search-form.tsx
@@ -3,7 +3,7 @@ import InputAdornment from '@mui/material/InputAdornment';
 import { FormProvider, useForm } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
 import { z } from 'zod';
-import { useEffect } from 'react';
+import { useEffect, useMemo } from 'react';
 import Grid from '@mui/material/Grid';
 import debounce from 'lodash/debounce';
 import { useColorMode } from '@/shared/contexts/color-mode';
@@ -24,7 +24,7 @@ export function EscrowAddressSearchForm({
   placeholder,
   updater,
   fullWidth = false,
-}: SearchFormProps) {
+}: Readonly<SearchFormProps>) {
   const isMobile = useIsMobile();
   const { colorPalette } = useColorMode();
   const methods = useForm({
@@ -36,24 +36,33 @@ export function EscrowAddressSearchForm({
     ),
   });
 
-  const debouncedUpdater = debounce((value: string) => {
-    updater(value);
-  }, 500);
+  const debouncedUpdater = useMemo(
+    () =>
+      debounce(async (value: string) => {
+        const isValid = await methods.trigger('searchValue');
+        if (isValid) {
+          updater(value);
+        }
+      }, 500),
+    [updater, methods]
+  );
 
   useEffect(() => {
-    const subscription = methods.watch(() => {
-      void methods.trigger('searchValue').then((isSearchValueValid) => {
-        const inputValue = methods.getValues('searchValue');
-        if (isSearchValueValid) {
-          debouncedUpdater(inputValue);
-        }
-      });
-    });
+    return () => {
+      debouncedUpdater.cancel();
+    };
+  }, [debouncedUpdater]);
 
+  useEffect(() => {
+    const subscription = methods.watch((value, { name }) => {
+      if (name === 'searchValue') {
+        void debouncedUpdater(value.searchValue ?? '');
+      }
+    });
     return () => {
       subscription.unsubscribe();
     };
-  }, [debouncedUpdater, methods, updater]);
+  }, [debouncedUpdater, methods]);
 
   return (
     <Grid
@@ -82,6 +91,9 @@ export function EscrowAddressSearchForm({
             width: fullWidth ? '100%' : '362px',
             margin: fullWidth ? '0' : '1rem',
           }}
+          onBlur={() => {
+            void methods.trigger('searchValue');
+          }}
         />
       </FormProvider>
     </Grid>
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/components/my-jobs-table-actions.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/components/my-jobs-table-actions.tsx
index 3d2d5341ad..5ad4849298 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/components/my-jobs-table-actions.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/components/my-jobs-table-actions.tsx
@@ -2,9 +2,9 @@
 import { Link, useParams } from 'react-router-dom';
 import { useTranslation } from 'react-i18next';
 import { TableButton } from '@/shared/components/ui/table-button';
-import { useRejectTaskMutation } from '../my-jobs/hooks';
+import { useResignJobMutation } from '../my-jobs/hooks';
 import { MyJobStatus } from '../types';
-import { type MyJob } from '../my-jobs/schemas';
+import { type MyJob } from '../schemas';
 import { RejectButton } from './reject-button';
 
 interface MyJobsTableRejectActionProps {
@@ -16,7 +16,7 @@ export function MyJobsTableActions({
 }: Readonly<MyJobsTableRejectActionProps>) {
   const { t } = useTranslation();
   const { mutate: rejectTaskMutation, isPending: isRejectPending } =
-    useRejectTaskMutation();
+    useResignJobMutation();
   const { address: oracleAddress } = useParams<{ address: string }>();
   const buttonDisabled = job.status !== MyJobStatus.ACTIVE || isRejectPending;
 
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/index.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/index.ts
index d0d0034f9d..b977266dbe 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/index.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/index.ts
@@ -3,5 +3,4 @@ export * from './use-jobs-notifications';
 export * from './use-job-types-oracles-table';
 export * from './use-jobs-filter-store';
 export * from './use-my-jobs-filter-store';
-export * from './use-get-ui-config';
 export * from './use-get-my-jobs-data';
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-my-jobs-data.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-my-jobs-data.ts
index f293ebb507..b9bd203a3e 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-my-jobs-data.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-my-jobs-data.ts
@@ -1,56 +1,46 @@
 /* eslint-disable camelcase */
 import { useInfiniteQuery, useQuery } from '@tanstack/react-query';
 import { useParams } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-import { stringifyUrlQueryObject } from '@/shared/helpers/transfomers';
-import { myJobsSuccessResponseSchema } from '../my-jobs/schemas';
+import * as jobsService from '../services/jobs.service';
+import { type MyJobPaginationResponse } from '../schemas';
 import {
   useMyJobsFilterStore,
   type MyJobsFilterStoreProps,
 } from './use-my-jobs-filter-store';
 
-type GetMyJobTableDataDto = MyJobsFilterStoreProps['filterParams'] & {
+type OracleParams = MyJobsFilterStoreProps['filterParams'] & {
   oracle_address: string;
 };
 
-const getMyJobsTableData = async (
-  dto: GetMyJobTableDataDto,
-  abortSignal: AbortSignal
-) => {
-  return apiClient(
-    `${apiPaths.worker.myJobs.path}?${stringifyUrlQueryObject({ ...dto })}`,
-    {
-      authenticated: true,
-      successSchema: myJobsSuccessResponseSchema,
-      options: {
-        method: 'GET',
-      },
-    },
-    abortSignal
-  );
-};
-
 export function useGetMyJobsData() {
   const { filterParams } = useMyJobsFilterStore();
   const { address } = useParams<{ address: string }>();
-  const dto = { ...filterParams, oracle_address: address ?? '' };
+  const queryParams: OracleParams = {
+    ...filterParams,
+    oracle_address: address ?? '',
+  };
+
   return useQuery({
-    queryKey: ['myJobs', dto],
-    queryFn: ({ signal }) => getMyJobsTableData(dto, signal),
+    queryKey: ['myJobs', queryParams],
+    queryFn: async ({ signal }) =>
+      jobsService.fetchMyJobs({ queryParams, signal }),
   });
 }
 
 export function useInfiniteGetMyJobsData() {
   const { filterParams } = useMyJobsFilterStore();
   const { address } = useParams<{ address: string }>();
-  const dto = { ...filterParams, oracle_address: address ?? '' };
+  const queryParams: OracleParams = {
+    ...filterParams,
+    oracle_address: address ?? '',
+  };
 
   return useInfiniteQuery({
     initialPageParam: 0,
-    queryKey: ['myJobsInfinite', dto],
-    queryFn: ({ signal }) => getMyJobsTableData(dto, signal),
-    getNextPageParam: (pageParams) => {
+    queryKey: ['myJobsInfinite', queryParams],
+    queryFn: async ({ signal }) =>
+      jobsService.fetchMyJobs({ queryParams, signal }),
+    getNextPageParam: (pageParams: MyJobPaginationResponse) => {
       return pageParams.total_pages - 1 <= pageParams.page
         ? undefined
         : pageParams.page;
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-ui-config.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-ui-config.ts
deleted file mode 100644
index 29c628ded6..0000000000
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-get-ui-config.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { z } from 'zod';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-
-const uiConfigSchema = z.object({
-  chainIdsEnabled: z.array(z.number()),
-});
-
-export type UiConfig = z.infer<typeof uiConfigSchema>;
-
-const getUiConfig = async (): Promise<UiConfig> => {
-  const response = await apiClient(apiPaths.worker.uiConfig.path, {
-    successSchema: uiConfigSchema,
-    options: {
-      method: 'GET',
-    },
-  });
-  return response;
-};
-
-export function useGetUiConfig() {
-  return useQuery({
-    queryKey: ['ui-config'],
-    queryFn: getUiConfig,
-    staleTime: Infinity,
-  });
-}
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-job-types-oracles-table.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-job-types-oracles-table.tsx
index 60943b3ecf..7dadc09e9f 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-job-types-oracles-table.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/hooks/use-job-types-oracles-table.tsx
@@ -1,18 +1,17 @@
-/* eslint-disable camelcase -- ... */
 import { create } from 'zustand';
 
 export interface JobsTypesOraclesFilterStore {
-  selected_job_types: string[];
+  selectedJobTypes: string[];
   selectJobType: (jobType: string[]) => void;
 }
 
 export const useJobsTypesOraclesFilterStore =
   create<JobsTypesOraclesFilterStore>((set) => ({
-    selected_job_types: [],
+    selectedJobTypes: [],
     selectJobType: (jobTypes: string[]) => {
       set((state) => ({
         ...state,
-        selected_job_types: jobTypes,
+        selectedJobTypes: jobTypes,
       }));
     },
   }));
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/jobs.page.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/jobs.page.tsx
index d16f9d00ae..d0c8f3cfa4 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/jobs.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/jobs.page.tsx
@@ -8,9 +8,9 @@ import { useIsMobile } from '@/shared/hooks/use-is-mobile';
 import { useColorMode } from '@/shared/contexts/color-mode';
 import { NoRecords } from '@/shared/components/ui/no-records';
 import { PageCardLoader } from '@/shared/components/ui/page-card';
+import { useGetUiConfig } from '@/shared/hooks';
 import { useGetOracles } from '../hooks';
 import { useGetOraclesNotifications } from '../hooks/use-get-oracles-notifications';
-import { useGetUiConfig } from './hooks';
 import { TabPanel } from './components';
 import { AvailableJobsView } from './available-jobs';
 import { MyJobsView } from './my-jobs/my-jobs-view';
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/columns.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/columns.tsx
index a76d57871c..4d7aa02284 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/columns.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/columns.tsx
@@ -14,7 +14,7 @@ import {
   RewardAmount,
   MyJobsTableActions,
 } from '../../../components';
-import { type MyJob } from '../../schemas';
+import { type MyJob } from '../../../schemas';
 import { StatusChip } from './status-chip';
 import { MyJobsExpiresAtSort } from './my-jobs-expires-at-sort';
 import { MyJobsJobTypeFilter } from './my-jobs-job-type-filter';
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/my-jobs-table.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/my-jobs-table.tsx
index cee3a0ec9f..eaff8fbd3c 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/my-jobs-table.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/my-jobs-table.tsx
@@ -10,7 +10,7 @@ import { useColorMode } from '@/shared/contexts/color-mode';
 import { createTableDarkMode } from '@/shared/styles/create-table-dark-mode';
 import { EscrowAddressSearchForm } from '../../../components';
 import { useGetMyJobsData, useMyJobsFilterStore } from '../../../hooks';
-import { useRefreshTasksMutation } from '../../hooks';
+import { useRefreshJobsMutation } from '../../hooks';
 import { getColumnsDefinition } from './columns';
 
 interface MyJobsTableProps {
@@ -33,7 +33,7 @@ export function MyJobsTable({ chainIdsEnabled }: Readonly<MyJobsTableProps>) {
   );
 
   const { mutate: refreshTasksMutation, isPending: isRefreshTasksPending } =
-    useRefreshTasksMutation();
+    useRefreshJobsMutation();
   const { address: oracle_address } = useParams<{ address: string }>();
 
   const [paginationState, setPaginationState] = useState({
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/status-chip.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/status-chip.tsx
index dc64a3abfa..cad5e86949 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/status-chip.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/desktop/status-chip.tsx
@@ -3,7 +3,7 @@ import Typography from '@mui/material/Typography';
 import { colorPalette as lightModeColorPalette } from '@/shared/styles/color-palette';
 import { useColorMode } from '@/shared/contexts/color-mode';
 import { getChipStatusColor } from '../../utils';
-import { type MyJob } from '../../schemas';
+import { type MyJob } from '../../../schemas';
 
 export function StatusChip({ status }: Readonly<{ status: MyJob['status'] }>) {
   const { colorPalette } = useColorMode();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/mobile/my-jobs-list-mobile.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/mobile/my-jobs-list-mobile.tsx
index 559cd39e51..0ece3f62c3 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/mobile/my-jobs-list-mobile.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/components/mobile/my-jobs-list-mobile.tsx
@@ -27,9 +27,9 @@ import {
   useJobsFilterStore,
   useInfiniteGetMyJobsData,
 } from '../../../hooks';
-import { useRefreshTasksMutation } from '../../hooks';
+import { useRefreshJobsMutation } from '../../hooks';
 import { getChipStatusColor } from '../../utils';
-import { type MyJob } from '../../schemas';
+import { type MyJob } from '../../../schemas';
 import { useMyJobFilterModal } from '../../hooks/use-my-jobs-filter-modal';
 
 export function MyJobsListMobile() {
@@ -48,7 +48,7 @@ export function MyJobsListMobile() {
   } = useInfiniteGetMyJobsData();
 
   const { mutate: refreshTasksMutation, isPending: isRefreshTasksPending } =
-    useRefreshTasksMutation();
+    useRefreshJobsMutation();
   const { setSearchEscrowAddress } = useJobsFilterStore();
   const { address: oracle_address } = useParams<{ address: string }>();
 
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/index.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/index.ts
index d4e2db7bde..6c74530371 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/index.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/index.ts
@@ -1,2 +1,2 @@
-export * from './refresh-tasks';
-export * from './reject-task';
+export * from './use-refresh-jobs';
+export * from './use-resign-job';
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-my-jobs-filter-modal.tsx b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-my-jobs-filter-modal.tsx
index b8be16ffb6..40a0c9c1be 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-my-jobs-filter-modal.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-my-jobs-filter-modal.tsx
@@ -1,5 +1,5 @@
 import { useModal } from '@/shared/contexts/modal-context';
-import { useGetUiConfig } from '../../hooks';
+import { useGetUiConfig } from '@/shared/hooks';
 import { MyJobsFilterModal } from '../components/mobile/my-jobs-filter-modal';
 
 export function useMyJobFilterModal() {
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/reject-task.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-refresh-jobs.ts
similarity index 57%
rename from packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/reject-task.ts
rename to packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-refresh-jobs.ts
index bf5e39679f..812ebb03d3 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/reject-task.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-refresh-jobs.ts
@@ -1,24 +1,18 @@
 import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
+import * as jobsService from '../../services/jobs.service';
+import { type RefreshJobsBody } from '../../types';
 
-function rejectTask(data: { assignment_id: string; oracle_address: string }) {
-  return apiClient(apiPaths.worker.resignJob.path, {
-    successSchema: z.unknown(),
-    authenticated: true,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+export const refreshTasksSchema = z.unknown();
 
-export function useRejectTaskMutation(callbacks?: {
+export function useRefreshJobsMutation(callbacks?: {
   onSuccess?: () => Promise<void>;
   onError?: (error: unknown) => Promise<void>;
 }) {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: rejectTask,
+    mutationFn: async (data: RefreshJobsBody) => jobsService.refreshJobs(data),
     onSuccess: async () => {
       if (callbacks?.onSuccess) {
         void callbacks.onSuccess();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/refresh-tasks.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-resign-job.ts
similarity index 56%
rename from packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/refresh-tasks.ts
rename to packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-resign-job.ts
index 2667d7357d..cc1daa15fd 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/refresh-tasks.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/hooks/use-resign-job.ts
@@ -1,25 +1,18 @@
 import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
+import * as jobsService from '../../services/jobs.service';
+import { type RejectTaskBody } from '../../types';
 
-function refreshTasks(data: { oracle_address: string }) {
-  return apiClient(apiPaths.worker.refreshJob.path, {
-    successSchema: z.unknown(),
-    authenticated: true,
-    withAuthRetry: true,
-    options: { method: 'PUT', body: JSON.stringify(data) },
-  });
-}
+export const rejectTaskSchema = z.unknown();
 
-export function useRefreshTasksMutation(callbacks?: {
+export function useResignJobMutation(callbacks?: {
   onSuccess?: () => Promise<void>;
   onError?: (error: unknown) => Promise<void>;
 }) {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: refreshTasks,
+    mutationFn: async (data: RejectTaskBody) => jobsService.resignJob(data),
     onSuccess: async () => {
       if (callbacks?.onSuccess) {
         void callbacks.onSuccess();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/schemas.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/schemas.ts
similarity index 56%
rename from packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/schemas.ts
rename to packages/apps/human-app/frontend/src/modules/worker/jobs/schemas.ts
index 7801675733..9014426e49 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/my-jobs/schemas.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/schemas.ts
@@ -1,7 +1,7 @@
-/* eslint-disable camelcase -- api response*/
+/* eslint-disable camelcase */
 import { z } from 'zod';
 import { createPaginationSchema } from '@/shared/helpers/pagination';
-import { MyJobStatus, UNKNOWN_JOB_STATUS } from '../types';
+import { MyJobStatus, UNKNOWN_JOB_STATUS } from './types';
 
 const myJobSchema = z.object({
   assignment_id: z.string(),
@@ -25,3 +25,20 @@ const myJobSchema = z.object({
 export const myJobsSuccessResponseSchema = createPaginationSchema(myJobSchema);
 
 export type MyJob = z.infer<typeof myJobSchema>;
+
+export type MyJobPaginationResponse = z.infer<
+  typeof myJobsSuccessResponseSchema
+>;
+
+export const availableJobSchema = z.object({
+  escrow_address: z.string(),
+  chain_id: z.number(),
+  job_type: z.string(),
+  status: z.string(),
+  job_description: z.string().optional(),
+  reward_amount: z.string().optional(),
+  reward_token: z.string().optional(),
+});
+
+export const availableJobsSuccessResponseSchema =
+  createPaginationSchema(availableJobSchema);
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/services/jobs.service.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/services/jobs.service.ts
new file mode 100644
index 0000000000..8abcbb9c0c
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/services/jobs.service.ts
@@ -0,0 +1,105 @@
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+import {
+  availableJobsSuccessResponseSchema,
+  type MyJobPaginationResponse,
+  myJobsSuccessResponseSchema,
+} from '../schemas';
+import {
+  type AssignJobBody,
+  type JobsBody,
+  type RefreshJobsBody,
+  type RejectTaskBody,
+  type AvailableJobsSuccessResponse,
+} from '../types';
+
+const apiPaths = {
+  jobs: '/jobs',
+  myJobs: '/assignment/job',
+  assignJob: '/assignment/job',
+  resignJob: '/assignment/resign-job',
+  refreshJobs: '/assignment/refresh',
+  uiConfig: '/ui-config',
+};
+
+async function fetchAvailableJobs(args: JobsBody) {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.get<AvailableJobsSuccessResponse>(
+        apiPaths.jobs,
+        {
+          queryParams: args.queryParams,
+          successSchema: availableJobsSuccessResponseSchema,
+          abortSignal: args.signal,
+        }
+      );
+
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to get available jobs');
+  }
+}
+
+async function fetchMyJobs(args: JobsBody) {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.get<MyJobPaginationResponse>(
+        apiPaths.myJobs,
+        {
+          queryParams: args.queryParams,
+          successSchema: myJobsSuccessResponseSchema,
+          abortSignal: args.signal,
+        }
+      );
+
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to get my jobs');
+  }
+}
+
+async function assignJob(data: AssignJobBody) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.assignJob, {
+      body: { ...data },
+    });
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to assign job');
+  }
+}
+
+async function resignJob(data: RejectTaskBody) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.resignJob, {
+      body: { ...data },
+    });
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to resign job');
+  }
+}
+
+async function refreshJobs(data: RefreshJobsBody) {
+  try {
+    await authorizedHumanAppApiClient.put(apiPaths.refreshJobs, {
+      body: { ...data },
+    });
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to refresh jobs');
+  }
+}
+
+export { fetchAvailableJobs, fetchMyJobs, assignJob, resignJob, refreshJobs };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/jobs/types.ts b/packages/apps/human-app/frontend/src/modules/worker/jobs/types.ts
index 79e9900eb0..cb6f85f3c4 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/jobs/types.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/jobs/types.ts
@@ -1,3 +1,9 @@
+import { type z } from 'zod';
+import {
+  type availableJobSchema,
+  type availableJobsSuccessResponseSchema,
+} from './schemas';
+
 export enum MyJobStatus {
   ACTIVE = 'ACTIVE',
   CANCELED = 'CANCELED',
@@ -22,3 +28,27 @@ export enum SortDirection {
   ASC = 'asc',
   DESC = 'desc',
 }
+
+export type AvailableJob = z.infer<typeof availableJobSchema>;
+export type AvailableJobsSuccessResponse = z.infer<
+  typeof availableJobsSuccessResponseSchema
+>;
+
+export interface RejectTaskBody {
+  assignment_id: string;
+  oracle_address: string;
+}
+
+export interface JobsBody {
+  queryParams?: Record<string, unknown>;
+  signal?: AbortSignal;
+}
+
+export interface AssignJobBody {
+  escrow_address: string;
+  chain_id: number;
+}
+
+export interface RefreshJobsBody {
+  oracle_address: string;
+}
diff --git a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-exchange-oracle-registration-mutation.ts b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-exchange-oracle-registration-mutation.ts
index 12536bbe94..400fd45f17 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-exchange-oracle-registration-mutation.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-exchange-oracle-registration-mutation.ts
@@ -1,26 +1,13 @@
-import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { type RegistrationInExchangeOracleDto } from '../schema';
-
-const RegistrationInExchangeOracleSuccessResponseSchema = z.unknown();
-
-function registrationInExchangeOracleMutationFn(
-  data: RegistrationInExchangeOracleDto
-) {
-  return apiClient(apiPaths.worker.registrationInExchangeOracle.path, {
-    authenticated: true,
-    successSchema: RegistrationInExchangeOracleSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+import * as oracleRegistrationService from '../services/oracle-registration.service';
 
 export function useExchangeOracleRegistrationMutation() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: registrationInExchangeOracleMutationFn,
+    mutationFn: async (data: RegistrationInExchangeOracleDto) =>
+      oracleRegistrationService.registerInExchangeOracle(data),
     onSuccess: async () => {
       await queryClient.invalidateQueries();
     },
diff --git a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-is-already-registered.ts b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-is-already-registered.ts
index 3d47ea8eaf..c0e43bb95a 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-is-already-registered.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/hooks/use-is-already-registered.ts
@@ -1,11 +1,17 @@
 import { useGetRegistrationDataInOracles } from '../../jobs-discovery';
 
 export const useIsAlreadyRegistered = (address: string | undefined) => {
-  const { data } = useGetRegistrationDataInOracles();
+  const { data, isPending } = useGetRegistrationDataInOracles();
 
   if (!address) {
-    return false;
+    return {
+      registered: false,
+      isPending: false,
+    };
   }
 
-  return (data?.oracle_addresses ?? []).includes(address);
+  return {
+    registered: (data?.oracle_addresses ?? []).includes(address),
+    isPending,
+  };
 };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/registration.page.tsx b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/registration.page.tsx
index 7bed886c9b..e3b708a5bf 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/registration.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/registration.page.tsx
@@ -27,9 +27,9 @@ export function RegistrationPage() {
   const { t } = useTranslation();
   const { address: oracleAddress } = useParams<{ address: string }>();
   const { data, isLoading } = useGetOracles();
-  const isAlreadyRegistered = useIsAlreadyRegistered(oracleAddress);
+  const { registered, isPending } = useIsAlreadyRegistered(oracleAddress);
 
-  if (isLoading) {
+  if (isLoading || isPending) {
     return (
       <Paper sx={styles}>
         <Loader />
@@ -43,7 +43,7 @@ export function RegistrationPage() {
     return <Navigate to={routerPaths.worker.jobsDiscovery} />;
   }
 
-  if (isAlreadyRegistered || !oracleData.registrationNeeded) {
+  if (registered || !oracleData.registrationNeeded) {
     return (
       <Navigate
         to={`${routerPaths.worker.jobs}/${oracleAddress}`}
diff --git a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/schema.ts b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/schema.ts
index 87215513cf..d0e72115ae 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/schema.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/schema.ts
@@ -3,7 +3,7 @@ import { ethers } from 'ethers';
 import { t } from 'i18next';
 import { z } from 'zod';
 
-export const registrationInExchangeOracleDtoSchema = z.object({
+const registrationInExchangeOracleDtoSchema = z.object({
   oracle_address: z
     .string()
     .refine(
diff --git a/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/services/oracle-registration.service.ts b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/services/oracle-registration.service.ts
new file mode 100644
index 0000000000..78a21bfe74
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/oracle-registration/services/oracle-registration.service.ts
@@ -0,0 +1,24 @@
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+import { type RegistrationInExchangeOracleDto } from '../schema';
+
+const apiPaths = {
+  registrationInExchangeOracle: '/exchange-oracle-registration',
+};
+
+async function registerInExchangeOracle(data: RegistrationInExchangeOracleDto) {
+  try {
+    await authorizedHumanAppApiClient.post(
+      apiPaths.registrationInExchangeOracle,
+      {
+        body: { ...data },
+      }
+    );
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to register in exchange oracle');
+  }
+}
+
+export { registerInExchangeOracle };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc-mutation.ts b/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc-mutation.ts
index 4625ad3ff7..85569678d1 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc-mutation.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc-mutation.ts
@@ -1,38 +1,13 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { z } from 'zod';
 import { useAuthenticatedUser } from '@/modules/auth/hooks/use-authenticated-user';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
-import { useAccessTokenRefresh } from '@/api/hooks/use-access-token-refresh';
-
-const kycStartSchema = z.object({
-  url: z.string(),
-});
-
-export type KycStartSuccessSchema = z.infer<typeof kycStartSchema>;
+import * as profileService from '../services/profile.service';
 
 export function useKycStartMutation() {
   const queryClient = useQueryClient();
   const { user } = useAuthenticatedUser();
-  const { refreshAccessTokenAsync } = useAccessTokenRefresh();
-  return useMutation({
-    mutationFn: async () => {
-      try {
-        const result = await apiClient(apiPaths.worker.kycStart.path, {
-          successSchema: kycStartSchema,
-          authenticated: true,
-          withAuthRetry: apiPaths.worker.kycStart.withAuthRetry,
-          options: {
-            method: 'POST',
-          },
-        });
-        return result;
-      } catch (error) {
-        await refreshAccessTokenAsync({ authType: 'web2' });
-        throw error;
-      }
-    },
 
+  return useMutation({
+    mutationFn: async () => profileService.startKyc(),
     onError: () => {
       void queryClient.invalidateQueries();
     },
diff --git a/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc.ts b/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc.ts
index 08c93f14ab..d9c18d6f6c 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/profile/hooks/use-start-kyc.ts
@@ -1,6 +1,6 @@
 import { useEffect, useState, useCallback } from 'react';
 import { useKycErrorNotifications } from '@/modules/worker/hooks/use-kyc-notification';
-import { FetchError } from '@/api/fetcher';
+import { ApiClientError } from '@/api';
 import { useKycStartMutation } from './use-start-kyc-mutation';
 
 export function useStartKyc() {
@@ -21,7 +21,7 @@ export function useStartKyc() {
   useEffect(() => {
     if (kycStartMutationStatus === 'error') {
       if (
-        kycStartMutationError instanceof FetchError &&
+        kycStartMutationError instanceof ApiClientError &&
         kycStartMutationError.status === 400
       ) {
         setIsKYCInProgress(true);
diff --git a/packages/apps/human-app/frontend/src/modules/worker/profile/services/profile.service.ts b/packages/apps/human-app/frontend/src/modules/worker/profile/services/profile.service.ts
new file mode 100644
index 0000000000..ea68f77797
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/profile/services/profile.service.ts
@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+
+const apiPaths = {
+  kycStart: '/kyc/start',
+  signedAddress: '/kyc/on-chain',
+  registerAddress: '/user/register-address',
+};
+
+const kycStartSchema = z.object({
+  url: z.string(),
+});
+
+type KycStartSuccessSchema = z.infer<typeof kycStartSchema>;
+
+async function startKyc() {
+  try {
+    const result =
+      await authorizedHumanAppApiClient.post<KycStartSuccessSchema>(
+        apiPaths.kycStart,
+        {
+          successSchema: kycStartSchema,
+        }
+      );
+    return result;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to start KYC process');
+  }
+}
+
+async function registerAddress(data: {
+  address: string;
+  chainId: number;
+  signature: string;
+}) {
+  try {
+    await authorizedHumanAppApiClient.post(apiPaths.registerAddress, {
+      body: data,
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to register address.');
+  }
+}
+
+export { startKyc, registerAddress };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/reset-password/hooks/reset-password.ts b/packages/apps/human-app/frontend/src/modules/worker/reset-password/hooks/reset-password.ts
index 92a563e027..7da3044c1e 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/reset-password/hooks/reset-password.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/reset-password/hooks/reset-password.ts
@@ -1,51 +1,20 @@
-/* eslint-disable camelcase -- ... */
 import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
-import { t } from 'i18next';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { routerPaths } from '@/router/router-paths';
+import * as passwordService from '../password.service';
+import { type ResetPasswordDto } from '../types';
 
-export const resetPasswordDtoSchema = z
-  .object({
-    password: z
-      .string()
-      .min(8, t('validation.min'))
-      .max(50, t('validation.max', { count: 50 })),
-    confirmPassword: z
-      .string()
-      .min(1, t('validation.required'))
-      .max(50, t('validation.max', { count: 50 })),
-    h_captcha_token: z
-      .string()
-      .min(1, t('validation.captcha'))
-      .default('token'),
-  })
-  .refine(({ password, confirmPassword }) => confirmPassword === password, {
-    message: t('validation.passwordMismatch'),
-    path: ['confirmPassword'],
-  });
-
-export type ResetPasswordDto = z.infer<typeof resetPasswordDtoSchema>;
-
-const ResetPasswordSuccessResponseSchema = z.unknown();
-
-function resetPasswordMutationFn(
-  data: Omit<ResetPasswordDto, 'confirmPassword'> & { token: string }
-) {
-  return apiClient(apiPaths.worker.resetPassword.path, {
-    successSchema: ResetPasswordSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+export const ResetPasswordSuccessResponseSchema = z.unknown();
 
 export function useResetPasswordMutation() {
   const queryClient = useQueryClient();
   const navigate = useNavigate();
 
   return useMutation({
-    mutationFn: resetPasswordMutationFn,
+    mutationFn: async (
+      data: Omit<ResetPasswordDto, 'confirmPassword'> & { token: string }
+    ) => passwordService.resetPassword(data),
     onSuccess: async () => {
       navigate(routerPaths.worker.resetPasswordSuccess);
       await queryClient.invalidateQueries();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/reset-password/password.service.ts b/packages/apps/human-app/frontend/src/modules/worker/reset-password/password.service.ts
new file mode 100644
index 0000000000..7ade0c42c7
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/reset-password/password.service.ts
@@ -0,0 +1,40 @@
+import { ApiClientError, humanAppApiClient } from '@/api';
+import { type SendResetLinkDto } from '../send-reset-link/schemas';
+import { type ResetPasswordDto } from './types';
+
+const apiPaths = {
+  sendResetLink: '/password-reset/forgot-password',
+  resetPassword: '/password-reset/restore-password',
+};
+
+async function sendResetLink(data: SendResetLinkDto) {
+  try {
+    await humanAppApiClient.post(apiPaths.sendResetLink, {
+      body: data,
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to send reset link');
+  }
+}
+
+async function resetPassword(
+  data: Omit<ResetPasswordDto, 'confirmPassword'> & { token: string }
+) {
+  try {
+    await humanAppApiClient.post(apiPaths.resetPassword, {
+      body: data,
+    });
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to reset password');
+  }
+}
+
+export { sendResetLink, resetPassword };
diff --git a/packages/apps/human-app/frontend/src/modules/worker/reset-password/reset-password.page.tsx b/packages/apps/human-app/frontend/src/modules/worker/reset-password/reset-password.page.tsx
index 6aa16103a5..48549fe605 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/reset-password/reset-password.page.tsx
+++ b/packages/apps/human-app/frontend/src/modules/worker/reset-password/reset-password.page.tsx
@@ -15,11 +15,9 @@ import { getErrorMessageForError } from '@/shared/errors';
 import { routerPaths } from '@/router/router-paths';
 import { HCaptchaForm } from '@/shared/components/hcaptcha';
 import { useResetMutationErrors } from '@/shared/hooks/use-reset-mutation-errors';
-import {
-  type ResetPasswordDto,
-  resetPasswordDtoSchema,
-  useResetPasswordMutation,
-} from './hooks';
+import { useResetPasswordMutation } from './hooks';
+import { resetPasswordDtoSchema } from './schemas';
+import { type ResetPasswordDto } from './types';
 
 export function ResetPasswordWorkerPage() {
   const location = useLocation();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/reset-password/schemas.ts b/packages/apps/human-app/frontend/src/modules/worker/reset-password/schemas.ts
new file mode 100644
index 0000000000..0d4aff9219
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/reset-password/schemas.ts
@@ -0,0 +1,23 @@
+import { t } from 'i18next';
+import { z } from 'zod';
+
+export const resetPasswordDtoSchema = z
+  .object({
+    password: z
+      .string()
+      .min(8, t('validation.min'))
+      .max(50, t('validation.max', { count: 50 })),
+    confirmPassword: z
+      .string()
+      .min(1, t('validation.required'))
+      .max(50, t('validation.max', { count: 50 })),
+    // eslint-disable-next-line camelcase
+    h_captcha_token: z
+      .string()
+      .min(1, t('validation.captcha'))
+      .default('token'),
+  })
+  .refine(({ password, confirmPassword }) => confirmPassword === password, {
+    message: t('validation.passwordMismatch'),
+    path: ['confirmPassword'],
+  });
diff --git a/packages/apps/human-app/frontend/src/modules/worker/reset-password/types.ts b/packages/apps/human-app/frontend/src/modules/worker/reset-password/types.ts
new file mode 100644
index 0000000000..35eecd5468
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/reset-password/types.ts
@@ -0,0 +1,4 @@
+import { type z } from 'zod';
+import { type resetPasswordDtoSchema } from './schemas';
+
+export type ResetPasswordDto = z.infer<typeof resetPasswordDtoSchema>;
diff --git a/packages/apps/human-app/frontend/src/modules/worker/send-reset-link/hooks/send-reset-link.ts b/packages/apps/human-app/frontend/src/modules/worker/send-reset-link/hooks/send-reset-link.ts
index ba28c6ae7e..e64a755532 100644
--- a/packages/apps/human-app/frontend/src/modules/worker/send-reset-link/hooks/send-reset-link.ts
+++ b/packages/apps/human-app/frontend/src/modules/worker/send-reset-link/hooks/send-reset-link.ts
@@ -1,26 +1,19 @@
 import { z } from 'zod';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useNavigate } from 'react-router-dom';
-import { apiClient } from '@/api/api-client';
-import { apiPaths } from '@/api/api-paths';
 import { routerPaths } from '@/router/router-paths';
 import { type SendResetLinkDto } from '../schemas';
+import * as passwordService from '../../reset-password/password.service';
 
-const SendResetLinkSuccessResponseSchema = z.unknown();
-
-function sendResetLinkMutationFn(data: SendResetLinkDto) {
-  return apiClient(apiPaths.worker.sendResetLink.path, {
-    successSchema: SendResetLinkSuccessResponseSchema,
-    options: { method: 'POST', body: JSON.stringify(data) },
-  });
-}
+export const SendResetLinkSuccessResponseSchema = z.unknown();
 
 export function useSendResetLinkMutation() {
   const queryClient = useQueryClient();
   const navigate = useNavigate();
 
   return useMutation({
-    mutationFn: sendResetLinkMutationFn,
+    mutationFn: async (data: SendResetLinkDto) =>
+      passwordService.sendResetLink(data),
     onSuccess: async (_, { email }) => {
       navigate(routerPaths.worker.sendResetLinkSuccess, { state: { email } });
       await queryClient.invalidateQueries();
diff --git a/packages/apps/human-app/frontend/src/modules/worker/services/oracles.service.ts b/packages/apps/human-app/frontend/src/modules/worker/services/oracles.service.ts
new file mode 100644
index 0000000000..bbc7632a36
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/modules/worker/services/oracles.service.ts
@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+import { env } from '@/shared/env';
+import { MainnetChains, TestnetChains } from '@/modules/smart-contracts/chains';
+
+const apiPaths = {
+  oracles: '/oracles',
+};
+
+const OracleSchema = z.object({
+  address: z.string(),
+  chainId: z.number(),
+  role: z.string(),
+  url: z.string(),
+  jobTypes: z.array(z.string()),
+  registrationNeeded: z.boolean().optional().nullable(),
+  registrationInstructions: z.string().optional().nullable(),
+});
+
+type OracleBase = z.infer<typeof OracleSchema>;
+
+export type Oracle = OracleBase & {
+  name: string;
+};
+
+const OracleNameToUrls = {
+  CVAT: [
+    'https://stg-exchange-oracle.humanprotocol.org',
+    'https://exchange-oracle.humanprotocol.org',
+  ],
+  Fortune: ['https://stg-fortune-exchange-oracle-server.humanprotocol.org'],
+} as const;
+
+const oracleUrlToNameMap = new Map<string, string>();
+for (const [oracleName, oracleUrls] of Object.entries(OracleNameToUrls)) {
+  for (const oracleUrl of oracleUrls) {
+    oracleUrlToNameMap.set(oracleUrl, oracleName);
+  }
+}
+
+const isTestnet = env.VITE_NETWORK === 'testnet';
+
+const H_CAPTCHA_ORACLE: Oracle = {
+  address: env.VITE_H_CAPTCHA_ORACLE_ADDRESS,
+  chainId: isTestnet ? TestnetChains[0].chainId : MainnetChains[0].chainId,
+  jobTypes: env.VITE_H_CAPTCHA_ORACLE_TASK_TYPES,
+  role: env.VITE_H_CAPTCHA_ORACLE_ROLE,
+  url: env.VITE_H_CAPTCHA_ORACLE_ANNOTATION_TOOL,
+  name: 'hCaptcha',
+  registrationNeeded: false,
+};
+
+async function getOracles(selectedJobTypes: string[]) {
+  try {
+    const params = selectedJobTypes.length
+      ? // eslint-disable-next-line camelcase
+        { selected_job_types: selectedJobTypes }
+      : undefined;
+
+    const queryParams = params ?? {};
+
+    let oracles: Oracle[] = [];
+
+    if (
+      selectedJobTypes.length === 0 ||
+      selectedJobTypes.some((t) => H_CAPTCHA_ORACLE.jobTypes.includes(t))
+    ) {
+      oracles.push(H_CAPTCHA_ORACLE);
+    }
+
+    if (env.VITE_FEATURE_FLAG_JOBS_DISCOVERY) {
+      const results = await authorizedHumanAppApiClient.get<OracleBase[]>(
+        apiPaths.oracles,
+        {
+          queryParams,
+        }
+      );
+
+      if (Array.isArray(results)) {
+        oracles = oracles.concat(
+          results.map((oracle: OracleBase) => ({
+            ...oracle,
+            name: oracleUrlToNameMap.get(oracle.url) ?? '',
+          }))
+        );
+      }
+    }
+
+    return oracles;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to get oracles');
+  }
+}
+
+export { getOracles };
diff --git a/packages/apps/human-app/frontend/src/shared/components/hcaptcha/h-captcha-form.tsx b/packages/apps/human-app/frontend/src/shared/components/hcaptcha/h-captcha-form.tsx
index 1f89dba444..256e64362a 100644
--- a/packages/apps/human-app/frontend/src/shared/components/hcaptcha/h-captcha-form.tsx
+++ b/packages/apps/human-app/frontend/src/shared/components/hcaptcha/h-captcha-form.tsx
@@ -1,8 +1,8 @@
 import { useEffect, useRef } from 'react';
 import { useFormContext } from 'react-hook-form';
 import { Typography } from '@mui/material';
-import { FetchError } from '@/api/fetcher';
 import { useColorMode } from '@/shared/contexts/color-mode';
+import { ApiClientError } from '@/api';
 import { CustomHCaptcha, type CustomHCaptchaRef } from './h-captcha';
 
 interface HCaptchaFormProps {
@@ -20,7 +20,7 @@ export function HCaptchaForm({ name, error }: Readonly<HCaptchaFormProps>) {
   }
 
   useEffect(() => {
-    if (error instanceof FetchError) {
+    if (error instanceof ApiClientError) {
       setValue(name, '');
       customCaptchaRef.current?.reset();
     }
diff --git a/packages/apps/human-app/frontend/src/shared/components/ui/table/table-query-hook.ts b/packages/apps/human-app/frontend/src/shared/components/ui/table/table-query-hook.ts
deleted file mode 100644
index f4cebb7d5d..0000000000
--- a/packages/apps/human-app/frontend/src/shared/components/ui/table/table-query-hook.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { useContext } from 'react';
-import { TableQueryContext } from '@/shared/components/ui/table/table-query-context';
-
-export const useTableQuery = () => useContext(TableQueryContext);
diff --git a/packages/apps/human-app/frontend/src/shared/contexts/browser-auth-provider.ts b/packages/apps/human-app/frontend/src/shared/contexts/browser-auth-provider.ts
index ce781b4439..9a10b113f8 100644
--- a/packages/apps/human-app/frontend/src/shared/contexts/browser-auth-provider.ts
+++ b/packages/apps/human-app/frontend/src/shared/contexts/browser-auth-provider.ts
@@ -1,5 +1,8 @@
 /* eslint-disable camelcase -- ...*/
-import type { BrowserAuthProvider } from '@/shared/types/browser-auth-provider';
+import type {
+  AuthType,
+  BrowserAuthProvider,
+} from '@/shared/types/browser-auth-provider';
 import { type AuthTokensSuccessResponse } from '../schemas';
 
 const accessTokenKey = btoa('access_token');
@@ -44,6 +47,7 @@ const browserAuthProvider: BrowserAuthProvider = {
   signOutSubscription: undefined,
   getAccessToken() {
     const result = localStorage.getItem(accessTokenKey);
+
     if (!result) {
       return null;
     }
@@ -59,14 +63,14 @@ const browserAuthProvider: BrowserAuthProvider = {
 
     return atob(result);
   },
-  getAuthType() {
+  getAuthType(): AuthType | null {
     const result = localStorage.getItem(authTypeKey);
 
     if (!result) {
       return null;
     }
 
-    return atob(result);
+    return atob(result) as AuthType;
   },
   setUserData(userData) {
     localStorage.setItem(userDataKey, btoa(JSON.stringify(userData)));
diff --git a/packages/apps/human-app/frontend/src/shared/contexts/generic-auth-context.tsx b/packages/apps/human-app/frontend/src/shared/contexts/generic-auth-context.tsx
index 9e72fccfba..daad26d065 100644
--- a/packages/apps/human-app/frontend/src/shared/contexts/generic-auth-context.tsx
+++ b/packages/apps/human-app/frontend/src/shared/contexts/generic-auth-context.tsx
@@ -9,7 +9,7 @@ import { type Web3UserData } from '@/modules/auth-web3/context/web3-auth-context
 import { type AuthType } from '../types/browser-auth-provider';
 import { useExpirationModal } from '../hooks';
 
-export type AuthStatus = 'loading' | 'error' | 'success' | 'idle';
+type AuthStatus = 'loading' | 'error' | 'success' | 'idle';
 
 interface SignOutOptions {
   throwExpirationModal?: boolean;
diff --git a/packages/apps/human-app/frontend/src/shared/errors/get-error-message-for-error.ts b/packages/apps/human-app/frontend/src/shared/errors/get-error-message-for-error.ts
index 3abe649d8d..d14eb1add6 100644
--- a/packages/apps/human-app/frontend/src/shared/errors/get-error-message-for-error.ts
+++ b/packages/apps/human-app/frontend/src/shared/errors/get-error-message-for-error.ts
@@ -1,6 +1,6 @@
 import { t } from 'i18next';
-import { FetchError } from '@/api/fetcher';
 import { JsonRpcError } from '@/modules/smart-contracts/json-rpc-error';
+import { ApiClientError } from '@/api';
 
 type CustomErrorHandler = (unknownError: unknown) => string | undefined;
 
@@ -22,11 +22,7 @@ export function getErrorMessageForError(
     return t('errors.jsonRpcError');
   }
 
-  if (unknownError instanceof FetchError) {
-    if (typeof unknownError.data === 'string') {
-      return unknownError.data;
-    }
-
+  if (unknownError instanceof ApiClientError) {
     if (unknownError.message) {
       return unknownError.message;
     }
diff --git a/packages/apps/human-app/frontend/src/shared/helpers/time.ts b/packages/apps/human-app/frontend/src/shared/helpers/time.ts
deleted file mode 100644
index b89539eb76..0000000000
--- a/packages/apps/human-app/frontend/src/shared/helpers/time.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export const delay = (ms: number): Promise<void> => {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(undefined);
-    }, ms);
-  });
-};
diff --git a/packages/apps/human-app/frontend/src/shared/helpers/transfomers.ts b/packages/apps/human-app/frontend/src/shared/helpers/transfomers.ts
deleted file mode 100644
index 88a8cbc5a2..0000000000
--- a/packages/apps/human-app/frontend/src/shared/helpers/transfomers.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import queryString from 'query-string';
-
-export function stringifyUrlQueryObject(obj: object) {
-  return queryString.stringify(obj);
-}
diff --git a/packages/apps/human-app/frontend/src/shared/helpers/url.ts b/packages/apps/human-app/frontend/src/shared/helpers/url.ts
deleted file mode 100644
index 10c493ddb7..0000000000
--- a/packages/apps/human-app/frontend/src/shared/helpers/url.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export function normalizeBaseUrl(baseUrl: string): string {
-  return baseUrl.replace(/\/$/, '');
-}
diff --git a/packages/apps/human-app/frontend/src/shared/hooks/index.ts b/packages/apps/human-app/frontend/src/shared/hooks/index.ts
index 59707564b6..6f64178930 100644
--- a/packages/apps/human-app/frontend/src/shared/hooks/index.ts
+++ b/packages/apps/human-app/frontend/src/shared/hooks/index.ts
@@ -7,3 +7,5 @@ export * from './use-is-mobile';
 export * from './use-reset-mutation-errors';
 export * from './use-web3-provider';
 export * from './use-expiration-modal';
+export * from './use-prepare-signature';
+export * from './use-get-ui-config';
diff --git a/packages/apps/human-app/frontend/src/shared/hooks/use-get-ui-config.ts b/packages/apps/human-app/frontend/src/shared/hooks/use-get-ui-config.ts
new file mode 100644
index 0000000000..64f102c547
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/shared/hooks/use-get-ui-config.ts
@@ -0,0 +1,10 @@
+import { useQuery } from '@tanstack/react-query';
+import * as uiConfigService from '../services/ui-config.service';
+
+export function useGetUiConfig() {
+  return useQuery({
+    queryKey: ['ui-config'],
+    queryFn: async () => uiConfigService.getUiConfig(),
+    staleTime: Infinity,
+  });
+}
diff --git a/packages/apps/human-app/frontend/src/shared/hooks/use-prepare-signature.ts b/packages/apps/human-app/frontend/src/shared/hooks/use-prepare-signature.ts
new file mode 100644
index 0000000000..fb64fc0413
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/shared/hooks/use-prepare-signature.ts
@@ -0,0 +1,31 @@
+import { useMutation } from '@tanstack/react-query';
+import {
+  prepareSignature,
+  type PrepareSignatureType,
+} from '@/shared/services/signature.service';
+import { useWalletConnect } from '@/shared/contexts/wallet-connect';
+
+export function usePrepareSignature(type: PrepareSignatureType) {
+  const { address } = useWalletConnect();
+
+  const mutation = useMutation({
+    mutationFn: () => {
+      if (!address) {
+        throw new Error('No address provided. Please connect your wallet.');
+      }
+
+      return prepareSignature({
+        address,
+        type,
+      });
+    },
+    mutationKey: ['prepareSignature', type],
+  });
+
+  return {
+    prepareSignature: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+  };
+}
diff --git a/packages/apps/human-app/frontend/src/shared/i18n/en.json b/packages/apps/human-app/frontend/src/shared/i18n/en.json
index 019b21646b..a7f65ac09c 100644
--- a/packages/apps/human-app/frontend/src/shared/i18n/en.json
+++ b/packages/apps/human-app/frontend/src/shared/i18n/en.json
@@ -149,7 +149,8 @@
       "paragraph3": "<1>Can't find our email?</1> If you can't find the email in your inbox please check the spam folder.",
       "paragraph4": "<1>Having trouble?</1> Please <2>Contact Support</2>",
       "successResent": "Verification email has been successfully resent.",
-      "authError": "Log in before you resend email verification"
+      "authError": "Log in before you resend email verification",
+      "emailError": "No email provided."
     },
     "emailVerification": {
       "title": "Email Verified",
diff --git a/packages/apps/human-app/frontend/src/shared/providers/notifications-provider.tsx b/packages/apps/human-app/frontend/src/shared/providers/notifications-provider.tsx
index 7fe29e62e2..17aabba253 100644
--- a/packages/apps/human-app/frontend/src/shared/providers/notifications-provider.tsx
+++ b/packages/apps/human-app/frontend/src/shared/providers/notifications-provider.tsx
@@ -2,7 +2,6 @@ import { type ReactNode } from 'react';
 import { SnackbarProvider } from 'notistack';
 import CheckCircleIcon from '@mui/icons-material/CheckCircle';
 import ErrorIcon from '@mui/icons-material/Error';
-import { Stack } from '@mui/material';
 import { TopNotificationType } from '@/shared/hooks/use-notification';
 import { colorPalette as lightColorPalette } from '@/shared/styles/color-palette';
 import { handleUnreachableCase } from '@/shared/helpers/handle-unreachable-case';
@@ -35,48 +34,29 @@ const getNotificationIconByType = (
 export function NotificationProvider({
   children,
   maxSnacks = MAX_NOTIFICATIONS_VISIBLE,
-}: NotificationProviderProps) {
+}: Readonly<NotificationProviderProps>) {
   const isMobile = useIsMobile();
 
   return (
-    <Stack
-      sx={{
-        '.notistack-SnackbarContainer': {
-          width: '100%',
-        },
-        '.notistack-SnackbarContainer > div': {
-          width: '100%',
-          maxWidth: '100%',
-        },
-        '.notistack-Snackbar': {
-          display: 'flex',
-          justifyContent: 'flex-end',
-          width: isMobile ? '100%' : 'calc(100% - 303px)',
-          marginRight: isMobile ? '0' : '32px',
-        },
-        '.notistack-CollapseWrapper': {
-          display: 'flex',
-          justifyContent: 'flex-end',
-        },
+    <SnackbarProvider
+      maxSnack={maxSnacks}
+      anchorOrigin={{
+        vertical: 'top',
+        horizontal: 'right',
+      }}
+      iconVariant={{
+        success: getNotificationIconByType(TopNotificationType.SUCCESS, {
+          marginRight: '12px',
+        }),
+        warning: getNotificationIconByType(TopNotificationType.WARNING, {
+          marginRight: '12px',
+        }),
+      }}
+      style={{
+        minWidth: isMobile ? '90vw' : '80vw',
       }}
     >
-      <SnackbarProvider
-        maxSnack={maxSnacks}
-        anchorOrigin={{
-          vertical: 'top',
-          horizontal: 'right',
-        }}
-        iconVariant={{
-          success: getNotificationIconByType(TopNotificationType.SUCCESS, {
-            marginRight: '12px',
-          }),
-          warning: getNotificationIconByType(TopNotificationType.WARNING, {
-            marginRight: '12px',
-          }),
-        }}
-      >
-        {children}
-      </SnackbarProvider>
-    </Stack>
+      {children}
+    </SnackbarProvider>
   );
 }
diff --git a/packages/apps/human-app/frontend/src/shared/services/signature.service.ts b/packages/apps/human-app/frontend/src/shared/services/signature.service.ts
new file mode 100644
index 0000000000..27dc848e4e
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/shared/services/signature.service.ts
@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { ApiClientError, humanAppApiClient } from '@/api';
+
+const apiPaths = {
+  web3: {
+    prepareSignature: '/prepare-signature',
+  },
+};
+
+interface PrepareSignatureBody {
+  address: string;
+  type: PrepareSignatureType;
+}
+
+export enum PrepareSignatureType {
+  SIGN_UP = 'signup',
+  SIGN_IN = 'signin',
+  DISABLE_OPERATOR = 'disable_operator',
+  ENABLE_OPERATOR = 'enable_operator',
+  REGISTER_ADDRESS = 'register_address',
+}
+
+const prepareSignatureSuccessSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  contents: z.string(),
+  nonce: z.unknown(),
+});
+
+export type SignatureData = z.infer<typeof prepareSignatureSuccessSchema>;
+
+async function prepareSignature(data: PrepareSignatureBody) {
+  try {
+    const result = await humanAppApiClient.post<SignatureData>(
+      apiPaths.web3.prepareSignature,
+      {
+        body: { ...data },
+        successSchema: prepareSignatureSuccessSchema,
+      }
+    );
+
+    return result;
+  } catch (error) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+
+    throw new Error('Failed to prepare signature');
+  }
+}
+
+export { prepareSignature };
diff --git a/packages/apps/human-app/frontend/src/shared/services/ui-config.service.ts b/packages/apps/human-app/frontend/src/shared/services/ui-config.service.ts
new file mode 100644
index 0000000000..4343540456
--- /dev/null
+++ b/packages/apps/human-app/frontend/src/shared/services/ui-config.service.ts
@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { ApiClientError, authorizedHumanAppApiClient } from '@/api';
+
+const apiPaths = {
+  uiConfig: '/ui-config',
+};
+
+const uiConfigSchema = z.object({
+  chainIdsEnabled: z.array(z.number()),
+});
+
+type UiConfig = z.infer<typeof uiConfigSchema>;
+
+async function getUiConfig() {
+  try {
+    const result = await authorizedHumanAppApiClient.get<UiConfig>(
+      apiPaths.uiConfig,
+      {
+        successSchema: uiConfigSchema,
+      }
+    );
+
+    return result;
+  } catch (error: unknown) {
+    if (error instanceof ApiClientError) {
+      throw error;
+    }
+    throw new Error('Failed to get UI config');
+  }
+}
+
+export { getUiConfig };
diff --git a/packages/apps/human-app/frontend/src/shared/types/browser-auth-provider.ts b/packages/apps/human-app/frontend/src/shared/types/browser-auth-provider.ts
index 297669b6c9..ce014570a9 100644
--- a/packages/apps/human-app/frontend/src/shared/types/browser-auth-provider.ts
+++ b/packages/apps/human-app/frontend/src/shared/types/browser-auth-provider.ts
@@ -19,7 +19,7 @@ export interface BrowserAuthProvider {
   signOutSubscription?: SubscriptionCallback;
   getAccessToken: () => string | null;
   getRefreshToken: () => string | null;
-  getAuthType: () => string | null;
+  getAuthType: () => AuthType | null;
   setUserData: (userData: UserData | Web3UserData) => void;
   getUserData: () => { data: unknown };
 }
diff --git a/packages/apps/human-app/frontend/src/shared/types/entity.type.ts b/packages/apps/human-app/frontend/src/shared/types/entity.type.ts
index 892e45b12d..03ec2ffb9e 100644
--- a/packages/apps/human-app/frontend/src/shared/types/entity.type.ts
+++ b/packages/apps/human-app/frontend/src/shared/types/entity.type.ts
@@ -1,5 +1 @@
-import { z } from 'zod';
-
-export const testDataSchema = z.coerce.date();
-export type TestData = z.infer<typeof testDataSchema>;
 export type PageSize = 5 | 10;
diff --git a/packages/apps/human-app/frontend/src/shared/types/global.type.ts b/packages/apps/human-app/frontend/src/shared/types/global.type.ts
index 56f0a676aa..c5ebc70959 100644
--- a/packages/apps/human-app/frontend/src/shared/types/global.type.ts
+++ b/packages/apps/human-app/frontend/src/shared/types/global.type.ts
@@ -1,17 +1,11 @@
 import type { ZodError } from 'zod';
-import type { FetchError } from '@/api/fetcher';
 import type { JsonRpcError } from '@/modules/smart-contracts/json-rpc-error';
+import { type ApiClientError } from '@/api';
 
-export interface Children {
-  children?: React.ReactNode;
-}
-
-export type ResponseError = FetchError | Error | ZodError | JsonRpcError;
+export type ResponseError = ApiClientError | Error | ZodError | JsonRpcError;
 
 declare module '@tanstack/react-query' {
   interface Register {
     defaultError: ResponseError;
   }
 }
-
-export type FormNotifications = 'warning' | 'error' | 'default';
diff --git a/packages/apps/human-app/frontend/src/shared/types/svg.d.ts b/packages/apps/human-app/frontend/src/shared/types/svg.d.ts
deleted file mode 100644
index 7a9b19df95..0000000000
--- a/packages/apps/human-app/frontend/src/shared/types/svg.d.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-declare module '*.svg' {
-  const ReactComponent: React.FC<React.SVGProps<SVGSVGElement>>;
-  // eslint-disable-next-line import/no-default-export -- export vite config
-  export default ReactComponent;
-}
-
-declare module '*.svg?url' {
-  const content: string;
-  // eslint-disable-next-line import/no-default-export -- export vite config
-  export default content;
-}
diff --git a/packages/apps/reputation-oracle/server/src/app.module.ts b/packages/apps/reputation-oracle/server/src/app.module.ts
index ebd52542e9..02f2541927 100644
--- a/packages/apps/reputation-oracle/server/src/app.module.ts
+++ b/packages/apps/reputation-oracle/server/src/app.module.ts
@@ -22,8 +22,8 @@ import { KycModule } from './modules/kyc/kyc.module';
 import { CronJobModule } from './modules/cron-job/cron-job.module';
 import { QualificationModule } from './modules/qualification/qualification.module';
 import { EscrowCompletionModule } from './modules/escrow-completion/escrow-completion.module';
-import { WebhookIncomingModule } from './modules/webhook/webhook-incoming.module';
-import { WebhookOutgoingModule } from './modules/webhook/webhook-outgoing.module';
+import { IncomingWebhookModule } from './modules/webhook/webhook-incoming.module';
+import { OutgoingWebhookModule } from './modules/webhook/webhook-outgoing.module';
 import { UserModule } from './modules/user';
 import { NDAModule } from './modules/nda/nda.module';
 
@@ -90,8 +90,8 @@ import { AbuseModule } from './modules/abuse/abuse.module';
     QualificationModule,
     ReputationModule,
     UserModule,
-    WebhookIncomingModule,
-    WebhookOutgoingModule,
+    IncomingWebhookModule,
+    OutgoingWebhookModule,
   ],
   controllers: [AppController],
 })
diff --git a/packages/apps/reputation-oracle/server/src/common/enums/webhook.ts b/packages/apps/reputation-oracle/server/src/common/enums/webhook.ts
index a00f84eb3e..abdc7e0a78 100644
--- a/packages/apps/reputation-oracle/server/src/common/enums/webhook.ts
+++ b/packages/apps/reputation-oracle/server/src/common/enums/webhook.ts
@@ -1,22 +1,4 @@
-export enum EventType {
-  JOB_COMPLETED = 'job_completed',
-  ESCROW_COMPLETED = 'escrow_completed',
-  ABUSE_DETECTED = 'abuse_detected',
-  ABUSE_DISMISSED = 'abuse_dismissed',
-}
-
-export enum WebhookIncomingStatus {
-  PENDING = 'pending',
-  COMPLETED = 'completed',
-  FAILED = 'failed',
-}
-
-export enum WebhookOutgoingStatus {
-  PENDING = 'pending',
-  SENT = 'sent',
-  FAILED = 'failed',
-}
-
+// TODO: Move to escrow completion module
 export enum EscrowCompletionStatus {
   PENDING = 'pending',
   AWAITING_PAYOUTS = 'awaiting_payouts',
diff --git a/packages/apps/reputation-oracle/server/src/database/database.module.ts b/packages/apps/reputation-oracle/server/src/database/database.module.ts
index 94461cf7a1..f2e53645f1 100644
--- a/packages/apps/reputation-oracle/server/src/database/database.module.ts
+++ b/packages/apps/reputation-oracle/server/src/database/database.module.ts
@@ -12,8 +12,8 @@ import { DatabaseConfigService } from '../config/database-config.service';
 import { SiteKeyEntity } from '../modules/user/site-key.entity';
 import { QualificationEntity } from '../modules/qualification/qualification.entity';
 import { UserQualificationEntity } from '../modules/qualification/user-qualification.entity';
-import { WebhookIncomingEntity } from '../modules/webhook/webhook-incoming.entity';
-import { WebhookOutgoingEntity } from '../modules/webhook/webhook-outgoing.entity';
+import { IncomingWebhookEntity } from '../modules/webhook/webhook-incoming.entity';
+import { OutgoingWebhookEntity } from '../modules/webhook/webhook-outgoing.entity';
 import { EscrowCompletionEntity } from '../modules/escrow-completion/escrow-completion.entity';
 import { EscrowPayoutsBatchEntity } from '../modules/escrow-completion/escrow-payouts-batch.entity';
 import { AbuseEntity } from '../modules/abuse/abuse.entity';
@@ -63,8 +63,8 @@ import { TypeOrmLoggerModule, TypeOrmLoggerService } from './typeorm';
           migrationsRun: false,
           entities: [
             AbuseEntity,
-            WebhookIncomingEntity,
-            WebhookOutgoingEntity,
+            IncomingWebhookEntity,
+            OutgoingWebhookEntity,
             EscrowCompletionEntity,
             EscrowPayoutsBatchEntity,
             ReputationEntity,
diff --git a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.module.ts b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.module.ts
index 3e57cfff30..5e995f6eb5 100644
--- a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.module.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.module.ts
@@ -4,12 +4,12 @@ import { AbuseSlackBot } from './abuse.slack-bot';
 import { AbuseRepository } from './abuse.repository';
 import { AbuseService } from './abuse.service';
 import { Web3Module } from '../web3/web3.module';
-import { WebhookOutgoingModule } from '../webhook/webhook-outgoing.module';
+import { OutgoingWebhookModule } from '../webhook/webhook-outgoing.module';
 import { AbuseController } from './abuse.controller';
 import { AbuseSlackAuthGuard } from './abuse.slack-auth.guard';
 
 @Module({
-  imports: [HttpModule, Web3Module, WebhookOutgoingModule],
+  imports: [HttpModule, Web3Module, OutgoingWebhookModule],
   providers: [
     AbuseRepository,
     AbuseService,
diff --git a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.spec.ts b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.spec.ts
index 2701768a86..43bd05d038 100644
--- a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.spec.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.spec.ts
@@ -10,14 +10,13 @@ import {
 } from '@human-protocol/sdk';
 import { ConfigService } from '@nestjs/config';
 import { Test } from '@nestjs/testing';
-
-import { EventType } from '../../common/enums';
 import { PostgresErrorCodes } from '../../common/enums/database';
 import { DatabaseError } from '../../common/errors/database';
 import { ServerConfigService } from '../../config/server-config.service';
 import { generateTestnetChainId } from '../web3/fixtures';
 import { Web3Service } from '../web3/web3.service';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
+import { OutgoingWebhookEventType } from '../webhook/types';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
 import { AbuseRepository } from './abuse.repository';
 import { AbuseService } from './abuse.service';
 import { AbuseSlackBot } from './abuse.slack-bot';
@@ -29,7 +28,7 @@ const fakeAddress = faker.finance.ethereumAddress();
 const mockAbuseRepository = createMock<AbuseRepository>();
 const mockAbuseSlackBot = createMock<AbuseSlackBot>();
 const mockWeb3Service = createMock<Web3Service>();
-const mockWebhookOutgoingService = createMock<WebhookOutgoingService>();
+const mockOutgoingWebhookService = createMock<OutgoingWebhookService>();
 
 const mockedStakingClient = jest.mocked(StakingClient);
 const mockedOperatorUtils = jest.mocked(OperatorUtils);
@@ -59,8 +58,8 @@ describe('AbuseService', () => {
         },
         { provide: AbuseRepository, useValue: mockAbuseRepository },
         {
-          provide: WebhookOutgoingService,
-          useValue: mockWebhookOutgoingService,
+          provide: OutgoingWebhookService,
+          useValue: mockOutgoingWebhookService,
         },
       ],
     }).compile();
@@ -297,7 +296,7 @@ describe('AbuseService', () => {
         webhookUrl: webhookUrl1,
       } as IOperator);
 
-      mockWebhookOutgoingService.createOutgoingWebhook.mockRejectedValueOnce(
+      mockOutgoingWebhookService.createOutgoingWebhook.mockRejectedValueOnce(
         new DatabaseError('Failed to create webhook'),
       );
 
@@ -331,7 +330,7 @@ describe('AbuseService', () => {
           webhookUrl: webhookUrl2,
         } as IOperator);
 
-      mockWebhookOutgoingService.createOutgoingWebhook.mockRejectedValueOnce(
+      mockOutgoingWebhookService.createOutgoingWebhook.mockRejectedValueOnce(
         new DatabaseError(PostgresErrorCodes.Duplicated),
       );
 
@@ -395,7 +394,7 @@ describe('AbuseService', () => {
       mockedOperatorUtils.getOperator.mockResolvedValueOnce({
         webhookUrl: webhookUrl1,
       } as IOperator);
-      mockWebhookOutgoingService.createOutgoingWebhook.mockResolvedValueOnce(
+      mockOutgoingWebhookService.createOutgoingWebhook.mockResolvedValueOnce(
         undefined,
       );
 
@@ -410,12 +409,12 @@ describe('AbuseService', () => {
       //   expect.any(Number),
       // );
       expect(
-        mockWebhookOutgoingService.createOutgoingWebhook,
+        mockOutgoingWebhookService.createOutgoingWebhook,
       ).toHaveBeenCalledWith(
         {
           escrowAddress: mockAbuseEntities[0].escrowAddress,
           chainId: mockAbuseEntities[0].chainId,
-          eventType: EventType.ABUSE_DETECTED,
+          eventType: OutgoingWebhookEventType.ABUSE_DETECTED,
         },
         expect.any(String),
       );
@@ -456,7 +455,7 @@ describe('AbuseService', () => {
 
       expect(mockAbuseRepository.findClassified).toHaveBeenCalledTimes(1);
       expect(
-        mockWebhookOutgoingService.createOutgoingWebhook,
+        mockOutgoingWebhookService.createOutgoingWebhook,
       ).not.toHaveBeenCalled();
       expect(mockAbuseRepository.updateOne).not.toHaveBeenCalled();
     });
diff --git a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.ts b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.ts
index 97721e9b46..56ae182ffc 100644
--- a/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/abuse/abuse.service.ts
@@ -6,12 +6,12 @@ import {
 } from '@human-protocol/sdk';
 import { Injectable } from '@nestjs/common';
 import { ethers } from 'ethers';
-import { EventType } from '../../common/enums';
 import { isDuplicatedError } from '../../common/errors/database';
 import { ServerConfigService } from '../../config/server-config.service';
 import logger from '../../logger';
 import { Web3Service } from '../web3/web3.service';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
+import { OutgoingWebhookEventType } from '../webhook/types';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
 import { AbuseEntity } from './abuse.entity';
 import { AbuseRepository } from './abuse.repository';
 import { AbuseDecision, AbuseStatus } from './constants';
@@ -34,7 +34,7 @@ export class AbuseService {
     private readonly abuseRepository: AbuseRepository,
     private readonly web3Service: Web3Service,
     private readonly serverConfigService: ServerConfigService,
-    private readonly webhookOutgoingService: WebhookOutgoingService,
+    private readonly outgoingWebhookService: OutgoingWebhookService,
   ) {}
 
   async reportAbuse(data: ReportAbuseInput): Promise<void> {
@@ -169,11 +169,11 @@ export class AbuseService {
         const webhookPayload = {
           chainId: abuseEntity.chainId,
           escrowAddress: abuseEntity.escrowAddress,
-          eventType: EventType.ABUSE_DETECTED,
+          eventType: OutgoingWebhookEventType.ABUSE_DETECTED,
         };
 
         try {
-          await this.webhookOutgoingService.createOutgoingWebhook(
+          await this.outgoingWebhookService.createOutgoingWebhook(
             webhookPayload,
             webhookUrl,
           );
@@ -231,11 +231,11 @@ export class AbuseService {
           const webhookPayload = {
             chainId,
             escrowAddress,
-            eventType: EventType.ABUSE_DETECTED,
+            eventType: OutgoingWebhookEventType.ABUSE_DETECTED,
           };
 
           try {
-            await this.webhookOutgoingService.createOutgoingWebhook(
+            await this.outgoingWebhookService.createOutgoingWebhook(
               webhookPayload,
               webhookUrl,
             );
@@ -257,7 +257,7 @@ export class AbuseService {
           const webhookPayload = {
             chainId: chainId,
             escrowAddress: escrowAddress,
-            eventType: EventType.ABUSE_DISMISSED,
+            eventType: OutgoingWebhookEventType.ABUSE_DISMISSED,
           };
           const webhookUrl = (
             await OperatorUtils.getOperator(
@@ -267,7 +267,7 @@ export class AbuseService {
           ).webhookUrl as string;
 
           try {
-            await this.webhookOutgoingService.createOutgoingWebhook(
+            await this.outgoingWebhookService.createOutgoingWebhook(
               webhookPayload,
               webhookUrl,
             );
diff --git a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.module.ts b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.module.ts
index 75f4042c18..7a73f75e4b 100644
--- a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.module.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.module.ts
@@ -1,8 +1,8 @@
 import { Module } from '@nestjs/common';
 
 import { EscrowCompletionModule } from '../escrow-completion/escrow-completion.module';
-import { WebhookIncomingModule } from '../webhook/webhook-incoming.module';
-import { WebhookOutgoingModule } from '../webhook/webhook-outgoing.module';
+import { IncomingWebhookModule } from '../webhook/webhook-incoming.module';
+import { OutgoingWebhookModule } from '../webhook/webhook-outgoing.module';
 
 import { CronJobService } from './cron-job.service';
 import { CronJobRepository } from './cron-job.repository';
@@ -10,8 +10,8 @@ import { AbuseModule } from '../abuse/abuse.module';
 
 @Module({
   imports: [
-    WebhookIncomingModule,
-    WebhookOutgoingModule,
+    IncomingWebhookModule,
+    OutgoingWebhookModule,
     EscrowCompletionModule,
     AbuseModule,
   ],
diff --git a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.spec.ts b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.spec.ts
index bbeff8b38c..0be8b3b76a 100644
--- a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.spec.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.spec.ts
@@ -3,16 +3,16 @@ import { CronJobService } from './cron-job.service';
 import { CronJobRepository } from './cron-job.repository';
 import { CronJobEntity } from './cron-job.entity';
 import { CronJobType } from '../../common/enums/cron-job';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
-import { WebhookIncomingService } from '../webhook/webhook-incoming.service';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
+import { IncomingWebhookService } from '../webhook/webhook-incoming.service';
 import { EscrowCompletionService } from '../escrow-completion/escrow-completion.service';
 import { AbuseService } from '../abuse/abuse.service';
 
 describe('CronJobService', () => {
   let service: CronJobService;
   let cronJobRepository: jest.Mocked<CronJobRepository>;
-  let webhookIncomingService: jest.Mocked<WebhookIncomingService>;
-  let webhookOutgoingService: jest.Mocked<WebhookOutgoingService>;
+  let incomingWebhookService: jest.Mocked<IncomingWebhookService>;
+  let outgoingWebhookService: jest.Mocked<OutgoingWebhookService>;
   let escrowCompletionService: jest.Mocked<EscrowCompletionService>;
   let abuseService: jest.Mocked<AbuseService>;
 
@@ -29,13 +29,13 @@ describe('CronJobService', () => {
           },
         },
         {
-          provide: WebhookIncomingService,
+          provide: IncomingWebhookService,
           useValue: {
             processPendingIncomingWebhooks: jest.fn(),
           },
         },
         {
-          provide: WebhookOutgoingService,
+          provide: OutgoingWebhookService,
           useValue: {
             processPendingOutgoingWebhooks: jest.fn(),
           },
@@ -60,8 +60,8 @@ describe('CronJobService', () => {
 
     service = module.get<CronJobService>(CronJobService);
     cronJobRepository = module.get(CronJobRepository);
-    webhookIncomingService = module.get(WebhookIncomingService);
-    webhookOutgoingService = module.get(WebhookOutgoingService);
+    incomingWebhookService = module.get(IncomingWebhookService);
+    outgoingWebhookService = module.get(OutgoingWebhookService);
     escrowCompletionService = module.get(EscrowCompletionService);
     abuseService = module.get(AbuseService);
   });
@@ -211,7 +211,7 @@ describe('CronJobService', () => {
       await service.processPendingIncomingWebhooks();
 
       expect(
-        webhookIncomingService.processPendingIncomingWebhooks,
+        incomingWebhookService.processPendingIncomingWebhooks,
       ).not.toHaveBeenCalled();
     });
 
@@ -227,7 +227,7 @@ describe('CronJobService', () => {
       await service.processPendingIncomingWebhooks();
 
       expect(
-        webhookIncomingService.processPendingIncomingWebhooks,
+        incomingWebhookService.processPendingIncomingWebhooks,
       ).toHaveBeenCalled();
       expect(service.startCronJob).toHaveBeenCalled();
       expect(service.completeCronJob).toHaveBeenCalled();
@@ -242,7 +242,7 @@ describe('CronJobService', () => {
         .spyOn(service, 'completeCronJob')
         .mockResolvedValue(new CronJobEntity());
 
-      webhookIncomingService.processPendingIncomingWebhooks.mockRejectedValue(
+      incomingWebhookService.processPendingIncomingWebhooks.mockRejectedValue(
         new Error('Processing error'),
       );
 
@@ -401,7 +401,7 @@ describe('CronJobService', () => {
       await service.processPendingOutgoingWebhooks();
 
       expect(
-        webhookOutgoingService.processPendingOutgoingWebhooks,
+        outgoingWebhookService.processPendingOutgoingWebhooks,
       ).not.toHaveBeenCalled();
     });
 
@@ -417,7 +417,7 @@ describe('CronJobService', () => {
       await service.processPendingOutgoingWebhooks();
 
       expect(
-        webhookOutgoingService.processPendingOutgoingWebhooks,
+        outgoingWebhookService.processPendingOutgoingWebhooks,
       ).toHaveBeenCalled();
       expect(service.startCronJob).toHaveBeenCalled();
       expect(service.completeCronJob).toHaveBeenCalled();
@@ -432,7 +432,7 @@ describe('CronJobService', () => {
         .spyOn(service, 'completeCronJob')
         .mockResolvedValue(new CronJobEntity());
 
-      webhookOutgoingService.processPendingOutgoingWebhooks.mockRejectedValue(
+      outgoingWebhookService.processPendingOutgoingWebhooks.mockRejectedValue(
         new Error('Processing error'),
       );
 
diff --git a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.ts b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.ts
index 8b48208b7b..3ad7cc8035 100644
--- a/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/cron-job/cron-job.service.ts
@@ -6,8 +6,8 @@ import { CronJobType } from '../../common/enums/cron-job';
 import logger from '../../logger';
 import { AbuseService } from '../abuse/abuse.service';
 import { EscrowCompletionService } from '../escrow-completion/escrow-completion.service';
-import { WebhookIncomingService } from '../webhook/webhook-incoming.service';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
+import { IncomingWebhookService } from '../webhook/webhook-incoming.service';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
 import { CronJobEntity } from './cron-job.entity';
 import { CronJobRepository } from './cron-job.repository';
 
@@ -17,8 +17,8 @@ export class CronJobService {
 
   constructor(
     private readonly cronJobRepository: CronJobRepository,
-    private readonly webhookIncomingService: WebhookIncomingService,
-    private readonly webhookOutgoingService: WebhookOutgoingService,
+    private readonly incomingWebhookService: IncomingWebhookService,
+    private readonly outgoingWebhookService: OutgoingWebhookService,
     private readonly escrowCompletionService: EscrowCompletionService,
     private readonly abuseService: AbuseService,
   ) {}
@@ -98,7 +98,7 @@ export class CronJobService {
     );
 
     try {
-      await this.webhookIncomingService.processPendingIncomingWebhooks();
+      await this.incomingWebhookService.processPendingIncomingWebhooks();
     } catch (error) {
       this.logger.error('Error processing pending incoming webhooks', error);
     }
@@ -184,7 +184,7 @@ export class CronJobService {
     );
 
     try {
-      await this.webhookOutgoingService.processPendingOutgoingWebhooks();
+      await this.outgoingWebhookService.processPendingOutgoingWebhooks();
     } catch (error) {
       this.logger.error('Error processing pending outgoing webhooks', error);
     }
diff --git a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.module.ts b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.module.ts
index 47d0b4a9b5..281754d006 100644
--- a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.module.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.module.ts
@@ -3,14 +3,14 @@ import { Module } from '@nestjs/common';
 import { PayoutModule } from '../payout/payout.module';
 import { ReputationModule } from '../reputation/reputation.module';
 import { Web3Module } from '../web3/web3.module';
-import { WebhookOutgoingModule } from '../webhook/webhook-outgoing.module';
+import { OutgoingWebhookModule } from '../webhook/webhook-outgoing.module';
 
 import { EscrowCompletionRepository } from './escrow-completion.repository';
 import { EscrowCompletionService } from './escrow-completion.service';
 import { EscrowPayoutsBatchRepository } from './escrow-payouts-batch.repository';
 
 @Module({
-  imports: [Web3Module, PayoutModule, ReputationModule, WebhookOutgoingModule],
+  imports: [Web3Module, PayoutModule, ReputationModule, OutgoingWebhookModule],
   providers: [
     EscrowCompletionService,
     EscrowCompletionRepository,
diff --git a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.spec.ts b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.spec.ts
index f3188347dd..db8cc51412 100644
--- a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.spec.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.spec.ts
@@ -22,11 +22,11 @@ import { Web3ConfigService } from '../../config/web3-config.service';
 import { ServerConfigService } from '../../config/server-config.service';
 import { EscrowCompletionService } from './escrow-completion.service';
 import { PostgresErrorCodes } from '../../common/enums/database';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
 import { PayoutService } from '../payout/payout.service';
 import { ReputationService } from '../reputation/reputation.service';
 import { DatabaseError } from '../../common/errors/database';
-import { WebhookOutgoingRepository } from '../webhook/webhook-outgoing.repository';
+import { OutgoingWebhookRepository } from '../webhook/webhook-outgoing.repository';
 import { StorageService } from '../storage/storage.service';
 import { ReputationRepository } from '../reputation/reputation.repository';
 import { ReputationConfigService } from '../../config/reputation-config.service';
@@ -85,7 +85,7 @@ describe('escrowCompletionService', () => {
     escrowCompletionRepository: EscrowCompletionRepository,
     escrowPayoutsBatchRepository: EscrowPayoutsBatchRepository,
     web3ConfigService: Web3ConfigService,
-    webhookOutgoingService: WebhookOutgoingService,
+    outgoingWebhookService: OutgoingWebhookService,
     reputationService: ReputationService,
     payoutService: PayoutService;
 
@@ -144,8 +144,8 @@ describe('escrowCompletionService', () => {
           useValue: createMock<EscrowPayoutsBatchRepository>(),
         },
         {
-          provide: WebhookOutgoingRepository,
-          useValue: createMock<WebhookOutgoingRepository>(),
+          provide: OutgoingWebhookRepository,
+          useValue: createMock<OutgoingWebhookRepository>(),
         },
         {
           provide: ReputationRepository,
@@ -164,7 +164,7 @@ describe('escrowCompletionService', () => {
           provide: StorageService,
           useValue: createMock<StorageService>(),
         },
-        WebhookOutgoingService,
+        OutgoingWebhookService,
         PayoutService,
         ReputationService,
         Web3ConfigService,
@@ -181,8 +181,8 @@ describe('escrowCompletionService', () => {
       EscrowCompletionService,
     );
 
-    webhookOutgoingService = moduleRef.get<WebhookOutgoingService>(
-      WebhookOutgoingService,
+    outgoingWebhookService = moduleRef.get<OutgoingWebhookService>(
+      OutgoingWebhookService,
     );
     payoutService = moduleRef.get<PayoutService>(PayoutService);
     reputationService = moduleRef.get<ReputationService>(ReputationService);
@@ -451,7 +451,7 @@ describe('escrowCompletionService', () => {
         .mockResolvedValue();
 
       createOutgoingWebhookMock = jest
-        .spyOn(webhookOutgoingService, 'createOutgoingWebhook')
+        .spyOn(outgoingWebhookService, 'createOutgoingWebhook')
         .mockResolvedValue();
     });
 
@@ -539,7 +539,7 @@ describe('escrowCompletionService', () => {
         .mockResolvedValue(escrowCompletionEntity1 as any);
 
       createOutgoingWebhookMock = jest
-        .spyOn(webhookOutgoingService, 'createOutgoingWebhook')
+        .spyOn(outgoingWebhookService, 'createOutgoingWebhook')
         .mockImplementation(() => {
           throw new DatabaseError(
             'Duplicate entry error',
diff --git a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.ts b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.ts
index 9d272879a9..d0ce93b467 100644
--- a/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/escrow-completion/escrow-completion.service.ts
@@ -11,7 +11,7 @@ import {
   OperatorUtils,
 } from '@human-protocol/sdk';
 import { Injectable } from '@nestjs/common';
-import { EscrowCompletionStatus, EventType } from '../../common/enums';
+import { EscrowCompletionStatus } from '../../common/enums';
 import { ServerConfigService } from '../../config/server-config.service';
 import { EscrowCompletionRepository } from './escrow-completion.repository';
 import { EscrowCompletionEntity } from './escrow-completion.entity';
@@ -23,12 +23,13 @@ import {
 import { PayoutService } from '../payout/payout.service';
 import { ReputationService } from '../reputation/reputation.service';
 import { Web3Service } from '../web3/web3.service';
-import { WebhookOutgoingService } from '../webhook/webhook-outgoing.service';
+import { OutgoingWebhookService } from '../webhook/webhook-outgoing.service';
 import { isDuplicatedError } from '../../common/errors/database';
 import { CalculatedPayout } from '../payout/payout.interface';
 import { EscrowPayoutsBatchEntity } from './escrow-payouts-batch.entity';
 import { EscrowPayoutsBatchRepository } from './escrow-payouts-batch.repository';
 import logger from '../../logger';
+import { OutgoingWebhookEventType } from '../webhook/types';
 
 @Injectable()
 export class EscrowCompletionService {
@@ -40,7 +41,7 @@ export class EscrowCompletionService {
     private readonly escrowCompletionRepository: EscrowCompletionRepository,
     private readonly escrowPayoutsBatchRepository: EscrowPayoutsBatchRepository,
     private readonly web3Service: Web3Service,
-    private readonly webhookOutgoingService: WebhookOutgoingService,
+    private readonly outgoingWebhookService: OutgoingWebhookService,
     private readonly payoutService: PayoutService,
     private readonly reputationService: ReputationService,
     public readonly serverConfigService: ServerConfigService,
@@ -219,7 +220,7 @@ export class EscrowCompletionService {
         const webhookPayload = {
           chainId,
           escrowAddress,
-          eventType: EventType.ESCROW_COMPLETED,
+          eventType: OutgoingWebhookEventType.ESCROW_COMPLETED,
         };
 
         let allWebhooksCreated = true;
@@ -239,7 +240,7 @@ export class EscrowCompletionService {
           }
 
           try {
-            await this.webhookOutgoingService.createOutgoingWebhook(
+            await this.outgoingWebhookService.createOutgoingWebhook(
               webhookPayload,
               webhookUrl,
             );
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/fixtures.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/fixtures.ts
new file mode 100644
index 0000000000..77d2775cc0
--- /dev/null
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/fixtures.ts
@@ -0,0 +1,84 @@
+import { faker } from '@faker-js/faker';
+import * as crypto from 'crypto';
+import stringify from 'json-stable-stringify';
+
+import { generateTestnetChainId } from '../web3/fixtures';
+import {
+  IncomingWebhookStatus,
+  OutgoingWebhookEventType,
+  OutgoingWebhookStatus,
+} from './types';
+import { IncomingWebhookEntity } from './webhook-incoming.entity';
+import { OutgoingWebhookEntity } from './webhook-outgoing.entity';
+
+type GenerateIncomingWebhookOptions = {
+  retriesCount?: number;
+  status?: IncomingWebhookStatus;
+};
+
+type GenerateOutgoingWebhookPayloadOptions = {
+  escrowAddress?: string;
+};
+
+type GenerateOutgoingWebhookOptions = {
+  retriesCount?: number;
+  status?: OutgoingWebhookStatus;
+};
+
+export function generateIncomingWebhook(
+  options?: GenerateIncomingWebhookOptions,
+): IncomingWebhookEntity {
+  const retriesCount = options?.retriesCount || 0;
+  const status = options?.status || IncomingWebhookStatus.PENDING;
+  return {
+    id: faker.number.int(),
+    chainId: generateTestnetChainId(),
+    escrowAddress: faker.finance.ethereumAddress(),
+    retriesCount,
+    waitUntil: faker.date.future(),
+    status,
+    failureDetail: null,
+    createdAt: faker.date.recent(),
+    updatedAt: new Date(),
+  };
+}
+
+export function generateOutgoingWebhookPayload(
+  options?: GenerateOutgoingWebhookPayloadOptions,
+): Record<string, unknown> {
+  const escrowAddress =
+    options?.escrowAddress || faker.finance.ethereumAddress();
+
+  return {
+    chainId: generateTestnetChainId(),
+    eventType: OutgoingWebhookEventType.ESCROW_COMPLETED,
+    escrowAddress,
+  };
+}
+
+export function generateOutgoingWebhook(
+  options?: GenerateOutgoingWebhookOptions,
+): OutgoingWebhookEntity {
+  const retriesCount = options?.retriesCount || 0;
+  const status = options?.status || OutgoingWebhookStatus.PENDING;
+
+  const payload = generateOutgoingWebhookPayload();
+  const url = faker.internet.url();
+  const hash = crypto
+    .createHash('sha1')
+    .update(stringify({ payload, url }) as string)
+    .digest('hex');
+
+  return {
+    id: faker.number.int(),
+    payload,
+    hash,
+    url,
+    retriesCount,
+    waitUntil: faker.date.future(),
+    status,
+    failureDetail: null,
+    createdAt: faker.date.recent(),
+    updatedAt: new Date(),
+  };
+}
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/types.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/types.ts
new file mode 100644
index 0000000000..25c184514a
--- /dev/null
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/types.ts
@@ -0,0 +1,30 @@
+import { ChainId } from '@human-protocol/sdk';
+
+export type IncomingWebhookData = {
+  chainId: ChainId;
+  eventType: IncomingWebhookEventType;
+  escrowAddress: string;
+  eventData?: Record<string, unknown>;
+};
+
+export enum IncomingWebhookEventType {
+  JOB_COMPLETED = 'job_completed',
+}
+
+export enum OutgoingWebhookEventType {
+  ESCROW_COMPLETED = 'escrow_completed',
+  ABUSE_DETECTED = 'abuse_detected',
+  ABUSE_DISMISSED = 'abuse_dismissed',
+}
+
+export enum IncomingWebhookStatus {
+  PENDING = 'pending',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+}
+
+export enum OutgoingWebhookStatus {
+  PENDING = 'pending',
+  SENT = 'sent',
+  FAILED = 'failed',
+}
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.entity.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.entity.ts
index 25c669e2df..2c81aa199f 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.entity.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.entity.ts
@@ -2,30 +2,29 @@ import { Column, Entity, Index } from 'typeorm';
 
 import { DATABASE_SCHEMA_NAME } from '../../common/constants';
 import { BaseEntity } from '../../database/base.entity';
-import { WebhookIncomingStatus } from '../../common/enums';
-import { ChainId } from '@human-protocol/sdk';
+import { IncomingWebhookStatus } from './types';
 
 @Entity({ schema: DATABASE_SCHEMA_NAME, name: 'webhook_incoming' })
 @Index(['chainId', 'escrowAddress'], { unique: true })
-export class WebhookIncomingEntity extends BaseEntity {
+export class IncomingWebhookEntity extends BaseEntity {
   @Column({ type: 'int' })
-  public chainId: ChainId;
+  chainId: number;
 
   @Column({ type: 'varchar' })
-  public escrowAddress: string;
+  escrowAddress: string;
 
   @Column({ type: 'varchar', nullable: true })
-  public failureDetail: string;
+  failureDetail: string | null;
 
   @Column({ type: 'int' })
-  public retriesCount: number;
+  retriesCount: number;
 
   @Column({ type: 'timestamptz' })
-  public waitUntil: Date;
+  waitUntil: Date;
 
   @Column({
     type: 'enum',
-    enum: WebhookIncomingStatus,
+    enum: IncomingWebhookStatus,
   })
-  public status: WebhookIncomingStatus;
+  status: IncomingWebhookStatus;
 }
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.module.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.module.ts
index aba8b66063..b979a0efe6 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.module.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.module.ts
@@ -4,13 +4,13 @@ import { Module } from '@nestjs/common';
 import { EscrowCompletionModule } from '../escrow-completion/escrow-completion.module';
 
 import { WebhookController } from './webhook.controller';
-import { WebhookIncomingRepository } from './webhook-incoming.repository';
-import { WebhookIncomingService } from './webhook-incoming.service';
+import { IncomingWebhookRepository } from './webhook-incoming.repository';
+import { IncomingWebhookService } from './webhook-incoming.service';
 
 @Module({
   imports: [HttpModule, EscrowCompletionModule],
   controllers: [WebhookController],
-  providers: [WebhookIncomingService, WebhookIncomingRepository],
-  exports: [WebhookIncomingService],
+  providers: [IncomingWebhookService, IncomingWebhookRepository],
+  exports: [IncomingWebhookService],
 })
-export class WebhookIncomingModule {}
+export class IncomingWebhookModule {}
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.repository.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.repository.ts
index 2ccb1dad39..c965e1e026 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.repository.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.repository.ts
@@ -1,22 +1,23 @@
 import { Injectable } from '@nestjs/common';
-import { BaseRepository } from '../../database/base.repository';
 import { DataSource, LessThanOrEqual } from 'typeorm';
-import { WebhookIncomingStatus } from '../../common/enums/webhook';
-import { WebhookIncomingEntity } from './webhook-incoming.entity';
+
 import { ServerConfigService } from '../../config/server-config.service';
+import { BaseRepository } from '../../database/base.repository';
+import { IncomingWebhookStatus } from './types';
+import { IncomingWebhookEntity } from './webhook-incoming.entity';
 
 @Injectable()
-export class WebhookIncomingRepository extends BaseRepository<WebhookIncomingEntity> {
+export class IncomingWebhookRepository extends BaseRepository<IncomingWebhookEntity> {
   constructor(
-    private dataSource: DataSource,
-    public readonly serverConfigService: ServerConfigService,
+    dataSource: DataSource,
+    private readonly serverConfigService: ServerConfigService,
   ) {
-    super(WebhookIncomingEntity, dataSource);
+    super(IncomingWebhookEntity, dataSource);
   }
 
-  public findByStatus(
-    status: WebhookIncomingStatus,
-  ): Promise<WebhookIncomingEntity[]> {
+  findByStatus(
+    status: IncomingWebhookStatus,
+  ): Promise<IncomingWebhookEntity[]> {
     return this.find({
       where: {
         status,
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.spec.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.spec.ts
index 9bec7fc113..2bb5f58132 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.spec.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.spec.ts
@@ -1,298 +1,173 @@
+import { faker } from '@faker-js/faker';
 import { createMock } from '@golevelup/ts-jest';
-import { ChainId } from '@human-protocol/sdk';
-import { HttpService } from '@nestjs/axios';
-import { ConfigService } from '@nestjs/config';
 import { Test } from '@nestjs/testing';
-import {
-  MOCK_ADDRESS,
-  MOCK_MAX_RETRY_COUNT,
-  MOCK_PRIVATE_KEY,
-  mockConfig,
-} from '../../../test/constants';
-import { EventType, WebhookIncomingStatus } from '../../common/enums/webhook';
-import { Web3Service } from '../web3/web3.service';
-import { WebhookIncomingRepository } from './webhook-incoming.repository';
-import { WebhookOutgoingRepository } from './webhook-outgoing.repository';
-import { WebhookIncomingService } from './webhook-incoming.service';
-import { WebhookIncomingEntity } from './webhook-incoming.entity';
-import { IncomingWebhookDto } from './webhook.dto';
-import { Web3ConfigService } from '../../config/web3-config.service';
-import { ServerConfigService } from '../../config/server-config.service';
-import { ReputationService } from '../reputation/reputation.service';
-import { EscrowCompletionRepository } from '../escrow-completion/escrow-completion.repository';
-import { EscrowCompletionService } from '../escrow-completion/escrow-completion.service';
+
 import { PostgresErrorCodes } from '../../common/enums/database';
 import { DatabaseError } from '../../common/errors/database';
-import { WebhookOutgoingService } from './webhook-outgoing.service';
-import { PayoutService } from '../payout/payout.service';
-import { StorageService } from '../storage/storage.service';
-import { ReputationRepository } from '../reputation/reputation.repository';
-import { ReputationConfigService } from '../../config/reputation-config.service';
-import { S3ConfigService } from '../../config/s3-config.service';
-import { PGPConfigService } from '../../config/pgp-config.service';
-import { IncomingWebhookError, WebhookErrorMessage } from './webhook.error';
-import { EscrowPayoutsBatchRepository } from '../escrow-completion/escrow-payouts-batch.repository';
-import { PgpEncryptionService } from '../encryption/pgp-encryption.service';
+import { ServerConfigService } from '../../config/server-config.service';
+import { EscrowCompletionService } from '../escrow-completion/escrow-completion.service';
+import { generateTestnetChainId } from '../web3/fixtures';
 
-describe('WebhookIncomingService', () => {
-  let webhookIncomingService: WebhookIncomingService,
-    webhookIncomingRepository: WebhookIncomingRepository,
-    web3ConfigService: Web3ConfigService,
-    escrowCompletionService: EscrowCompletionService;
+import { generateIncomingWebhook } from './fixtures';
+import {
+  IncomingWebhookData,
+  IncomingWebhookEventType,
+  IncomingWebhookStatus,
+} from './types';
+import { IncomingWebhookRepository } from './webhook-incoming.repository';
+import { IncomingWebhookService } from './webhook-incoming.service';
 
-  const signerMock = {
-    address: MOCK_ADDRESS,
-    getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }),
-  };
+const mockServerConfigService = {
+  maxRetryCount: 1,
+};
 
-  // Mock ConfigService to return the mock configuration values
-  const mockConfigService = {
-    get: jest.fn((key: string) => mockConfig[key]),
-    getOrThrow: jest.fn((key: string) => {
-      if (!mockConfig[key])
-        throw new Error(`Configuration key "${key}" does not exist`);
-      return mockConfig[key];
-    }),
-  };
+const mockEscrowCompletionService = createMock<EscrowCompletionService>();
+const mockIncomingWebhookRepository = createMock<IncomingWebhookRepository>();
 
-  // Mock Web3Service
-  const mockWeb3Service = {
-    getSigner: jest.fn().mockReturnValue(signerMock),
-  };
+describe('WebhookIncomingService', () => {
+  let incomingWebhookService: IncomingWebhookService;
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     const moduleRef = await Test.createTestingModule({
       providers: [
-        WebhookIncomingService,
-        WebhookOutgoingService,
-        EscrowCompletionService,
-        Web3ConfigService,
-        ServerConfigService,
-        PayoutService,
-        PgpEncryptionService,
-        ReputationService,
-        HttpService,
-        ReputationConfigService,
-        S3ConfigService,
-        PGPConfigService,
-        {
-          provide: EscrowCompletionRepository,
-          useValue: createMock<EscrowCompletionRepository>(),
-        },
-        {
-          provide: StorageService,
-          useValue: createMock<StorageService>(),
-        },
+        IncomingWebhookService,
         {
-          provide: EscrowPayoutsBatchRepository,
-          useValue: createMock<EscrowPayoutsBatchRepository>(),
+          provide: ServerConfigService,
+          useValue: mockServerConfigService,
         },
         {
-          provide: WebhookOutgoingRepository,
-          useValue: createMock<WebhookOutgoingRepository>(),
+          provide: EscrowCompletionService,
+          useValue: mockEscrowCompletionService,
         },
         {
-          provide: ReputationRepository,
-          useValue: createMock<ReputationRepository>(),
+          provide: IncomingWebhookRepository,
+          useValue: mockIncomingWebhookRepository,
         },
-        // Mocked services
-        {
-          provide: ConfigService,
-          useValue: mockConfigService,
-        },
-        {
-          provide: Web3Service,
-          useValue: mockWeb3Service,
-        },
-        {
-          provide: WebhookIncomingRepository,
-          useValue: createMock<WebhookIncomingRepository>(),
-        },
-        { provide: HttpService, useValue: createMock<HttpService>() },
       ],
     }).compile();
 
-    // Assign injected dependencies to variables
-    webhookIncomingService = moduleRef.get<WebhookIncomingService>(
-      WebhookIncomingService,
+    incomingWebhookService = moduleRef.get<IncomingWebhookService>(
+      IncomingWebhookService,
     );
-    webhookIncomingRepository = moduleRef.get(WebhookIncomingRepository);
-    escrowCompletionService = moduleRef.get<EscrowCompletionService>(
-      EscrowCompletionService,
-    );
-    web3ConfigService = moduleRef.get(Web3ConfigService);
-
-    // Mocking privateKey getter
-    jest
-      .spyOn(web3ConfigService, 'privateKey', 'get')
-      .mockReturnValue(MOCK_PRIVATE_KEY);
   });
 
   afterEach(() => {
-    jest.clearAllMocks();
+    jest.resetAllMocks();
   });
 
   describe('createIncomingWebhook', () => {
-    const validDto: IncomingWebhookDto = {
-      chainId: ChainId.LOCALHOST,
-      escrowAddress: MOCK_ADDRESS,
-      eventType: EventType.JOB_COMPLETED,
-    };
-
-    const invalidDto: IncomingWebhookDto = {
-      chainId: ChainId.LOCALHOST,
-      escrowAddress: MOCK_ADDRESS,
-      eventType: 'JOB_FAILED' as EventType,
-    };
-
-    const webhookEntity: Partial<WebhookIncomingEntity> = {
-      chainId: ChainId.LOCALHOST,
-      escrowAddress: MOCK_ADDRESS,
-      status: WebhookIncomingStatus.PENDING,
-      waitUntil: new Date(),
-      retriesCount: 0,
-    };
-
-    it('should successfully create an incoming webhook with valid DTO', async () => {
-      jest
-        .spyOn(webhookIncomingRepository, 'createUnique')
-        .mockResolvedValue(webhookEntity as WebhookIncomingEntity);
+    it('should create an incoming webhook', async () => {
+      const data: IncomingWebhookData = {
+        chainId: generateTestnetChainId(),
+        eventType: IncomingWebhookEventType.JOB_COMPLETED,
+        escrowAddress: faker.finance.ethereumAddress(),
+      };
 
-      await webhookIncomingService.createIncomingWebhook(validDto);
+      await incomingWebhookService.createIncomingWebhook(data);
 
-      expect(webhookIncomingRepository.createUnique).toHaveBeenCalledWith(
+      expect(mockIncomingWebhookRepository.createUnique).toHaveBeenCalledTimes(
+        1,
+      );
+      expect(mockIncomingWebhookRepository.createUnique).toHaveBeenCalledWith(
         expect.objectContaining({
-          chainId: validDto.chainId,
-          escrowAddress: validDto.escrowAddress,
+          chainId: data.chainId,
+          escrowAddress: data.escrowAddress,
+          status: IncomingWebhookStatus.PENDING,
+          retriesCount: 0,
         }),
       );
     });
-
-    it('should throw BadRequestException with an invalid event type', async () => {
-      await expect(
-        webhookIncomingService.createIncomingWebhook(invalidDto),
-      ).rejects.toThrow(
-        new IncomingWebhookError(
-          WebhookErrorMessage.INVALID_EVENT_TYPE,
-          invalidDto.chainId,
-          invalidDto.escrowAddress,
-        ),
-      );
-    });
   });
 
   describe('processPendingIncomingWebhooks', () => {
-    let createEscrowCompletionMock: any;
-    let webhookEntity1: Partial<WebhookIncomingEntity>,
-      webhookEntity2: Partial<WebhookIncomingEntity>;
-
-    beforeEach(() => {
-      webhookEntity1 = {
-        id: 1,
-        chainId: ChainId.LOCALHOST,
-        escrowAddress: MOCK_ADDRESS,
-        status: WebhookIncomingStatus.PENDING,
-        waitUntil: new Date(),
-        retriesCount: 0,
-      };
-
-      webhookEntity2 = {
-        id: 2,
-        chainId: ChainId.LOCALHOST,
-        escrowAddress: MOCK_ADDRESS,
-        status: WebhookIncomingStatus.PENDING,
-        waitUntil: new Date(),
-        retriesCount: 0,
-      };
-
-      jest
-        .spyOn(webhookIncomingRepository, 'findByStatus')
-        .mockResolvedValue([webhookEntity1 as any, webhookEntity2 as any]);
-
-      createEscrowCompletionMock = jest.spyOn(
-        escrowCompletionService as any,
-        'createEscrowCompletion',
+    it('should process pending webhooks', async () => {
+      const incomingWebhookEntity = generateIncomingWebhook();
+
+      mockIncomingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        incomingWebhookEntity,
+      ]);
+
+      await incomingWebhookService.processPendingIncomingWebhooks();
+
+      expect(
+        mockEscrowCompletionService.createEscrowCompletion,
+      ).toHaveBeenCalledTimes(1);
+      expect(
+        mockEscrowCompletionService.createEscrowCompletion,
+      ).toHaveBeenCalledWith(
+        incomingWebhookEntity.chainId,
+        incomingWebhookEntity.escrowAddress,
       );
-      createEscrowCompletionMock.mockResolvedValue(undefined);
-    });
-
-    afterEach(() => {
-      jest.restoreAllMocks();
-    });
-
-    it('should process pending incoming webhooks and mark them as COMPLETED', async () => {
-      await webhookIncomingService.processPendingIncomingWebhooks();
 
-      expect(createEscrowCompletionMock).toHaveBeenCalledTimes(2);
-      expect(createEscrowCompletionMock).toHaveBeenCalledWith(
-        webhookEntity1.chainId,
-        webhookEntity1.escrowAddress,
-      );
-      expect(createEscrowCompletionMock).toHaveBeenCalledWith(
-        webhookEntity2.chainId,
-        webhookEntity2.escrowAddress,
+      incomingWebhookEntity.status = IncomingWebhookStatus.COMPLETED;
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledWith(
+        incomingWebhookEntity,
       );
-
-      expect(webhookIncomingRepository.updateOne).toHaveBeenCalledTimes(2);
-      expect(webhookEntity1.status).toBe(WebhookIncomingStatus.COMPLETED);
-      expect(webhookEntity2.status).toBe(WebhookIncomingStatus.COMPLETED);
     });
 
-    it('should retry the webhook if processing fails and retries are below threshold', async () => {
-      createEscrowCompletionMock.mockRejectedValueOnce(
-        new Error('Processing error'),
+    it('should increase retries count in case of an error', async () => {
+      const incomingWebhookEntity = generateIncomingWebhook();
+
+      mockIncomingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        incomingWebhookEntity,
+      ]);
+      mockEscrowCompletionService.createEscrowCompletion.mockRejectedValueOnce(
+        new Error(),
       );
 
-      await webhookIncomingService.processPendingIncomingWebhooks();
+      await incomingWebhookService.processPendingIncomingWebhooks();
 
-      expect(webhookIncomingRepository.updateOne).toHaveBeenCalledWith(
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          status: WebhookIncomingStatus.PENDING,
+          id: incomingWebhookEntity.id,
+          status: incomingWebhookEntity.status,
           retriesCount: 1,
         }),
       );
     });
 
-    it('should mark the webhook as FAILED if retries exceed the threshold', async () => {
-      const error = new Error('Processing error');
-      const loggerErrorSpy = jest.spyOn(
-        webhookIncomingService['logger'],
-        'error',
-      );
+    it('should continue in case of a duplicated error', async () => {
+      const incomingWebhookEntity = generateIncomingWebhook();
 
-      webhookEntity1.retriesCount = MOCK_MAX_RETRY_COUNT;
-      createEscrowCompletionMock.mockRejectedValueOnce(error);
+      mockIncomingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        incomingWebhookEntity,
+      ]);
+      mockEscrowCompletionService.createEscrowCompletion.mockRejectedValueOnce(
+        new DatabaseError(PostgresErrorCodes.Duplicated),
+      );
 
-      await webhookIncomingService.processPendingIncomingWebhooks();
+      await incomingWebhookService.processPendingIncomingWebhooks();
 
-      expect(webhookIncomingRepository.updateOne).toHaveBeenCalledWith(
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          status: WebhookIncomingStatus.FAILED,
-          retriesCount: MOCK_MAX_RETRY_COUNT,
+          id: incomingWebhookEntity.id,
+          status: IncomingWebhookStatus.COMPLETED,
         }),
       );
-      expect(loggerErrorSpy).toHaveBeenCalledWith(
-        'Error processing incoming webhook',
-        {
-          error,
-          webhookId: expect.any(Number),
-        },
-      );
     });
 
-    it('should handle duplicated errors and mark the webhook as COMPLETED', async () => {
-      createEscrowCompletionMock.mockImplementationOnce(() => {
-        throw new DatabaseError(
-          'Duplicate entry',
-          PostgresErrorCodes.Duplicated,
-        );
+    it('should set failed status if retries count exceeds the limit', async () => {
+      const incomingWebhookEntity = generateIncomingWebhook({
+        retriesCount: 1,
       });
 
-      await webhookIncomingService.processPendingIncomingWebhooks();
+      mockIncomingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        incomingWebhookEntity,
+      ]);
+      mockEscrowCompletionService.createEscrowCompletion.mockRejectedValueOnce(
+        new Error(),
+      );
+
+      await incomingWebhookService.processPendingIncomingWebhooks();
 
-      expect(webhookIncomingRepository.updateOne).toHaveBeenCalledWith(
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockIncomingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          status: WebhookIncomingStatus.COMPLETED,
+          id: incomingWebhookEntity.id,
+          status: IncomingWebhookStatus.FAILED,
         }),
       );
     });
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.ts
index b02ccab0aa..b3a17a16f2 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-incoming.service.ts
@@ -1,65 +1,41 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { Injectable } from '@nestjs/common';
-import { ServerConfigService } from '../../config/server-config.service';
-import { Web3ConfigService } from '../../config/web3-config.service';
+
 import { BACKOFF_INTERVAL_SECONDS } from '../../common/constants';
-import { EventType, WebhookIncomingStatus } from '../../common/enums';
-import { calculateExponentialBackoffMs } from '../../utils/backoff';
 import { isDuplicatedError } from '../../common/errors/database';
+import { ServerConfigService } from '../../config/server-config.service';
 import { EscrowCompletionService } from '../escrow-completion/escrow-completion.service';
-import { WebhookIncomingEntity } from './webhook-incoming.entity';
-import { WebhookIncomingRepository } from './webhook-incoming.repository';
-import { IncomingWebhookDto } from './webhook.dto';
-import { IncomingWebhookError, WebhookErrorMessage } from './webhook.error';
+import { calculateExponentialBackoffMs } from '../../utils/backoff';
 import logger from '../../logger';
 
+import { IncomingWebhookData, IncomingWebhookStatus } from './types';
+import { IncomingWebhookEntity } from './webhook-incoming.entity';
+import { IncomingWebhookRepository } from './webhook-incoming.repository';
+
 @Injectable()
-export class WebhookIncomingService {
+export class IncomingWebhookService {
   private readonly logger = logger.child({
-    context: WebhookIncomingService.name,
+    context: IncomingWebhookService.name,
   });
 
   constructor(
-    private readonly webhookIncomingRepository: WebhookIncomingRepository,
     private readonly escrowCompletionService: EscrowCompletionService,
-    public readonly serverConfigService: ServerConfigService,
-    public readonly web3ConfigService: Web3ConfigService,
+    private readonly incomingWebhookRepository: IncomingWebhookRepository,
+    private readonly serverConfigService: ServerConfigService,
   ) {}
 
-  /**
-   * Creates an incoming webhook entry in the repository.
-   * Validates that the event type is 'JOB_COMPLETED' and sets initial status to 'PENDING'.
-   * @param {IncomingWebhookDto} dto - Contains webhook details like chain ID and escrow address.
-   * @throws {IncomingWebhookError} If the event type is invalid or the webhook cannot be created.
-   */
-  public async createIncomingWebhook(dto: IncomingWebhookDto): Promise<void> {
-    if (dto.eventType !== EventType.JOB_COMPLETED) {
-      throw new IncomingWebhookError(
-        WebhookErrorMessage.INVALID_EVENT_TYPE,
-        dto.chainId,
-        dto.escrowAddress,
-      );
-    }
-
-    let webhookEntity = new WebhookIncomingEntity();
-    webhookEntity.chainId = dto.chainId;
-    webhookEntity.escrowAddress = dto.escrowAddress;
-    webhookEntity.status = WebhookIncomingStatus.PENDING;
+  async createIncomingWebhook(data: IncomingWebhookData): Promise<void> {
+    const webhookEntity = new IncomingWebhookEntity();
+    webhookEntity.chainId = data.chainId;
+    webhookEntity.escrowAddress = data.escrowAddress;
+    webhookEntity.status = IncomingWebhookStatus.PENDING;
     webhookEntity.waitUntil = new Date();
     webhookEntity.retriesCount = 0;
 
-    webhookEntity =
-      await this.webhookIncomingRepository.createUnique(webhookEntity);
+    await this.incomingWebhookRepository.createUnique(webhookEntity);
   }
 
-  /**
-   * Handles errors that occur while processing an incoming webhook.
-   * If retry count is below the maximum, increments retry count and reschedules; otherwise, marks as 'FAILED'.
-   * @param webhookEntity - The incoming webhook entity.
-   * @param failureDetail - Reason for the failure.
-   */
-  private async handleWebhookIncomingError(
-    webhookEntity: WebhookIncomingEntity,
+  private async handleIncomingWebhookProcessingError(
+    webhookEntity: IncomingWebhookEntity,
     failureDetail: string,
   ): Promise<void> {
     if (webhookEntity.retriesCount < this.serverConfigService.maxRetryCount) {
@@ -71,14 +47,14 @@ export class WebhookIncomingService {
       webhookEntity.retriesCount += 1;
     } else {
       webhookEntity.failureDetail = failureDetail;
-      webhookEntity.status = WebhookIncomingStatus.FAILED;
+      webhookEntity.status = IncomingWebhookStatus.FAILED;
     }
-    await this.webhookIncomingRepository.updateOne(webhookEntity);
+    await this.incomingWebhookRepository.updateOne(webhookEntity);
   }
 
-  public async processPendingIncomingWebhooks(): Promise<void> {
-    const webhookEntities = await this.webhookIncomingRepository.findByStatus(
-      WebhookIncomingStatus.PENDING,
+  async processPendingIncomingWebhooks(): Promise<void> {
+    const webhookEntities = await this.incomingWebhookRepository.findByStatus(
+      IncomingWebhookStatus.PENDING,
     );
 
     for (const webhookEntity of webhookEntities) {
@@ -90,20 +66,19 @@ export class WebhookIncomingService {
           escrowAddress,
         );
 
-        webhookEntity.status = WebhookIncomingStatus.COMPLETED;
-        await this.webhookIncomingRepository.updateOne(webhookEntity);
+        webhookEntity.status = IncomingWebhookStatus.COMPLETED;
+        await this.incomingWebhookRepository.updateOne(webhookEntity);
       } catch (error) {
         if (isDuplicatedError(error)) {
-          webhookEntity.status = WebhookIncomingStatus.COMPLETED;
-          await this.webhookIncomingRepository.updateOne(webhookEntity);
+          webhookEntity.status = IncomingWebhookStatus.COMPLETED;
+          await this.incomingWebhookRepository.updateOne(webhookEntity);
         } else {
-          // Handle other errors (general failure)
           this.logger.error('Error processing incoming webhook', {
             error,
             webhookId: webhookEntity.id,
           });
 
-          await this.handleWebhookIncomingError(
+          await this.handleIncomingWebhookProcessingError(
             webhookEntity,
             `Error message: ${error.message}`,
           );
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.entity.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.entity.ts
index 743825888d..bf68fa51f3 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.entity.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.entity.ts
@@ -2,32 +2,32 @@ import { Column, Entity, Index } from 'typeorm';
 
 import { DATABASE_SCHEMA_NAME } from '../../common/constants';
 import { BaseEntity } from '../../database/base.entity';
-import { WebhookOutgoingStatus } from '../../common/enums';
+import { OutgoingWebhookStatus } from './types';
 
 @Entity({ schema: DATABASE_SCHEMA_NAME, name: 'webhook_outgoing' })
 @Index(['hash'], { unique: true })
-export class WebhookOutgoingEntity extends BaseEntity {
+export class OutgoingWebhookEntity extends BaseEntity {
   @Column({ type: 'jsonb' })
-  public payload: Record<string, unknown>;
+  payload: Record<string, unknown>;
 
   @Column({ type: 'varchar' })
-  public hash: string;
+  hash: string;
 
   @Column({ type: 'varchar' })
-  public url: string;
+  url: string;
 
   @Column({ type: 'varchar', nullable: true })
-  public failureDetail: string;
+  failureDetail: string | null;
 
   @Column({ type: 'int' })
-  public retriesCount: number;
+  retriesCount: number;
 
   @Column({ type: 'timestamptz' })
-  public waitUntil: Date;
+  waitUntil: Date;
 
   @Column({
     type: 'enum',
-    enum: WebhookOutgoingStatus,
+    enum: OutgoingWebhookStatus,
   })
-  public status: WebhookOutgoingStatus;
+  status: OutgoingWebhookStatus;
 }
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.module.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.module.ts
index 947e12c163..15c63e0d85 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.module.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.module.ts
@@ -3,12 +3,12 @@ import { Module } from '@nestjs/common';
 
 import { Web3Module } from '../web3/web3.module';
 
-import { WebhookOutgoingRepository } from './webhook-outgoing.repository';
-import { WebhookOutgoingService } from './webhook-outgoing.service';
+import { OutgoingWebhookRepository } from './webhook-outgoing.repository';
+import { OutgoingWebhookService } from './webhook-outgoing.service';
 
 @Module({
   imports: [Web3Module, HttpModule],
-  providers: [WebhookOutgoingService, WebhookOutgoingRepository],
-  exports: [WebhookOutgoingService],
+  providers: [OutgoingWebhookService, OutgoingWebhookRepository],
+  exports: [OutgoingWebhookService],
 })
-export class WebhookOutgoingModule {}
+export class OutgoingWebhookModule {}
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.repository.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.repository.ts
index a2b99adb3d..1d6cac026a 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.repository.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.repository.ts
@@ -1,22 +1,23 @@
 import { Injectable } from '@nestjs/common';
-import { BaseRepository } from '../../database/base.repository';
 import { DataSource, LessThanOrEqual } from 'typeorm';
-import { WebhookOutgoingStatus } from '../../common/enums/webhook';
-import { WebhookOutgoingEntity } from './webhook-outgoing.entity';
+
 import { ServerConfigService } from '../../config/server-config.service';
+import { BaseRepository } from '../../database/base.repository';
+import { OutgoingWebhookStatus } from './types';
+import { OutgoingWebhookEntity } from './webhook-outgoing.entity';
 
 @Injectable()
-export class WebhookOutgoingRepository extends BaseRepository<WebhookOutgoingEntity> {
+export class OutgoingWebhookRepository extends BaseRepository<OutgoingWebhookEntity> {
   constructor(
-    private dataSource: DataSource,
-    public readonly serverConfigService: ServerConfigService,
+    dataSource: DataSource,
+    private readonly serverConfigService: ServerConfigService,
   ) {
-    super(WebhookOutgoingEntity, dataSource);
+    super(OutgoingWebhookEntity, dataSource);
   }
 
-  public findByStatus(
-    status: WebhookOutgoingStatus,
-  ): Promise<WebhookOutgoingEntity[]> {
+  findByStatus(
+    status: OutgoingWebhookStatus,
+  ): Promise<OutgoingWebhookEntity[]> {
     return this.find({
       where: {
         status,
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.spec.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.spec.ts
index 9bee57c77b..d2841f8d0a 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.spec.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.spec.ts
@@ -1,291 +1,196 @@
-import * as crypto from 'crypto';
-import stringify from 'json-stable-stringify';
+import { faker } from '@faker-js/faker';
 import { createMock } from '@golevelup/ts-jest';
-import { ChainId } from '@human-protocol/sdk';
 import { HttpService } from '@nestjs/axios';
-import { ConfigService } from '@nestjs/config';
 import { Test } from '@nestjs/testing';
+import * as crypto from 'crypto';
+import stringify from 'json-stable-stringify';
+
 import {
-  MOCK_ADDRESS,
-  MOCK_FILE_HASH,
-  MOCK_FILE_URL,
-  MOCK_MAX_RETRY_COUNT,
-  MOCK_PRIVATE_KEY,
-  MOCK_WEBHOOK_URL,
-  mockConfig,
-} from '../../../test/constants';
-import { EventType, WebhookOutgoingStatus } from '../../common/enums/webhook';
-import { Web3Service } from '../web3/web3.service';
-import { WebhookOutgoingRepository } from './webhook-outgoing.repository';
-import { WebhookOutgoingService } from './webhook-outgoing.service';
-import { WebhookOutgoingEntity } from './webhook-outgoing.entity';
-import { of } from 'rxjs';
+  createHttpServiceMock,
+  createHttpServiceResponse,
+} from '../../../test/mock-creators/nest';
 import { HEADER_SIGNATURE_KEY } from '../../common/constants';
-import { signMessage } from '../../utils/web3';
-import { HttpStatus } from '@nestjs/common';
-import { Web3ConfigService } from '../../config/web3-config.service';
 import { ServerConfigService } from '../../config/server-config.service';
-import { OutgoingWebhookError, WebhookErrorMessage } from './webhook.error';
+import { Web3ConfigService } from '../../config/web3-config.service';
+import { transformKeysFromCamelToSnake } from '../../utils/case-converters';
+import { signMessage } from '../../utils/web3';
+import { mockWeb3ConfigService } from '../web3/fixtures';
+import {
+  generateOutgoingWebhookPayload,
+  generateOutgoingWebhook,
+} from './fixtures';
+import { OutgoingWebhookStatus } from './types';
+import { OutgoingWebhookRepository } from './webhook-outgoing.repository';
+import { OutgoingWebhookService } from './webhook-outgoing.service';
+
+const mockServerConfigService = {
+  maxRetryCount: 1,
+};
+
+const mockOutgoingWebhookRepository = createMock<OutgoingWebhookRepository>();
+const mockHttpService = createHttpServiceMock();
 
 describe('WebhookOutgoingService', () => {
-  let webhookOutgoingService: WebhookOutgoingService,
-    webhookOutgoingRepository: WebhookOutgoingRepository,
-    httpService: HttpService,
-    web3ConfigService: Web3ConfigService;
-
-  const signerMock = {
-    address: MOCK_ADDRESS,
-    getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }),
-  };
-
-  // Mock ConfigService to return the mock configuration values
-  const mockConfigService = {
-    get: jest.fn((key: string) => mockConfig[key]),
-    getOrThrow: jest.fn((key: string) => {
-      if (!mockConfig[key])
-        throw new Error(`Configuration key "${key}" does not exist`);
-      return mockConfig[key];
-    }),
-  };
-
-  // Mock Web3Service
-  const mockWeb3Service = {
-    getSigner: jest.fn().mockReturnValue(signerMock),
-  };
-
-  beforeEach(async () => {
+  let outgoingWebhookService: OutgoingWebhookService;
+
+  beforeAll(async () => {
     const moduleRef = await Test.createTestingModule({
       providers: [
-        WebhookOutgoingService,
-        Web3ConfigService,
-        ServerConfigService,
-        HttpService,
-        // Mocked services
+        OutgoingWebhookService,
         {
-          provide: ConfigService,
-          useValue: mockConfigService,
+          provide: ServerConfigService,
+          useValue: mockServerConfigService,
         },
         {
-          provide: Web3Service,
-          useValue: mockWeb3Service,
+          provide: OutgoingWebhookRepository,
+          useValue: mockOutgoingWebhookRepository,
         },
         {
-          provide: WebhookOutgoingRepository,
-          useValue: createMock<WebhookOutgoingRepository>(),
+          provide: HttpService,
+          useValue: mockHttpService,
         },
-        { provide: HttpService, useValue: createMock<HttpService>() },
+        { provide: Web3ConfigService, useValue: mockWeb3ConfigService },
       ],
     }).compile();
 
-    // Assign injected dependencies to variables
-    webhookOutgoingService = moduleRef.get<WebhookOutgoingService>(
-      WebhookOutgoingService,
+    outgoingWebhookService = moduleRef.get<OutgoingWebhookService>(
+      OutgoingWebhookService,
     );
-    webhookOutgoingRepository = moduleRef.get(WebhookOutgoingRepository);
-    httpService = moduleRef.get(HttpService);
-    web3ConfigService = moduleRef.get(Web3ConfigService);
-
-    // Mocking privateKey getter
-    jest
-      .spyOn(web3ConfigService, 'privateKey', 'get')
-      .mockReturnValue(MOCK_PRIVATE_KEY);
   });
 
   afterEach(() => {
-    jest.clearAllMocks();
+    jest.resetAllMocks();
   });
 
   describe('createOutgoingWebhook', () => {
-    const payload = {
-      chainId: ChainId.LOCALHOST,
-      escrowAddress: MOCK_ADDRESS,
-      eventType: EventType.ESCROW_COMPLETED,
-      waitUntil: new Date(),
-      retriesCount: 0,
-    };
-
-    const url = MOCK_FILE_URL;
-
-    const hash = crypto
-      .createHash('sha1')
-      .update(stringify({ payload, url }) as string)
-      .digest('hex');
-
-    const webhookEntity: Partial<WebhookOutgoingEntity> = {
-      payload,
-      url,
-      hash,
-      status: WebhookOutgoingStatus.PENDING,
-    };
-
-    it('should successfully create outgoing webhook with valid DTO', async () => {
-      jest
-        .spyOn(webhookOutgoingRepository, 'createUnique')
-        .mockResolvedValue(webhookEntity as WebhookOutgoingEntity);
-
-      await webhookOutgoingService.createOutgoingWebhook(payload, url);
-
-      expect(webhookOutgoingRepository.createUnique).toHaveBeenCalledWith({
-        ...webhookEntity,
-        waitUntil: expect.any(Date),
-        retriesCount: 0,
-      });
-    });
-  });
+    it('should create outgoing webhook', async () => {
+      const payload = generateOutgoingWebhookPayload();
+      const url = faker.internet.url();
 
-  describe('sendWebhook', () => {
-    const payload = {
-      chainId: ChainId.LOCALHOST,
-      escrowAddress: MOCK_ADDRESS,
-      eventType: EventType.ESCROW_COMPLETED,
-    };
-    const webhook: any = {
-      hash: 'test',
-      url: MOCK_WEBHOOK_URL,
-      payload,
-    };
-
-    it('should successfully send a webhook', async () => {
-      jest.spyOn(httpService as any, 'post').mockImplementation(() => {
-        return of({
-          status: HttpStatus.CREATED,
-        });
-      });
-      expect(await webhookOutgoingService.sendWebhook(webhook)).toBe(undefined);
+      const hash = crypto
+        .createHash('sha1')
+        .update(stringify({ payload, url }) as string)
+        .digest('hex');
 
-      const expectedBody = {
-        chain_id: payload.chainId,
-        escrow_address: payload.escrowAddress,
-        event_type: payload.eventType,
-      };
+      await outgoingWebhookService.createOutgoingWebhook(payload, url);
 
-      expect(httpService.post).toHaveBeenCalledWith(
-        MOCK_WEBHOOK_URL,
-        expectedBody,
-        {
-          headers: {
-            [HEADER_SIGNATURE_KEY]: await signMessage(
-              expectedBody,
-              MOCK_PRIVATE_KEY,
-            ),
-          },
-        },
+      expect(mockOutgoingWebhookRepository.createUnique).toHaveBeenCalledTimes(
+        1,
       );
-    });
-    it('should return an error if there is no response', async () => {
-      jest.spyOn(httpService as any, 'post').mockImplementation(() => {
-        return of({});
-      });
-      await expect(webhookOutgoingService.sendWebhook(webhook)).rejects.toThrow(
-        new OutgoingWebhookError(WebhookErrorMessage.NOT_SENT, webhook.hash),
+      expect(mockOutgoingWebhookRepository.createUnique).toHaveBeenCalledWith(
+        expect.objectContaining({
+          payload,
+          hash,
+          url,
+          status: OutgoingWebhookStatus.PENDING,
+        }),
       );
     });
   });
 
   describe('processPendingOutgoingWebhooks', () => {
-    let sendWebhookMock: any;
-    let webhookEntity1: Partial<WebhookOutgoingEntity>,
-      webhookEntity2: Partial<WebhookOutgoingEntity>;
-
-    beforeEach(() => {
-      webhookEntity1 = {
-        id: 1,
-        payload: {
-          chainId: ChainId.LOCALHOST,
-          escrowAddress: MOCK_ADDRESS,
-          eventType: EventType.ESCROW_COMPLETED,
-        },
-        hash: MOCK_FILE_HASH,
-        url: MOCK_FILE_URL,
-        status: WebhookOutgoingStatus.PENDING,
-        waitUntil: new Date(),
-        retriesCount: 0,
-      };
-
-      webhookEntity2 = {
-        id: 2,
-        payload: {
-          chainId: ChainId.LOCALHOST,
-          escrowAddress: MOCK_ADDRESS,
-          eventType: EventType.ESCROW_COMPLETED,
-        },
-        hash: MOCK_FILE_HASH,
-        url: MOCK_FILE_URL,
-        status: WebhookOutgoingStatus.PENDING,
-        waitUntil: new Date(),
-        retriesCount: 0,
-      };
-
-      jest
-        .spyOn(webhookOutgoingRepository, 'findByStatus')
-        .mockResolvedValue([webhookEntity1 as any, webhookEntity2 as any]);
-
-      sendWebhookMock = jest.spyOn(
-        webhookOutgoingService as any,
-        'sendWebhook',
-      );
-      sendWebhookMock.mockResolvedValue();
+    let spyOnSendWebhook: jest.SpyInstance;
+
+    beforeAll(() => {
+      spyOnSendWebhook = jest
+        .spyOn(outgoingWebhookService, 'sendWebhook')
+        .mockImplementation();
     });
 
-    afterEach(() => {
-      jest.restoreAllMocks();
+    afterAll(() => {
+      spyOnSendWebhook.mockRestore();
     });
 
-    it('should mark the webhook as SENT when sending webhook succeeds', async () => {
-      sendWebhookMock.mockResolvedValueOnce(undefined);
+    it('should process pending webhooks', async () => {
+      const outgoingWebhookEntity = generateOutgoingWebhook();
+
+      mockOutgoingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        outgoingWebhookEntity,
+      ]);
+
+      spyOnSendWebhook.mockResolvedValueOnce(null);
 
-      await webhookOutgoingService.processPendingOutgoingWebhooks();
+      await outgoingWebhookService.processPendingOutgoingWebhooks();
 
-      expect(webhookOutgoingRepository.updateOne).toHaveBeenCalledWith(
+      expect(outgoingWebhookService.sendWebhook).toHaveBeenCalledTimes(1);
+      expect(outgoingWebhookService.sendWebhook).toHaveBeenCalledWith(
+        outgoingWebhookEntity,
+      );
+
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          id: webhookEntity1.id,
-          status: WebhookOutgoingStatus.SENT,
+          id: outgoingWebhookEntity.id,
+          status: OutgoingWebhookStatus.SENT,
         }),
       );
-      expect(webhookEntity1.status).toBe(WebhookOutgoingStatus.SENT);
     });
 
-    it('should increment retriesCount and set waitUntil when sending webhook fails', async () => {
-      sendWebhookMock.mockRejectedValueOnce(new Error('Network error'));
+    it('should increase retries count in case of an error', async () => {
+      const outgoingWebhookEntity = generateOutgoingWebhook();
+
+      mockOutgoingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        outgoingWebhookEntity,
+      ]);
+      spyOnSendWebhook.mockRejectedValueOnce(new Error());
 
-      await webhookOutgoingService.processPendingOutgoingWebhooks();
+      await outgoingWebhookService.processPendingOutgoingWebhooks();
 
-      expect(webhookOutgoingRepository.updateOne).toHaveBeenCalledWith(
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          id: webhookEntity1.id,
+          id: outgoingWebhookEntity.id,
+          status: outgoingWebhookEntity.status,
           retriesCount: 1,
-          waitUntil: expect.any(Date),
-          status: WebhookOutgoingStatus.PENDING,
         }),
       );
-      expect(webhookEntity1.retriesCount).toBe(1);
-      expect(webhookEntity1.waitUntil).toBeInstanceOf(Date);
     });
 
-    it('should mark webhook as FAILED if retry count exceeds threshold', async () => {
-      const error = new Error('Random Error');
-      const loggerErrorSpy = jest.spyOn(
-        webhookOutgoingService['logger'],
-        'error',
-      );
-
-      sendWebhookMock.mockRejectedValueOnce(error);
+    it('should set failed status if retries count exceeds the limit', async () => {
+      const outgoingWebhookEntity = generateOutgoingWebhook({
+        retriesCount: 1,
+      });
 
-      webhookEntity1.retriesCount = MOCK_MAX_RETRY_COUNT;
+      mockOutgoingWebhookRepository.findByStatus.mockResolvedValueOnce([
+        outgoingWebhookEntity,
+      ]);
+      spyOnSendWebhook.mockRejectedValueOnce(new Error());
 
-      await webhookOutgoingService.processPendingOutgoingWebhooks();
+      await outgoingWebhookService.processPendingOutgoingWebhooks();
 
-      expect(webhookOutgoingRepository.updateOne).toHaveBeenCalledWith(
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledTimes(1);
+      expect(mockOutgoingWebhookRepository.updateOne).toHaveBeenCalledWith(
         expect.objectContaining({
-          status: WebhookOutgoingStatus.FAILED,
+          id: outgoingWebhookEntity.id,
+          status: OutgoingWebhookStatus.FAILED,
         }),
       );
-      expect(loggerErrorSpy).toHaveBeenCalledWith(
-        'Error processing outgoing webhook',
-        {
-          error,
-          webhookId: expect.any(Number),
-        },
+    });
+  });
+
+  describe('sendWebhook', () => {
+    it('should send a webhook with correct parameters', async () => {
+      const outgoingWebhookEntity = generateOutgoingWebhook();
+
+      const expectedPayload = transformKeysFromCamelToSnake(
+        outgoingWebhookEntity.payload,
+      ) as object;
+      const expectedSignature = await signMessage(
+        expectedPayload,
+        mockWeb3ConfigService.privateKey,
+      );
+
+      mockHttpService.post.mockReturnValueOnce(
+        createHttpServiceResponse(200, {}),
+      );
+
+      await outgoingWebhookService.sendWebhook(outgoingWebhookEntity);
+
+      expect(mockHttpService.post).toHaveBeenCalledTimes(1);
+      expect(mockHttpService.post).toHaveBeenCalledWith(
+        outgoingWebhookEntity.url,
+        expectedPayload,
+        { headers: { [HEADER_SIGNATURE_KEY]: expectedSignature } },
       );
     });
   });
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.ts
index 6f8fa32cdd..ba0ff0b2c3 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook-outgoing.service.ts
@@ -1,45 +1,39 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { HttpService } from '@nestjs/axios';
+import { Injectable } from '@nestjs/common';
 import * as crypto from 'crypto';
 import stringify from 'json-stable-stringify';
-import { HttpStatus, Injectable } from '@nestjs/common';
-import { WebhookOutgoingStatus } from '../../common/enums';
 import { firstValueFrom } from 'rxjs';
-import { signMessage } from '../../utils/web3';
+
 import {
   BACKOFF_INTERVAL_SECONDS,
   HEADER_SIGNATURE_KEY,
 } from '../../common/constants';
-import { HttpService } from '@nestjs/axios';
-import { transformKeysFromCamelToSnake } from '../../utils/case-converters';
 import { ServerConfigService } from '../../config/server-config.service';
 import { Web3ConfigService } from '../../config/web3-config.service';
-import { WebhookOutgoingEntity } from './webhook-outgoing.entity';
-import { WebhookOutgoingRepository } from './webhook-outgoing.repository';
 import { calculateExponentialBackoffMs } from '../../utils/backoff';
-import { OutgoingWebhookError, WebhookErrorMessage } from './webhook.error';
+import { transformKeysFromCamelToSnake } from '../../utils/case-converters';
+import { formatAxiosError } from '../../utils/http';
+import { signMessage } from '../../utils/web3';
 import logger from '../../logger';
 
+import { OutgoingWebhookStatus } from './types';
+import { OutgoingWebhookEntity } from './webhook-outgoing.entity';
+import { OutgoingWebhookRepository } from './webhook-outgoing.repository';
+
 @Injectable()
-export class WebhookOutgoingService {
+export class OutgoingWebhookService {
   private readonly logger = logger.child({
-    context: WebhookOutgoingService.name,
+    context: OutgoingWebhookService.name,
   });
 
   constructor(
     private readonly httpService: HttpService,
-    private readonly webhookOutgoingRepository: WebhookOutgoingRepository,
-    public readonly serverConfigService: ServerConfigService,
-    public readonly web3ConfigService: Web3ConfigService,
+    private readonly outgoingWebhookRepository: OutgoingWebhookRepository,
+    private readonly serverConfigService: ServerConfigService,
+    private readonly web3ConfigService: Web3ConfigService,
   ) {}
 
-  /**
-   * Creates an outgoing webhook entry in the repository.
-   * Sets initial status to 'PENDING' and stores the provided payload, hash, and URL.
-   * @param {object} payload - The payload to send in the webhook.
-   * @param {string} hash - A hash generated from the URL and payload for unique identification.
-   * @param {string} url - The destination URL for the outgoing webhook.
-   */
-  public async createOutgoingWebhook(
+  async createOutgoingWebhook(
     payload: Record<string, unknown>,
     url: string,
   ): Promise<void> {
@@ -48,26 +42,19 @@ export class WebhookOutgoingService {
       .update(stringify({ payload, url }) as string)
       .digest('hex');
 
-    let webhookEntity = new WebhookOutgoingEntity();
+    const webhookEntity = new OutgoingWebhookEntity();
     webhookEntity.payload = payload;
     webhookEntity.hash = hash;
     webhookEntity.url = url;
-    webhookEntity.status = WebhookOutgoingStatus.PENDING;
+    webhookEntity.status = OutgoingWebhookStatus.PENDING;
     webhookEntity.waitUntil = new Date();
     webhookEntity.retriesCount = 0;
 
-    webhookEntity =
-      await this.webhookOutgoingRepository.createUnique(webhookEntity);
+    await this.outgoingWebhookRepository.createUnique(webhookEntity);
   }
 
-  /**
-   * Handles errors that occur while processing an outgoing webhook.
-   * If retry count is below the maximum, increments retry count and reschedules; otherwise, marks as 'FAILED'.
-   * @param webhookEntity - The outgoing webhook entity.
-   * @param failureDetail - Reason for the failure.
-   */
-  private async handleWebhookOutgoingError(
-    webhookEntity: WebhookOutgoingEntity,
+  private async handleOutgoingWebhookProcessingError(
+    webhookEntity: OutgoingWebhookEntity,
     failureDetail: string,
   ): Promise<void> {
     if (webhookEntity.retriesCount < this.serverConfigService.maxRetryCount) {
@@ -79,21 +66,12 @@ export class WebhookOutgoingService {
       webhookEntity.retriesCount += 1;
     } else {
       webhookEntity.failureDetail = failureDetail;
-      webhookEntity.status = WebhookOutgoingStatus.FAILED;
+      webhookEntity.status = OutgoingWebhookStatus.FAILED;
     }
-    await this.webhookOutgoingRepository.updateOne(webhookEntity);
+    await this.outgoingWebhookRepository.updateOne(webhookEntity);
   }
 
-  /**
-   * Sends a webhook request with a signed payload.
-   * Converts payload to snake_case, signs it, and sends it to the specified URL.
-   * @param {string} url - The target URL to which the webhook is sent.
-   * @param {object} payload - The data payload to send.
-   * @throws {OutgoingWebhookError} If the webhook request fails.
-   */
-  public async sendWebhook(
-    outgoingWebhook: WebhookOutgoingEntity,
-  ): Promise<void> {
+  async sendWebhook(outgoingWebhook: OutgoingWebhookEntity): Promise<void> {
     const snake_case_body = transformKeysFromCamelToSnake(
       outgoingWebhook.payload,
     ) as object;
@@ -101,42 +79,39 @@ export class WebhookOutgoingService {
       snake_case_body,
       this.web3ConfigService.privateKey,
     );
-    const { status } = await firstValueFrom(
-      await this.httpService.post(outgoingWebhook.url, snake_case_body, {
-        headers: { [HEADER_SIGNATURE_KEY]: signedBody },
-      }),
-    );
-
-    if (status !== HttpStatus.CREATED) {
-      throw new OutgoingWebhookError(
-        WebhookErrorMessage.NOT_SENT,
-        outgoingWebhook.hash,
+    try {
+      await firstValueFrom(
+        this.httpService.post(outgoingWebhook.url, snake_case_body, {
+          headers: { [HEADER_SIGNATURE_KEY]: signedBody },
+        }),
       );
+    } catch (error) {
+      const formattedError = formatAxiosError(error);
+      this.logger.error('Webhook not sent', {
+        error: formattedError,
+        hash: outgoingWebhook.hash,
+      });
+      throw new Error(formattedError.message);
     }
   }
 
-  public async processPendingOutgoingWebhooks(): Promise<void> {
-    const webhookEntities = await this.webhookOutgoingRepository.findByStatus(
-      WebhookOutgoingStatus.PENDING,
+  async processPendingOutgoingWebhooks(): Promise<void> {
+    const webhookEntities = await this.outgoingWebhookRepository.findByStatus(
+      OutgoingWebhookStatus.PENDING,
     );
 
     for (const webhookEntity of webhookEntities) {
       try {
         await this.sendWebhook(webhookEntity);
       } catch (error) {
-        this.logger.error('Error processing outgoing webhook', {
-          error,
-          webhookId: webhookEntity.id,
-        });
-
-        await this.handleWebhookOutgoingError(
+        await this.handleOutgoingWebhookProcessingError(
           webhookEntity,
           `Error message: ${error.message}`,
         );
         continue;
       }
-      webhookEntity.status = WebhookOutgoingStatus.SENT;
-      await this.webhookOutgoingRepository.updateOne(webhookEntity);
+      webhookEntity.status = OutgoingWebhookStatus.SENT;
+      await this.outgoingWebhookRepository.updateOne(webhookEntity);
     }
   }
 }
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.controller.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.controller.ts
index a68bf3e65b..3b56628c6c 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.controller.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.controller.ts
@@ -1,34 +1,26 @@
-import {
-  Body,
-  Controller,
-  HttpCode,
-  Post,
-  UseFilters,
-  UseGuards,
-} from '@nestjs/common';
+import { Body, Controller, HttpCode, Post, UseGuards } from '@nestjs/common';
 
 import {
-  ApiTags,
+  ApiBody,
+  ApiHeader,
   ApiOperation,
   ApiResponse,
-  ApiHeader,
-  ApiBody,
+  ApiTags,
 } from '@nestjs/swagger';
+
 import { HEADER_SIGNATURE_KEY } from '../../common/constants';
 import { Public } from '../../common/decorators';
 import { AuthSignatureRole, SignatureAuthGuard } from '../../common/guards';
 
-import { WebhookIncomingService } from './webhook-incoming.service';
+import { IncomingWebhookService } from './webhook-incoming.service';
 import { IncomingWebhookDto } from './webhook.dto';
-import { IncomingWebhookErrorFilter } from './webhook.error.filter';
 
 @Public()
 @ApiTags('Webhook')
 @Controller('/webhook')
-@UseFilters(IncomingWebhookErrorFilter)
 export class WebhookController {
   constructor(
-    private readonly webhookIncomingService: WebhookIncomingService,
+    private readonly incomingWebhookService: IncomingWebhookService,
   ) {}
 
   @ApiOperation({
@@ -48,9 +40,7 @@ export class WebhookController {
   @UseGuards(new SignatureAuthGuard([AuthSignatureRole.RECORDING_ORACLE]))
   @Post('/')
   @HttpCode(202)
-  public async createIncomingWebhook(
-    @Body() data: IncomingWebhookDto,
-  ): Promise<void> {
-    await this.webhookIncomingService.createIncomingWebhook(data);
+  async createIncomingWebhook(@Body() data: IncomingWebhookDto): Promise<void> {
+    await this.incomingWebhookService.createIncomingWebhook(data);
   }
 }
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.dto.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.dto.ts
index 31c563318c..7f04826bd3 100644
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.dto.ts
+++ b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.dto.ts
@@ -1,24 +1,25 @@
 import { ChainId } from '@human-protocol/sdk';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsEthereumAddress, IsObject, IsOptional } from 'class-validator';
-import { EventType } from '../../common/enums';
+
 import { IsChainId, IsLowercasedEnum } from '../../common/validators';
+import { IncomingWebhookEventType } from './types';
 
 export class IncomingWebhookDto {
   @ApiProperty({ name: 'chain_id' })
   @IsChainId()
-  public chainId: ChainId;
+  chainId: ChainId;
 
   @ApiProperty({ name: 'event_type' })
-  @IsLowercasedEnum(EventType)
-  public eventType: EventType;
+  @IsLowercasedEnum(IncomingWebhookEventType)
+  eventType: IncomingWebhookEventType;
 
   @ApiProperty({ name: 'escrow_address' })
   @IsEthereumAddress()
-  public escrowAddress: string;
+  escrowAddress: string;
 
   @ApiPropertyOptional({ name: 'event_data' })
   @IsOptional()
   @IsObject()
-  public eventData?: any;
+  eventData?: Record<string, unknown>;
 }
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.filter.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.filter.ts
deleted file mode 100644
index f7c0103e8b..0000000000
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.filter.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpStatus,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-
-import { IncomingWebhookError } from './webhook.error';
-import logger from '../../logger';
-
-@Catch(IncomingWebhookError)
-export class IncomingWebhookErrorFilter implements ExceptionFilter {
-  private readonly logger = logger.child({
-    context: IncomingWebhookErrorFilter.name,
-  });
-
-  catch(exception: IncomingWebhookError, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-    const status = HttpStatus.BAD_REQUEST;
-
-    this.logger.error('Incoming webhook error', exception);
-
-    return response.status(status).json({
-      message: exception.message,
-      timestamp: new Date().toISOString(),
-      path: request.url,
-    });
-  }
-}
diff --git a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.ts b/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.ts
deleted file mode 100644
index 24cd928e53..0000000000
--- a/packages/apps/reputation-oracle/server/src/modules/webhook/webhook.error.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { ChainId } from '@human-protocol/sdk';
-import { BaseError } from '../../common/errors/base';
-
-export enum WebhookErrorMessage {
-  INVALID_EVENT_TYPE = 'Invalid event type',
-  NOT_SENT = 'Webhook was not sent',
-}
-
-export class IncomingWebhookError extends BaseError {
-  chainId: ChainId;
-  address: string;
-  constructor(message: WebhookErrorMessage, chainId: ChainId, address: string) {
-    super(message);
-    this.chainId = chainId;
-    this.address = address;
-  }
-}
-
-export class OutgoingWebhookError extends BaseError {
-  hash: string;
-  constructor(message: WebhookErrorMessage, hash: string) {
-    super(message);
-    this.hash = hash;
-  }
-}