universal-mcp-applications 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

universal_mcp/applications/semrush/app.py

@@ -40,6 +40,25 @@ class SemrushApp(APIApplication):
         """
         self._api_key = value
 
+    def _build_params_and_get(self, report_type: str, **kwargs) -> dict[str, Any]:
+        """
+        Builds the parameters dictionary and makes a GET request to the Semrush API.
+        """
+        params = {
+            "type": report_type,
+            "key": self.api_key,
+        }
+        for key, value in kwargs.items():
+            if value is not None:
+                params[key] = value
+
+        url = self.base_url
+        if "analytics" in report_type:
+            url = f"{self.base_url}/analytics/v1"
+
+        response = self._get(url, params=params)
+        return self._handle_response(response)
+
     def domain_ad_history(
         self,
         domain: str,
@@ -55,60 +74,22 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domain ad history data showing past ad copies, landing pages, and performance metrics over time.
-
-        Args:
-            domain (str): Unique name of the website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "tr_desc", "pc_asc")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            Dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search, important
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_ad_history",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_ad_history",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def domain_organic_pages(
         self,
@@ -125,60 +106,22 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get unique pages of a domain that rank in Google's top 100 organic search results.
-
-        Args:
-            domain (str): Unique name of the website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "tr_desc", "pc_asc")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_organic_unique",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_organic_unique",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def domain_organic_search_keywords(
         self,
@@ -220,43 +163,25 @@ class SemrushApp(APIApplication):
             httpx.HTTPStatusError: If the API request fails
 
         Tags:
-            domain-search
+            domain-search, important
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_organic",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if display_daily is not None:
-            params["display_daily"] = display_daily
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_positions is not None:
-            params["display_positions"] = display_positions
-        if display_positions_type is not None:
-            params["display_positions_type"] = display_positions_type
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_organic",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            display_daily=display_daily,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_positions=display_positions,
+            display_positions_type=display_positions_type,
+            display_filter=display_filter,
+            export_escape=export_escape,
+        )
 
     def domain_organic_subdomains(
         self,
@@ -272,57 +197,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get subdomains of a domain that rank in Google's top 100 organic search results.
-
-        Args:
-            domain (str): Unique name of the website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "pc_asc", "tg_desc")
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_organic_subdomains",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_organic_subdomains",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def domain_paid_search_keywords(
         self,
@@ -340,63 +229,23 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get keywords that bring paid traffic to a domain via Google's paid search results.
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "po_asc", "tg_desc")
-            display_positions (str, optional): Filter by position changes ("new", "lost", "rise", "fall")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_adwords",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_positions is not None:
-            params["display_positions"] = display_positions
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_adwords",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_positions=display_positions,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def domain_pla_search_keywords(
         self,
@@ -412,57 +261,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get keywords that trigger a domain's product listing ads (PLA) in Google's paid search results.
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "po_asc", "nq_desc")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_shopping",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_shopping",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def domain_vs_domain(
         self,
@@ -479,65 +292,22 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Compare up to five domains by common keywords, unique keywords, or search terms unique to the first domain.
-
-        Args:
-            domains (str): URL-encoded string containing domains in format: <sign>|<type>|<domain>
-                          Examples:
-                          - Shared keywords: "*|or|domain1|*|or|domain2|*|or|domain3"
-                          - All keywords: "*|or|domain1|+|or|domain2|+|or|domain3"
-                          - Unique keywords: "*|or|domain1|-|or|domain2|-|or|domain3"
-                          - Untapped keywords: "*|or|domain2|+|or|domain3|-|or|domain1"
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "p0_asc", "p1_desc")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domains:
             raise ValueError("Domains parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_domains",
-            "key": self.api_key,
-            "domains": domains,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_domains",
+            domains=domains,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def backlinks(
         self,
@@ -551,54 +321,19 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get backlinks data for a domain, root domain, or URL.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "page_ascore_desc", "last_seen_asc")
-            display_limit (int, optional): Number of results to return (max 1,000,000)
-            display_offset (int, optional): Number of results to skip
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_filter=display_filter,
+        )
 
     def backlinks_overview(
         self,
@@ -612,54 +347,19 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get backlinks overview summary including type, referring domains, and IP addresses.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order for results
-            display_limit (int, optional): Number of results to return
-            display_offset (int, optional): Number of results to skip
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_overview",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_overview_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_filter=display_filter,
+        )
 
     def keyword_difficulty(
         self,
@@ -670,42 +370,16 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get keyword difficulty data to estimate ranking difficulty for organic search terms.
-
-        Args:
-            phrase (str): Phrase (from 1 to 100 keywords separated by semicolons)
-            database (str): Regional database (default: "us")
-            export_columns (str, optional): Comma-separated list of columns to include
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis, important
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_kdi",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_kdi",
+            phrase=phrase,
+            database=database,
+            export_columns=export_columns,
+            export_escape=export_escape,
+        )
 
     def ads_copies(
         self,
@@ -721,57 +395,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get unique ad copies that appeared when a domain ranked in Google's paid search results.
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "pc_asc", "pc_desc")
-            display_filter (str, optional): Filter criteria for columns
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
-        """
-        if not domain:
-            raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_adwords_unique",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        """
+        if not domain:
+            raise ValueError("Domain parameter is required")
+        return self._build_params_and_get(
+            "domain_adwords_unique",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+            export_escape=export_escape,
+            export_decode=export_decode,
+        )
 
     def anchors(
         self,
@@ -784,87 +422,30 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get anchor texts used in backlinks leading to a domain, root domain, or URL.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "domains_num_desc", "backlinks_num_asc")
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_anchors",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_anchors_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
 
     def authority_score_profile(self, target: str, target_type: str) -> dict[str, Any]:
         """
         Get distribution of referring domains by Authority Score from 0 to 100.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_ascore_profile",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_ascore_profile_analytics",
+            target=target,
+            target_type=target_type,
+        )
 
     def batch_comparison(
         self,
@@ -874,49 +455,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Compare backlink profiles and link-building progress across multiple competitors.
-
-        Args:
-            targets (list[str]): Array of root domains, subdomains, or URLs to investigate (max 200)
-            target_types (list[str]): Array of target types corresponding to targets (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing or invalid
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not targets:
-            raise ValueError("Targets parameter is required")
-        if not target_types:
-            raise ValueError("Target_types parameter is required")
+        if not targets or not target_types:
+            raise ValueError("Targets and target_types parameters are required")
         if len(targets) > 200:
             raise ValueError("Maximum 200 targets allowed")
         if len(targets) != len(target_types):
             raise ValueError(
                 "Targets and target_types arrays must have the same length"
             )
-
-        # Build parameters dictionary
-        params = {"type": "backlinks_comparison", "key": self.api_key}
-
-        # Add targets and target_types as arrays
-        for target in targets:
-            params["targets[]"] = target
-        for target_type in target_types:
-            params["target_types[]"] = target_type
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "backlinks_comparison_analytics",
+            targets=targets,
+            target_types=target_types,
+            export_columns=export_columns,
+        )
 
     def batch_keyword_overview(
         self,
@@ -929,48 +482,18 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get summary of up to 100 keywords including volume, CPC, competition level, and results count.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate (up to 100 keywords separated by semicolons)
-            database (str): Regional database (default: "us")
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_these",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_these",
+            phrase=phrase,
+            database=database,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+        )
 
     def broad_match_keyword(
         self,
@@ -986,99 +509,36 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get broad matches and alternate search queries for a keyword or keyword expression.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "nq_desc", "cp_asc")
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_fullsearch",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_fullsearch",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+        )
 
     def categories(
         self, target: str, target_type: str, export_columns: str | None = None
     ) -> dict[str, Any]:
         """
         Get list of categories that the queried domain belongs to with confidence ratings.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, subdomain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_categories",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_categories_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+        )
 
     def categories_profile(
         self,
@@ -1090,48 +550,17 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get categories that referring domains belong to with domain counts for the queried domain.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_categories_profile",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_categories_profile_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
 
     def competitors(
         self,
@@ -1143,48 +572,17 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains that share a similar backlink profile with the analyzed domain.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_competitors",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_competitors_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
 
     def competitors_organic_search(
         self,
@@ -1200,57 +598,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domain's competitors in organic search results with common keywords analysis.
-
-        Args:
-            domain (str): Unique name of the website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "np_desc", "cr_asc")
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_organic_organic",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_organic_organic",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+        )
 
     def competitors_paid_search(
         self,
@@ -1266,57 +628,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domain's competitors in paid search results with common keywords analysis.
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "np_desc", "cr_asc")
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_adwords_adwords",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_adwords_adwords",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+        )
 
     def indexed_pages(
         self,
@@ -1329,51 +655,18 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get indexed pages of the queried domain with backlink and response data.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "backlinks_num_desc", "backlinks_num_asc")
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_pages",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_pages_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
 
     def keyword_ads_history(
         self,
@@ -1387,98 +680,41 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains that have bid on a keyword in the last 12 months with their paid search positions.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_adwords_historical",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_adwords_historical",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+        )
 
     def keyword_overview_all_databases(
         self,
         phrase: str,
         database: str | None = None,
         export_escape: int | None = None,
-        export_decode: int | None = None,
-        export_columns: str | None = None,
-    ) -> dict[str, Any]:
-        """
-        Get keyword summary including volume, CPC, competition level, and results across all regional databases.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str, optional): Regional database (if not specified, uses all databases)
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
+        export_decode: int | None = None,
+        export_columns: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Get keyword summary including volume, CPC, competition level, and results across all regional databases.
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {"type": "phrase_all", "key": self.api_key, "phrase": phrase}
-
-        if database is not None:
-            params["database"] = database
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_all",
+            phrase=phrase,
+            database=database,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+        )
 
     def keyword_overview_one_database(
         self,
@@ -1491,48 +727,18 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get keyword summary including volume, CPC, competition level, and results for a specific database.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_this",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_this",
+            phrase=phrase,
+            database=database,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+        )
 
     def organic_results(
         self,
@@ -1548,57 +754,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains ranking in Google's top 100 organic search results for a keyword.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-            positions_type (str, optional): Position type ("organic" or "all")
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_organic",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if positions_type is not None:
-            params["positions_type"] = positions_type
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_organic",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+            positions_type=positions_type,
+        )
 
     def paid_results(
         self,
@@ -1613,54 +783,20 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains ranking in Google's paid search results for a keyword.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            display_date (str, optional): Date in format "YYYYMM15" for historical data
-            export_columns (str, optional): Comma-separated list of columns to include
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_adwords",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if display_date is not None:
-            params["display_date"] = display_date
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_adwords",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+        )
 
     def phrase_questions(
         self,
@@ -1676,57 +812,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get phrase questions relevant to a queried term in a chosen database.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "nq_desc", "cp_asc")
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_questions",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_questions",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+        )
 
     def pla_competitors(
         self,
@@ -1741,54 +841,20 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains competing against the requested domain in Google's Product Listing Ads (PLA).
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "np_desc", "cr_asc")
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_shopping_shopping",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_shopping_shopping",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+        )
 
     def pla_copies(
         self,
@@ -1804,57 +870,21 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get product listing ad (PLA) copies that appeared when a domain ranked in Google's paid search results.
-
-        Args:
-            domain (str): Unique name of a website to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "pr_desc", "pc_asc")
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            domain-search
         """
         if not domain:
             raise ValueError("Domain parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "domain_shopping_unique",
-            "key": self.api_key,
-            "domain": domain,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "domain_shopping_unique",
+            domain=domain,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+        )
 
     def referring_domains(
         self,
@@ -1868,54 +898,19 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get domains pointing to the queried domain, root domain, or URL.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "domain_ascore_desc", "backlinks_num_asc")
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_refdomains",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_refdomains_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            display_filter=display_filter,
+        )
 
     def referring_domains_by_country(
         self,
@@ -1928,51 +923,18 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get referring domain distribution by country based on IP addresses.
-
-        Args:
-            target (str): Root domain, subdomain, or URL of the website to investigate
-            target_type (str): Type of requested target (root_domain, domain, or url)
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "domains_num_desc", "backlinks_num_asc")
-            display_limit (int, optional): Number of results to return (default: 10,000)
-            display_offset (int, optional): Number of results to skip
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            backlinks
         """
-        if not target:
-            raise ValueError("Target parameter is required")
-        if not target_type:
-            raise ValueError("Target_type parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "backlinks_geo",
-            "key": self.api_key,
-            "target": target,
-            "target_type": target_type,
-        }
-
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-
-        url = f"{self.base_url}/analytics/v1"
-        response = self._get(url, params=params)
-
-        return self._handle_response(response)
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_geo_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
 
     def related_keywords(
         self,
@@ -1988,57 +950,103 @@ class SemrushApp(APIApplication):
     ) -> dict[str, Any]:
         """
         Get extended list of related keywords, synonyms, and variations relevant to a queried term.
