.png)
Semrush Integration Guide
Integrate Semrush marketing and competitive intelligence data with enterprise systems through API-driven workflows, scheduled extraction, transformation, and controlled delivery.
Semrush integration options at a glance
Semrush provides HTTP-based APIs for selected SEO, advertising, traffic, keyword, backlink, project, and Site Audit data. Martini can authenticate to these APIs with a protected Semrush API key, retrieve report data on a schedule, partition large extractions by domain, database, date range, or project, and map responses into databases, files, dashboards, or downstream applications. Report retrieval may be subject to API-unit consumption, row limits, account permissions, and product entitlements. A universal Semrush webhook, callback, GraphQL, SOAP, or direct database interface was not confirmed, so scheduled polling is the safer general integration pattern.
| Integration point | Supported by Semrush? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Retrieve selected SEO, advertising, traffic, keyword, backlink, project, and Site Audit reports, and operate selected project or audit functions. Availability depends on the Semrush product, account, and API entitlement. | Martini can consume Semrush HTTP APIs in workflows, store configuration securely, map responses, apply business rules, and deliver normalized data to applications, databases, files, or APIs. |
| Authentication | Yes | Authenticate API requests primarily with an API key, commonly supplied as a request parameter. Access is governed by subscription, permissions, product entitlements, and available API units. | Martini can keep the API key in protected secrets or environment configuration and inject it into API requests without embedding it in workflow logic or exposing it downstream. |
| Bulk / async / batch APIs | Limited | Report extraction can return multiple rows and substantial result sets, subject to API-unit consumption, row limits, endpoint restrictions, and report parameters. A universal asynchronous job model was not confirmed. | Martini can partition and schedule extraction by domain, database, region, date, keyword set, project, or report type, while tracking checkpoints and source parameters. |
| Database / analytics access | Limited | Semrush exposes marketing and SEO datasets through APIs rather than general direct database connectivity. Retrieved data can be stored in a reporting database or warehouse. | Martini can transform API responses and write them to supported SQL databases, files, or analytics pipelines, including source parameters and collection timestamps. |
| Webhooks / outbound callbacks | Not confirmed | A general-purpose webhook or outbound callback framework covering Semrush data domains was not confirmed. Product-specific notifications should be verified before use. | Martini can use scheduled polling as the general pattern; it can receive a callback only when the relevant Semrush product documentation confirms that event mechanism. |
| GraphQL APIs | Not confirmed | No official Semrush GraphQL API was confirmed in the reviewed documentation. | Martini should use the documented Semrush HTTP APIs rather than assume GraphQL support. |
| SOAP APIs | Not confirmed | No official Semrush SOAP API was confirmed. New integrations should use the documented HTTP APIs. | Martini can consume SOAP services generally, but a Semrush SOAP integration should not be designed without vendor confirmation. |
| File / attachment APIs | Not confirmed | Selected products may offer exportable reports or downloadable results, but a general Semrush file or attachment API was not confirmed. | Martini can process an approved export or file exchange when available, but the primary Semrush integration should use its documented APIs. |
How Semrush exposes data and business events
Semrush REST APIs
Semrush documents HTTP APIs for selected analytics, SEO, advertising, traffic, project, backlink, keyword, and Site Audit data. Endpoint availability, returned fields, row limits, and report parameters vary by product and account entitlement.
Martini implementation pattern
Martini implementation pattern: a scheduled or API-invoked workflow authenticates with a protected API key, calls the selected Semrush report endpoint, validates the response, maps the product-specific report schema, and writes the result to a target system or exposes a normalized internal API.
Implementation sequence
Scheduled report extraction
Because a universal Semrush webhook or callback model was not confirmed, scheduled polling is the safer general method for keeping downstream systems current. Large requests should be partitioned by domain, database, region, date, keyword set, project, or report type.
Martini implementation pattern
Martini implementation pattern: a scheduler starts an incremental workflow, retrieves only the required report slices, records checkpoints and API-unit-related metrics, and applies bounded retry and backoff behavior for transient failures without retrying permanent authorization or validation errors.
Implementation sequence
Semrush bulk report retrieval
Semrush report APIs can return multiple rows and substantial result sets, but universal asynchronous job processing was not confirmed. Extraction is constrained by API units, row limits, endpoint rules, and account permissions.
Martini implementation pattern
Martini implementation pattern: Martini divides the extraction into bounded partitions, processes each partition through reusable workflow logic, validates completeness, and routes failed partitions for controlled retry or operator review.
Implementation sequence
Semrush API façade
Semrush data can be made available to internal applications through a controlled Martini REST API rather than exposing Semrush credentials, raw report parameters, or product-specific response formats to every consumer.
Martini implementation pattern
Martini implementation pattern: an exposed Martini API validates the caller and request, invokes a workflow that retrieves the permitted Semrush report, applies authorization and business rules, normalizes the response, and returns only approved fields.
Implementation sequence
Common Semrush integration patterns
Pattern 1: Load Semrush reports into a reporting database
When to use this pattern
Use this pattern for daily competitor visibility snapshots, keyword-position history, backlink monitoring, or regional search-performance reporting. It separates Semrush's product-specific response formats from dashboards and downstream consumers.
Integration direction
Example Mapping
| Semrush Field | Canonical Field | Target Field |
|---|---|---|
| domain | source_domain | domain |
| keyword or phrase | search_term | keyword |
| database | market_database | search_database |
| report date | measurement_date | report_date |
Martini implementation pattern
A scheduled workflow retrieves only the required columns for each approved domain and market, partitions large reports, maps fields into a stable schema, and writes idempotently to PostgreSQL. It stores source parameters and retrieval timestamps, distinguishes transient failures from quota or validation failures, and retries only eligible errors with bounded backoff.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- SQL database integration
- business rules
- error handling
Pattern 2: Synchronize Site Audit findings to Jira
When to use this pattern
Use this pattern when SEO, content, or engineering teams need operational issues from Site Audit rather than another dashboard. It is appropriate for creating or updating Jira issues while avoiding duplicates across repeated crawls.
Integration direction
Example Mapping
| Semrush Field | Canonical Field | Target Field |
|---|---|---|
| Project | project_name | project |
| Crawl date | audit_crawl_date | customfield_audit_crawl_date |
| Issue type and severity | audit_issue | issuetype and priority |
| Affected URL | affected_url | description or customfield_affected_url |
Martini implementation pattern
Martini retrieves the selected Site Audit campaign results, normalizes issue and URL data, applies severity and routing rules, and creates or updates Jira issues through Jira's API. A deterministic key based on project, crawl, issue type, and URL prevents duplicate creation; failed target writes are retried without repeating successful updates.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- deduplication
- error handling
- retries
Pattern 3: Enrich accounts with Semrush metrics
When to use this pattern
Use this pattern when sales or marketing teams need a focused set of SEO and competitive indicators on Salesforce or HubSpot accounts. The workflow should write a small operational metric set rather than every available Semrush column.
Integration direction
Example Mapping
| Semrush Field | Canonical Field | Target Field |
|---|---|---|
| domain | account_domain | Account.Website or HubSpot company domain |
| organic visibility trend | organic_visibility_trend | SEO visibility trend field |
| ranking keyword count | ranking_keyword_count | Keyword count field |
| last Semrush refresh time | semrush_refreshed_at | Last refresh field |
Martini implementation pattern
Martini obtains an approved domain list from the account system or maintained configuration, retrieves selected Semrush reports, calculates or maps the required indicators, and upserts the target records. Validation rules reject ambiguous domain matches, and the workflow records the source period and refresh status for auditability.
Martini capabilities used
- workflows
- API consumption
- data mapping
- transformations
- business rules
- scheduled execution
- monitoring
Pattern 4: Expose a governed Semrush reporting API
When to use this pattern
Use this pattern when internal portals, analytics services, or customer-facing applications need selected Semrush data without direct access to Semrush credentials or unrestricted report parameters.
Integration direction
Example Mapping
| Semrush Field | Canonical Field | Target Field |
|---|---|---|
| requested domain | domain | validated domain parameter |
| report type | report_name | approved Semrush report |
| Semrush report rows | normalized_metrics | API response data |
| API-unit and source metadata | retrieval_metadata | response metadata or audit store |
Martini implementation pattern
A Martini REST API authenticates and authorizes the caller, validates an allowlisted report and parameter set, invokes the Semrush workflow, filters and normalizes the result, and applies request and data-use rules. Correlation identifiers, response caching where appropriate, and bounded retries protect both consumers and Semrush API capacity.
Martini capabilities used
- API exposure
- workflows
- API consumption
- validation
- data mapping
- authorization
- business rules
- error handling
Applications commonly integrated with Semrush
Semrush data can be combined with sales, marketing, engineering, advertising, and analytics applications. These are architecture patterns rather than evidence that Semrush provides a native integration with each product; Martini can orchestrate the Semrush API and the target application's own supported interface.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Add selected SEO, traffic, and competitive indicators to account-planning and sales workflows without copying the full Semrush report model into Salesforce. | Semrush → Martini → Salesforce | A scheduled Martini workflow retrieves metrics for an approved domain list, maps a small canonical metric set, applies freshness and threshold rules, and upserts Salesforce account fields with bounded retries and audit logging. |
| HubSpot | Enrich company or campaign records with organic visibility, keyword, and website-performance indicators. | Semrush → Martini → HubSpot | Martini receives or maintains the domain list, retrieves selected Semrush reports, normalizes metrics, and updates matching HubSpot companies or campaign data while recording the Semrush refresh timestamp. |
| Google Search Console | Combine Semrush competitive and keyword research with first-party search-performance data in a shared reporting model. | Semrush → Martini → Google Search Console | Separate workflows retrieve Semrush and Google Search Console data, map both into a common search-performance schema, and write the combined result to a reporting database or analytics layer. |
| Google Analytics 4 | Compare Semrush estimates and competitive research with first-party traffic and acquisition data. | Semrush → Martini → Google Analytics 4 | Martini schedules source-specific extractions, aligns domains, dates, and dimensions, validates required fields, and writes comparable datasets to a warehouse or reporting database. |
| Jira | Turn Site Audit findings into engineering or content-remediation issues with traceable URLs and crawl context. | Semrush → Martini → Jira | A workflow retrieves Site Audit results, maps issue type, severity, affected URL, crawl, and recommended action to Jira fields, then creates or updates issues using a deterministic deduplication key. |
| Tableau | Present Semrush extracts alongside CRM, advertising, and web-analytics data for recurring marketing and competitive reporting. | Semrush → Martini → Tableau | Martini retrieves partitioned reports, converts them to a stable tabular schema, writes them to a reporting database or approved file exchange, and records extraction metadata for refresh monitoring. |
How to build a Semrush integration in Martini
Objective
Establish secure access to Semrush and the target systems without placing credentials in workflow logic or downstream payloads.
Instructions in Martini
- Store the Semrush API key in Martini secrets or protected environment configuration.
- Confirm Semrush subscription, API package, report entitlement, and target-system permissions.
- Configure target-system authentication separately and use least-privilege access.
Objective
Select a trigger that matches Semrush's confirmed integration model and the required freshness of the data.
Instructions in Martini
- Use a scheduler for general report synchronization because universal Semrush webhooks were not confirmed.
- Use an exposed Martini API for approved on-demand reporting.
- Partition scheduled work by domain, database, region, date, keyword set, project, or report type.
Objective
Call the appropriate Semrush HTTP API and retain enough source context to make the extraction reproducible.
Instructions in Martini
- Resolve the approved report, domain, database, date, project, and column parameters.
- Request only the required fields and bounded result ranges.
- Persist response status, source parameters, report type, collection time, and checkpoint information.
Objective
Coordinate extraction, validation, transformation, target writes, and operational outcomes in a maintainable Martini workflow.
Instructions in Martini
- Use reusable workflow logic for report retrieval and response validation.
- Route authentication, quota, invalid-parameter, and transient HTTP failures differently.
- Continue successful partitions while isolating failed partitions for retry or review.
Objective
Convert product-specific Semrush report responses into a stable canonical model for downstream systems.
Instructions in Martini
- Map report fields explicitly because response schemas vary by product and endpoint.
- Normalize domains, URLs, dates, keywords, severity, and source identifiers.
- Retain raw or source-level metadata when auditability and reproducibility are important.
Objective
Control which Semrush data is written, how it is deduplicated, and whether it may be redistributed.
Instructions in Martini
- Apply domain allowlists, report allowlists, freshness checks, and target routing rules.
- Use deterministic keys and upsert logic for repeated reports and Site Audit findings.
- Confirm Semrush data-use and redistribution terms before exposing metrics externally.
Common Semrush data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Domain | Website or competitor domain used in organic, advertising, traffic, and competitive research reports. | Salesforce, HubSpot, reporting databases, data warehouses | Martini validates and normalizes domain values, associates them with account or project identifiers, and persists the report parameters used for retrieval. |
| Keyword / phrase | Search term used for keyword metrics, rankings, trends, related keywords, and domain visibility analysis. | Reporting databases, Tableau, Microsoft Power BI, marketing applications | Martini maps keyword fields into a canonical search-performance model, preserves database and date context, and uses deterministic keys for upserts. |
| URL | Specific page associated with organic rankings, backlinks, Site Audit findings, or content analysis. | Jira, ServiceNow, reporting databases, content operations tools | Martini validates URL fields, maps page-level findings, and combines URLs with project, crawl, issue, or collection identifiers to prevent duplicate downstream actions. |
| Backlink | Referring link, referring domain, target URL, anchor, and related backlink metadata. | SQL databases, data warehouses, Tableau, Microsoft Power BI | Martini extracts the required backlink fields, records collection date and source parameters, and applies upsert or deduplication logic based on source and target identifiers. |
| Project | Semrush project that groups monitoring and analysis configuration for a website or domain. | Salesforce, HubSpot, Jira, ServiceNow, reporting databases | Martini retrieves project data where the account entitlement supports it, maps project identifiers and status, and uses them to scope subsequent synchronization workflows. |
| Site Audit campaign | Site-audit configuration and crawl results, including errors, notices, issues, and affected URLs. | Jira, ServiceNow, operational databases, reporting dashboards | Martini normalizes campaign, crawl, severity, issue, URL, and status fields, then creates or updates target issues using a stable project-crawl-issue-URL key. |
Authentication and security considerations
API-key authentication
Semrush API access is primarily authenticated with an API key, commonly supplied with the request. Access depends on the Semrush subscription, API package, account permissions, product entitlement, and available API units.
Protecting credentials
Store the Semrush API key in Martini secrets or protected environment configuration. Do not embed it in workflow logic, expose it in downstream payloads, or write it to logs and error messages.
Least-privilege integration
- Request only the reports, columns, databases, and domains required by the workflow.
- Restrict exposed Martini API operations to approved report types and parameters.
- Confirm data-use and redistribution terms before publishing Semrush-derived metrics to external users.
Operational considerations for Semrush integrations
API units and quotas
Semrush API usage can consume account-based API units. Schedule large extractions, limit returned fields, cache completed periods where appropriate, and monitor endpoint, parameters, response status, and estimated consumption.
Pagination and partitioning
Do not assume one request returns a complete report. Respect documented row limits and partition by domain, database, region, date range, keyword set, project, or report type.
Idempotency and history
Use deterministic keys and upserts for repeated results. Preserve the time represented by the Semrush report separately from the Martini retrieval time and target update time.
Errors and schema changes
Handle authorization, exhausted API units, invalid parameters, unsupported databases, rate limits, and transient HTTP failures separately. Validate required fields because report columns and response structures vary by product and endpoint.
Testing and monitoring
Test representative domains, databases, report types, empty results, quota responses, and malformed parameters. Monitor workflow logs, row counts, checkpoints, retries, and failed partitions before promoting changes.
Why use Martini instead of scripts or point-to-point integrations?
Reusable orchestration
Martini centralizes Semrush retrieval, scheduling, partitioning, validation, transformation, target writes, and operational handling in maintainable workflows rather than scattering logic across scripts.
Controlled data access
Martini can keep Semrush credentials server-side, expose a business-specific API, restrict report parameters, and apply authorization and data-use rules before returning or redistributing metrics.
Reliable synchronization
Workflows can preserve checkpoints and source parameters, apply deterministic upserts, classify failures, retry transient errors with bounded backoff, and provide monitoring context for support teams.
Adaptable integration assets
Martini can map changing, product-specific Semrush responses into stable internal models and deliver them to databases, files, analytics platforms, CRMs, issue systems, or other supported enterprise endpoints.
Frequently asked questions
Semrush can be integrated through its documented HTTP APIs for selected SEO, advertising, traffic, keyword, backlink, project, and Site Audit data. Enterprise workflows commonly use API-key authentication, scheduled or on-demand report retrieval, partitioning for larger extracts, transformation into a canonical model, and delivery to databases, analytics platforms, CRMs, issue-management systems, or controlled APIs.
Yes. Martini can consume Semrush REST APIs using protected API-key configuration, orchestrate scheduled or on-demand workflows, map report responses, apply business rules, and write results to databases, files, downstream applications, or a normalized Martini API. A native Martini Semrush connector was not documented in the supplied research.
No. A dedicated Semrush connector is not required. Martini can integrate using Semrush's confirmed native HTTP APIs and API-key authentication, with scheduled polling as the general synchronization pattern because universal Semrush webhooks, callbacks, GraphQL, and SOAP support were not confirmed.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Semrush. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Semrush, cloud infrastructure, databases, or other third-party systems depending on subscription, usage, and deployment model.
Use the documented Semrush HTTP APIs for the required product and report. API access should be limited to the necessary fields and parameters, while larger synchronizations should be scheduled and partitioned. GraphQL and SOAP APIs were not confirmed, and a universal webhook model was not confirmed.
A general-purpose Semrush webhook or outbound callback framework for all data domains was not confirmed. A scheduled Martini workflow that polls the relevant API is therefore the safer general design. Product-specific callbacks should only be used after the applicable Semrush documentation confirms the event and delivery behavior.
Martini retrieves selected reports, validates product-specific responses, maps fields into a canonical model, and writes the result to a database, file, analytics layer, or target application. Workflows can preserve domain, database, date, report, project, and collection metadata and use deterministic keys for idempotent updates.
A robust workflow distinguishes authentication failures, exhausted API units, rate limits, invalid parameters, unsupported databases, and transient HTTP errors. Martini can apply bounded retries and backoff for eligible failures, partition large requests, monitor usage and row counts, and use upsert or deduplication keys such as project, crawl, issue type, and affected URL.
Yes. Martini can expose a controlled REST API that validates approved report parameters, invokes Semrush workflows, applies authorization and field filtering, and returns a normalized response. The Semrush API key remains server-side, and the façade can prevent unrestricted report access and unnecessary API-unit consumption.
Related Martini documentation
Workflows
Build a governed Semrush integration with Martini
Use Martini to connect Semrush API data with your enterprise workflows, databases, analytics platforms, and business applications through secure, maintainable integration flows.