-
-        Args:
-            phrase (str): Keyword or keyword expression to investigate
-            database (str): Regional database (default: "us")
-            display_limit (int, optional): Number of results to return (max 100,000)
-            display_offset (int, optional): Number of results to skip
-            export_escape (int, optional): Set to 1 to wrap columns in quotes
-            export_decode (int, optional): Set to 0 for URL-encoded response, 1 for normal response
-            export_columns (str, optional): Comma-separated list of columns to include
-            display_sort (str, optional): Sorting order (e.g., "nq_desc", "cp_asc")
-            display_filter (str, optional): Filter criteria for columns
-
-        Returns:
-            dict[str, Any]: API response data
-
-        Raises:
-            ValueError: If required parameters are missing
-            httpx.HTTPStatusError: If the API request fails
-
-        Tags:
-            keyword-analysis
         """
         if not phrase:
             raise ValueError("Phrase parameter is required")
-
-        # Build parameters dictionary
-        params = {
-            "type": "phrase_related",
-            "key": self.api_key,
-            "phrase": phrase,
-            "database": database,
-        }
-
-        if display_limit is not None:
-            params["display_limit"] = display_limit
-        if display_offset is not None:
-            params["display_offset"] = display_offset
-        if export_escape is not None:
-            params["export_escape"] = export_escape
-        if export_decode is not None:
-            params["export_decode"] = export_decode
-        if export_columns is not None:
-            params["export_columns"] = export_columns
-        if display_sort is not None:
-            params["display_sort"] = display_sort
-        if display_filter is not None:
-            params["display_filter"] = display_filter
-
-        response = self._get(self.base_url, params=params)
-
-        return self._handle_response(response)
+        return self._build_params_and_get(
+            "phrase_related",
+            phrase=phrase,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_filter=display_filter,
+        )
+
+    def tlds_distribution(
+        self,
+        target: str,
+        target_type: str,
+        export_columns: str | None = None,
+        display_sort: str | None = None,
+        display_limit: int | None = None,
+        display_offset: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Get referring domain distribution by top-level domain (e.g., .com, .org, .net).
+        """
+        if not target or not target_type:
+            raise ValueError("Target and target_type parameters are required")
+        return self._build_params_and_get(
+            "backlinks_tlds_profile_analytics",
+            target=target,
+            target_type=target_type,
+            export_columns=export_columns,
+            display_sort=display_sort,
+            display_limit=display_limit,
+            display_offset=display_offset,
+        )
+
+    def url_organic_search_keywords(
+        self,
+        url: str,
+        database: str = "us",
+        display_limit: int | None = None,
+        display_offset: int | None = None,
+        export_escape: int | None = None,
+        export_decode: int | None = None,
+        display_date: str | None = None,
+        export_columns: str | None = None,
+        display_sort: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Get keywords that bring users to a URL via Google's top 100 organic search results.
+        """
+        if not url:
+            raise ValueError("URL parameter is required")
+        return self._build_params_and_get(
+            "url_organic",
+            url=url,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            display_date=display_date,
+            export_columns=export_columns,
+            display_sort=display_sort,
+        )
+
+    def url_paid_search_keywords(
+        self,
+        url: str,
+        database: str = "us",
+        display_limit: int | None = None,
+        display_offset: int | None = None,
+        export_escape: int | None = None,
+        export_decode: int | None = None,
+        export_columns: str | None = None,
+        display_sort: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Get keywords that bring users to a URL via Google's paid search results.
+        """
+        if not url:
+            raise ValueError("URL parameter is required")
+        return self._build_params_and_get(
+            "url_adwords",
+            url=url,
+            database=database,
+            display_limit=display_limit,
+            display_offset=display_offset,
+            export_escape=export_escape,
+            export_decode=export_decode,
+            export_columns=export_columns,
+            display_sort=display_sort,
+        )
 
     def list_tools(self):
         """
@@ -2078,4 +1086,7 @@ class SemrushApp(APIApplication):
             self.referring_domains,
             self.referring_domains_by_country,
             self.related_keywords,
-        ]
+            self.tlds_distribution,
+            self.url_organic_search_keywords,
+            self.url_paid_search_keywords,
+        ]