Menu

Mattering Automations Semrush integration

Connect Semrush to Mattering Automations: domain, URL and subdomain reports, keyword research, competitor overlap, shopping ads, the v4 backlinks family and project management as workflow steps, on one API key. Semrush bills most reports per line returned, so this guide starts with what each node spends.

The Mattering Automations Semrush integration puts Semrush's competitive research data on your automation canvas: domain overview, organic and paid footprints, competitor overlap, shopping ads, keyword overview and ideas, keyword SERP and advertisers, URL and subdomain reports, whole-market leaders and movers, the nine-node v4 backlinks family, v4 keyword metrics, and project management. Twenty-five nodes read, three act, and one of those three is flagged destructive.

Start with the metering, because it changes how you set every field. Semrush bills most Analytics reports PER LINE RETURNED, which makes the row limit a spending control rather than a display preference: one domain organic call for 1,000 rows at 10 units per line is 10,000 units. The rate differs per report and every node states its own, from 1 unit per line on Semrush: Authority Score Distribution up to 80 on the widest competitor report, with a five-times multiplier on the reports that publish a historical rate when a past month is pinned. A few endpoints bill flat per request instead, notably Semrush: Backlinks Overview at 45 units and Semrush: Keyword Metrics (v4) at 20. Semrush: API Units Balance is free, and so is the connection test.

The credential is one API key that covers both halves of the API. The classic Analytics reports take it as a URL query parameter, which is the only form that API accepts, and the v4 endpoints take an Authorization header, which is what the connector uses wherever it can. Setup takes a few minutes, and this guide walks through creating the key, connecting it, verifying without spending a unit, and the full node reference.

Before you start

  • A Semrush subscription that includes API access, and this is the hard prerequisite rather than a formality. Semrush documents the Standard API, which covers both the SEO reports and the Projects endpoints, as requiring an SEO Business plan subscription plus a separately purchased API units package, and states plainly that there is no free tier. There is no sandbox, no trial API and no free key.
  • A units package with a non-zero balance. Units are bought separately from the subscription, and an exhausted balance is reported as an error on the report itself rather than as an authentication failure, so it is worth reading Semrush: API Units Balance before the first scheduled run.
  • A budget you have actually worked out, because most reports bill per line returned. Multiply the row limit by the node's stated per-line rate before you schedule anything, and remember that pinning a historical month multiplies the rate by five on the reports that publish a historical price.
  • A retention plan for whatever stores the data. Semrush's API usage restrictions state that you may not cache information received via the API for more than one month without Semrush's express written consent, so a database, dataset or widget that keeps Semrush rows needs a rolling window or written consent. This is a property of the consuming surface, not of the connector.
  • Awareness that Semrush's other APIs are separate purchases with their own quota models, including Trends, Listing Management and Map Rank Tracker. None of them is what this integration calls, and a subscription to one of them does not enable the Standard API.
  • A Mattering workspace with access to the Automations app.

Get your Semrush API key

Mattering authenticates to Semrush with a single API key, and the same key covers the classic Analytics reports and the newer v4 endpoints. There are no scopes to compose and no second field. One property of the classic API is worth understanding before you paste the key anywhere, because it is a genuine exposure question rather than a stylistic one: that API accepts the key only as a URL query parameter, with no header form available, so the secret necessarily travels in the URL on those calls.

Sign in to Semrush and open the API keys page in your account settings.
Copy the active key.
The classic Analytics API has no header form for the key, so on those calls the secret travels in the query string, which is the part of a request most likely to be recorded by something other than the client: proxy logs, CDN logs, browser history and the vendor's own request logs. Mattering never string-formats the key into a URL it holds, passes it as a separate parameter mapping, registers it for redaction so it is scrubbed from node output and execution records, and scrubs transport error text before returning it. That reduces exposure on our side; it cannot reduce it on an intermediary's. Treat the key as rotatable and rotate it if it is ever pasted into a shared log.
The v4 endpoints, which are the backlinks family, keyword metrics and projects, accept an Authorization header, and the connector uses the header there rather than the query parameter. One key, two transports, chosen per endpoint.

Connect Semrush to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Semrush from the list.
Click Create new credential, paste the API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. Mattering asks a domain report about a domain in a reserved test-only top-level domain, which cannot resolve and therefore cannot hold Semrush data. Because Semrush bills per line returned and no lines come back, the probe spends nothing while still proving the key, the classic report host and the parameter wiring. A pass then reads the unit balance, which Semrush also serves free, and reports it in the success message.
A pass proves the classic Analytics surface. It does not prove the v4 families are entitled, because backlinks, keyword metrics and projects live on a different path with a different auth header, and it does not tell you which report types your units package covers.
Click Connect. All 28 Semrush nodes appear in your canvas palette.

Verify it works

Verify with the free node first. Open any automation canvas, drop Semrush: API Units Balance onto it and run a test step. It costs nothing, it is the only node here that spends no units, and it returns how many units the account has left. Semrush serves that number as a bare integer in plain text rather than as JSON, so the connector parses it into a named field and keeps the raw body beside it. Read the number before you build anything that loops.

Next prove the v4 half cheaply. Drop Semrush: Authority Score Distribution onto the canvas, point it at a domain you own, and run the step. At 1 unit per line it is the cheapest data node in the connector, and it exercises a different path, a different auth header and a different response shape than the classic reports, so a success here tells you something the connection test could not. If your account has projects, Semrush: List Projects is another good v4 probe and is the lister the project pickers read from.

Only then spend on a classic report, and spend as little as you can. Drop Semrush: Domain Overview onto the canvas, set the domain, and set the row limit to 1. One line at the stated per-line rate is the smallest real answer this API gives. Two things to look at in the output rather than just the success flag. The parsed shape is a header list plus one object per line keyed by Semrush's own two-letter column codes, which is what your downstream templates will bind to. And re-running Semrush: API Units Balance afterwards should show the balance moved by the amount the node said it would, which is the clearest possible confirmation that you have understood the billing.

Node reference

28 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 25

Semrush: API Units Balance

semrush_api_units_balance

How many API units the account has left. Costs NOTHING to call: it is the only node here that spends no units, which makes it the right thing to put in front of an expensive branch: read the balance, compare it against what the next pull will cost, and stop the workflow rather than have Semrush answer ERROR 132 halfway through. The endpoint answers a bare integer as plain text, not JSON, so this connector parses it into api_units and keeps the raw body beside it. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Authority Score Distribution

semrush_backlinks_score_profile

How a target's referring domains are distributed across Authority Score bands: one row per score bucket with how many domains sit in it. A profile weighted to the low end is a quality problem the raw counts hide. SPENDS API UNITS: 1 unit per LINE, which makes this by far the cheapest backlinks report. The domain counts are a distribution of a single snapshot, so they may be summed WITHIN one response and never across responses. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Backlink Anchors

semrush_backlinks_anchors

The anchor texts pointing at a target, with how many backlinks and how many distinct domains use each one. The anchor distribution is what an over-optimisation audit reads. SPENDS API UNITS: 40 units per LINE. Rows are ranked and truncated at Row Limit, so two periods' top-anchor lists must never be added together. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Backlink Competitors

semrush_backlinks_competitors

Domains with a similar backlink profile to yours, scored by similarity and by how many referring domains you share. The starting point for a link-gap campaign. Note this endpoint takes a plain domain and has NO scope parameter, unlike the rest of the backlinks family. SPENDS API UNITS: 40 units per LINE. Similarity is a point-in-time score, not a count. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Backlinks

semrush_backlinks_list

The individual backlinks pointing at a target: source URL and title, target URL, anchor text, the source page's and domain's Authority Scores, when the link was first and last seen, and whether it is nofollow, sponsored or UGC. SPENDS API UNITS: 45 units per LINE, which makes this the most expensive backlinks node, and a 1,000-link pull is 45,000 units. Size the profile with Backlinks Overview first (45 units flat), then filter server-side. Authority Scores are point-in-time readings and must not be summed or averaged across pulls. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Backlinks Historical Summary

semrush_backlinks_summary

The link profile month by month, so you can chart whether a site's backlinks and referring domains are growing: one row per month with Authority Score, backlink count, referring domain count and follow count. This is the ONLY node in the connector that takes a real start and end date, which is why it is the only one carrying a window declaration. SPENDS API UNITS: 40 units per line, so a 24-month pull is 960 units. Each row is a SNAPSHOT of the cumulative profile at that month, not that month's activity, so the counts must be read as levels and never added together. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Backlinks Overview

semrush_backlinks_overview

One row summarising a target's whole link profile: total backlinks and referring domains, follow vs nofollow vs sponsored vs UGC, Authority Score, referring IPs and class-C networks, link types, and how many links were gained and lost. SPENDS API UNITS: 45 units per REQUEST (not per line), so this is the cheap way to size a profile before pulling the links themselves. Authority Score is a point-in-time 0-100 reading and the counts are cumulative totals as of now, so nothing here may be added across pulls. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Domain Competitors

semrush_domain_competitors

Who you are actually competing with. domain_organic_organic ranks the domains sharing your organic keywords by relevance, domain_adwords_adwords does the same for paid, and domain_domains compares up to five named domains keyword by keyword so you can see who ranks where for each phrase. This is the most expensive family in the connector: domain_domains is 80 units per LINE. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: domain_organic_organic costs 40 API units per line, or 200 per line when Historical Month is set; domain_adwords_adwords costs 40 API units per line, or 200 per line when Historical Month is set; domain_domains costs 80 API units per line, or 400 per line when Historical Month is set. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Domain Organic Search

semrush_domain_organic

Every organic keyword a domain ranks for in one database, with position, estimated traffic share, CPC, difficulty, intents and SERP features. domain_organic_pages rolls the same data up to the pages that earn it and domain_organic_subdomains rolls it up to subdomains. This is the workhorse report and the expensive one at volume. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: domain_organic costs 10 API units per line, or 50 per line when Historical Month is set. domain_organic_pages and domain_organic_subdomains are metered per line on the same basis. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Domain Overview

semrush_domain_overview

The headline numbers for a domain: Semrush Rank, organic and paid keyword counts, estimated traffic and traffic cost, and PLA presence. domain_rank answers for ONE database, domain_ranks answers for every database at once (one row per country), and domain_rank_history returns the month-by-month series for trend charts. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: domain_rank costs 10 API units per line, or 50 per line when Historical Month is set; domain_ranks costs 10 API units per line, or 50 per line when Historical Month is set; domain_rank_history costs 10 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Domain Paid Search

semrush_domain_paid

What a domain buys on Google Ads: domain_adwords lists the paid keywords with position, CPC and ad block, domain_adwords_unique lists the distinct ad copies with their titles and descriptions, and domain_adwords_historical returns the month-by-month ad history. Useful for competitor ad-copy research and for sizing someone's paid spend. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: domain_adwords costs 20 API units per line, or 100 per line when Historical Month is set; domain_adwords_unique costs 40 API units per line; domain_adwords_historical costs 100 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Domain Shopping Ads

semrush_domain_shopping

Google Shopping / Product Listing Ads for a domain: the PLA keywords it appears on with product titles and prices (domain_shopping), its distinct product ad copies (domain_shopping_unique), and the retailers competing for the same PLA placements (domain_shopping_shopping). SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: domain_shopping costs 30 API units per line, or 150 per line when Historical Month is set; domain_shopping_unique costs 60 API units per line, or 300 per line when Historical Month is set; domain_shopping_shopping costs 60 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Get Project

semrush_get_project

One Semrush project by id, with its name, domain, owner, permissions and enabled tools. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Indexed Pages

semrush_backlinks_pages

The pages of a site that attract links, ranked by how many: source URL and title, backlink and referring-domain counts, the page's response code, and its internal and external link counts. This is how you find which content actually earns links. SPENDS API UNITS: 40 units per LINE. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Keyword Ideas

semrush_keyword_ideas

Keyword expansion around a seed phrase: semantically related keywords with a relevance score (phrase_related), every keyword containing the phrase (phrase_fullsearch), and the question-form variants that make good article briefs (phrase_questions). Filter server-side with the Filter field to keep the bill down, because you pay per line returned. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: phrase_related costs 40 API units per line; phrase_fullsearch costs 20 API units per line; phrase_questions costs 40 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Keyword Metrics (v4)

semrush_keyword_metrics

Search volume, CPC, competitive density, keyword difficulty, result count, search intents, SERP features and the 12-month trend for one keyword, from Semrush's newer JSON keyword API. This is the vendor's recommended replacement for the phrase_this report; the CSV keyword nodes remain because v4 replaces none of the others. SPENDS API UNITS: 20 units per REQUEST, flat. Volume is a modelled estimate and difficulty is a point-in-time 0-100 score; neither is a count and neither may be aggregated. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Keyword Overview

semrush_keyword_overview

The core metrics for a keyword: search volume, CPC, competitive density and result count. phrase_this answers for one database, phrase_all answers for every database at once, phrase_these takes a batch of up to 100 keywords in one call, and phrase_kdi returns the Keyword Difficulty Index. phrase_these is the cheap way to score a list: one call, 10 units per line, instead of one call per keyword. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: phrase_this costs 10 API units per line; phrase_all costs 10 API units per line; phrase_these costs 10 API units per line; phrase_kdi costs 50 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Keyword Difficulty is a point-in-time 0-100 score, so it must never be summed or averaged across pulls. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Keyword SERP and Advertisers

semrush_keyword_serp

Who occupies a keyword's SERP: the domains and URLs ranking organically (phrase_organic), the advertisers bidding on it (phrase_adwords), and the month-by-month history of who advertised on it (phrase_adwords_historical). SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: phrase_organic costs 10 API units per line; phrase_adwords costs 20 API units per line; phrase_adwords_historical costs 100 API units per line. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: List Projects

semrush_list_projects

Every Semrush project on the account, with its id, name, domain, owner and which tools are enabled on it. This is the node the other project nodes' Project pickers read, and the only lister anywhere in the Semrush API, because everything else takes a domain, a URL or a keyword you type yourself. Does not consume report units: the vendor's Projects API documents no per-call unit price, unlike every Analytics report. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Market Leaders and Movers

semrush_market_movers

Market-wide lists rather than a single target: rank returns the domains with the highest Semrush Rank in a database, and rank_difference returns the winners and losers, the domains whose organic or paid visibility moved most since the previous period. Neither takes a domain: these are the whole-market views. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: rank costs 10 API units per line, or 50 per line when Historical Month is set; rank_difference costs 20 API units per line, or 100 per line when Historical Month is set. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. The difference columns (Tm, Um, Am, Bm, Cm) are already a delta between two periods, so they must not be summed with each other or across pulls. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Referring Domains

semrush_backlinks_refdomains

The domains linking to a target, one row each, with how many backlinks they send, the domain's Authority Score, its IP and country, when it was first and last seen, and whether it is newly gained or recently lost. Usually more useful than the raw link list for outreach and for competitor gap analysis. SPENDS API UNITS: 40 units per LINE. Rows come back ordered and cut off at Row Limit, so a result is a TOP N rather than the whole profile. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Referring IPs

semrush_backlinks_refips

The IP addresses linking to a target, with backlink and domain counts and country. The report you use to spot a link network: many referring domains sharing one IP is a footprint, not a coincidence. SPENDS API UNITS: 20 units per LINE, the cheapest of the per-line backlinks reports. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Run Any Report

semrush_run_report

Escape hatch for the classic Analytics API: run ANY documented report type against api.semrush.com with whichever target and display parameters it needs. The full vocabulary this node accepts, all 39 of them: domain_adwords, domain_adwords_adwords, domain_adwords_historical, domain_adwords_unique, domain_domains, domain_organic, domain_organic_organic, domain_organic_pages, domain_organic_subdomains, domain_rank, domain_rank_history, domain_ranks, domain_shopping, domain_shopping_shopping, domain_shopping_unique, phrase_adwords, phrase_adwords_historical, phrase_all, phrase_fullsearch, phrase_kdi, phrase_organic, phrase_questions, phrase_related, phrase_these, phrase_this, rank, rank_difference, subdomain_adwords, subdomain_adwords_unique, subdomain_organic, subdomain_organic_unique, subdomain_rank, subdomain_rank_history, subdomain_ranks, url_adwords, url_organic, url_rank, url_rank_history, url_ranks. Prefer a typed node where one exists, because it validates the report type, names the columns and states the unit cost. Reach for this one for a report we grouped awkwardly or a type Semrush ships after this connector. Costs whatever that report costs, per line. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Subdomain Report

semrush_subdomain_report

The domain reports again, scoped to a single subdomain such as blog.example.com or docs.example.com: overview for one or all databases, the history series, the organic and paid keyword lists, the organic pages roll-up, and the distinct ad copies. Useful when a subdomain is really its own property. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: subdomain_rank costs 10 API units per line; subdomain_ranks costs 10 API units per line, or 50 per line when Historical Month is set; subdomain_rank_history costs 10 API units per line; subdomain_organic costs 10 API units per line, or 50 per line when Historical Month is set; subdomain_adwords costs 20 API units per line, or 100 per line when Historical Month is set; subdomain_organic_unique costs 10 API units per line, or 50 per line when Historical Month is set; subdomain_adwords_unique costs 40 API units per line. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: URL Report

semrush_url_report

The same analysis as the domain reports, narrowed to ONE page. url_rank and url_ranks give the page's estimated traffic and keyword counts (one database, or all of them), url_rank_history gives the month-by-month series, and url_organic / url_adwords list the keywords that page ranks or advertises for. This is the node to point at a competitor's single winning article. SPENDS API UNITS, per line returned, so Row Limit is a spending control and not a convenience: url_rank costs 10 API units per line, or 50 per line when Historical Month is set; url_ranks costs 10 API units per line, or 50 per line when Historical Month is set; url_rank_history costs 10 API units per line; url_organic costs 10 API units per line, or 50 per line when Historical Month is set; url_adwords costs 20 API units per line, or 100 per line when Historical Month is set. Traffic and search-volume figures here are Semrush's MODELLED estimates derived from its own SERP crawl and clickstream panel, not measured visits to the site. Treat them as directional, and never present them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility and authority scores are POINT-IN-TIME readings, not counts: they cannot be added across periods, and an unweighted average of them is also wrong. That is why these nodes declare no aggregatable measures. Output shape: Semrush answers this endpoint with semicolon-delimited CSV, not JSON, so this connector parses it. data.columns is the header row, data.rows is one object per line keyed by those column codes, and data.row_count says how many came back. Values are the vendor's own text, uncast, because one report can mix decimals, packed date stamps and comma-joined trend series in a single table. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Action nodes 3

Semrush: Create Project

semrush_create_project

Create a Semrush project for a domain. A project is the container Position Tracking, Site Audit and the other campaign tools hang off, so this is the node that bootstraps a new client. Reversible: Semrush: Delete Project removes it. Semrush enforces a per-plan project limit and answers ERROR 521 when it is reached. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Delete Project

semrush_delete_project

Delete a Semrush project. DESTRUCTIVE and not undoable through the API: deleting a project takes its Position Tracking history and Site Audit history with it, and recreating a project with the same domain starts that history from zero. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Semrush: Update Project

semrush_update_project

Rename a Semrush project. Only the project name is editable; the domain is fixed at creation, so moving a project to a different site means creating a new one. This is one of Semrush's newer v4 JSON endpoints, not the classic CSV Analytics API: it answers JSON with a meta object and a data array, and the API key is sent as an Authorization header rather than in the query string. data.rows is a flat alias this connector adds for the vendor's data array, so charts and datasets have one path to bind to. Semrush reports failures as a plain-text ERROR line with an HTTP 200 as often as not, so this node inspects the body: an ERROR response comes back with success false, the vendor's message, and error_code set. ERROR 50 (NOTHING FOUND) means the key worked and the query matched nothing.

Using the integration

On the automation canvas

Semrush nodes chain with every other node in the palette. A monthly schedule can run Semrush: API Units Balance, branch on what is left, then pull Semrush: Domain Overview for a competitor list into a Mattering database. A webhook from a CRM can trigger Semrush: Keyword Overview on a prospect's brand terms. The project nodes have real pickers: Semrush: List Projects is the only lister anywhere in the Semrush API, and it fills the project selector on Semrush: Get Project, Semrush: Update Project and Semrush: Delete Project, showing each project by name with its domain alongside so two projects with the same name are not ambiguous at the moment you have to choose. Everything else, domains, URLs and keywords, is free text by nature, because the set of valid answers is the web.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. Semrush also runs an MCP server of its own, documented with a hosted endpoint, OAuth as the default authentication approach and API key authentication available, exposing discovery tools for domain overview, organic research, keyword research, competitor research, backlinks research, audience research, traffic overview, paid search research, shopping research, position tracking, site audit and projects, plus a report schema tool and a generic report runner. It is gated on a different set of Semrush subscriptions than the Standard API this integration uses, so which one you can reach may not be a matter of taste. For interactive questions, theirs is a good tool. This integration is the operations side: typed nodes that run unattended on a schedule, join Semrush data to Google Search Console and the rest of the fleet in one workflow, keep the key in a shared workspace store rather than in each person's client config, and state the per-line unit price where a reviewer can see it before the run.

Typed report nodes, and the escape hatch

The classic Analytics API is not a resource API. It is one address whose meaning is chosen by a report type string, with 39 documented values and no nouns anywhere. Rather than ship 39 near-identical nodes or one free-text box, this integration ships eleven typed nodes that name the QUESTION and offer only their own family's report types as a validated choice, so asking Semrush: Keyword Ideas for a domain report returns an error naming the allowed values before any request goes out and before any units are spent. Every one of the 39 values belongs to exactly one typed node, and nothing is unreachable: Semrush: Run Any Report accepts all 39 and forwards an unrecognised value too, because Semrush ships report types faster than connectors are rebuilt. Prefer a typed node where one exists, since it validates the type, names the columns and states the unit cost.

Controlling what a run costs

Three levers. The ROW LIMIT is the main one, because most reports bill per line returned, so the limit is literally the price. SERVER-SIDE FILTERING is the second and it is underused: filtering at Semrush means fewer lines returned and therefore fewer units spent, while filtering after the fact means you paid for the rows you threw away. CHOOSING THE CHEAPER NODE is the third: Semrush: Domain Overview before Semrush: Domain Competitors, Semrush: Backlinks Overview at a flat 45 units per request or Semrush: Authority Score Distribution at 1 unit per line before Semrush: Backlinks at 45 units per line, and Semrush: Keyword Overview with the batch report type to score up to 100 keywords in one call instead of one call per keyword. One more thing that quietly multiplies a bill: pinning a historical month raises the rate by five on the reports that publish a historical price, so a backfill costs meaningfully more per line than the current month does.

CSV in, structured rows out

Semrush answers the classic reports as semicolon-delimited CSV with a header row rather than as JSON, so the connector parses it before handing it on. What you get is the report type, a columns list, a rows list of one object per line keyed by those column codes, a row count, and a truncation flag. Four details are worth knowing. The column keys are Semrush's own two-letter codes rather than friendly names, deliberately, because those are what the export columns field accepts and renaming them would make the field you set and the key you read disagree; each node's field help expands the codes for its own report types. Values stay STRINGS and are not cast, because one Semrush table can mix integers, decimals, a packed date stamp, a unix timestamp and a comma-joined trend series in a single row with no type information on the wire. Parsing is done with a real CSV reader rather than a split, because ad copy legitimately contains semicolons. And the row list is capped at 10,000 with the truncation reported rather than hidden, since Semrush will happily return an export large enough to break an execution record.

Reading the numbers honestly

Two classes of Semrush number need care in anything that aggregates them, and the nodes say so in their own descriptions. Traffic and search-volume figures are MODELLED estimates derived from Semrush's own SERP crawl and clickstream panel, not measured visits: treat them as directional, and never place them beside real analytics numbers as though they were the same kind of quantity. Positions, visibility figures, Authority Score and keyword difficulty are POINT-IN-TIME readings rather than counts, so they cannot be added across periods and an unweighted average of them is also wrong. That is why almost nothing here declares an aggregatable measure. The one windowed node, Semrush: Backlinks Historical Summary, declares its counts as latest-value rather than summed, because each row is a snapshot of the cumulative profile at that month rather than that month's activity, and it declares Authority Score as not decomposable at all. Semrush: Authority Score Distribution is a genuine edge case: its per-band domain counts can be summed WITHIN one response, since that is a distribution of one snapshot, and must never be summed across responses.

Windows, or the lack of them

This is the shape most likely to surprise someone planning a backfill. The classic Analytics API has no date range at all. Its only period control is a single value pinning ONE month, so there is no start and end to give a scheduled job, even on the reports that are genuinely historical. Semrush: Keyword Metrics (v4) has the same shape with a nicer spelling, one month rather than a range. Only Semrush: Backlinks Historical Summary takes a real start and end, and it is the only node here that declares a window. The practical consequence is that a monthly series is built by running a report once per month and storing the results yourself, rather than by asking Semrush for a range, and that the one-month caching restriction applies to the store you build that way.

The write nodes, and the one that destroys

Twenty-five of the 28 nodes only read. Semrush: Create Project and Semrush: Update Project are the ordinary writes, which makes campaign setup something an onboarding workflow can do rather than a manual step. Semrush: Delete Project is flagged destructive, because deleting a project takes the campaign tooling configured against it, and there is no undo to lean on. Gate it behind a condition or an approval task rather than a bare trigger, especially where an AI agent can reach the palette. The project nodes are also the only part of the Semrush API that lists anything, which is why they are the only nodes here with a real picker.

Troubleshooting

A node reports failure although the HTTP status was 200
That is Semrush's error convention rather than a fault, and handling it is the reason these nodes read the body instead of the status. Semrush reports failures as a plain-text line rather than reliably pairing them with a 4xx, so treating a 2xx as success would present a wrong key, an API that is not enabled on the plan, or an exhausted unit balance as an empty report. Read the message the node returns: the credential codes mean the key is malformed or does not match the account, one code means the key is real but the plan does not include API access, one means the balance is zero, and one is an account request cap. Each of those is a different fix, and the message names which one it is.
A report came back empty but the credential is fine
Semrush answers a query that matched nothing with a distinct nothing-found response, and the connector treats it as its own case on purpose. The node still reports failure, because a workflow branching on success must not read no-data as data, but it also sets a nothing-found flag and the code alongside it so a consumer can branch on the difference between an empty answer and a broken credential. This is also exactly what the connection test relies on: it asks about a domain in a reserved test-only top-level domain and treats the nothing-found answer as a pass, which is how the probe proves the key without returning a single billable line.
Units are draining faster than expected
Look at the row limit first, because most reports bill per line returned and the limit is therefore the price of the call. Then look at whether a historical month is pinned, which multiplies the rate by five on the reports that publish a historical price. Then look at which node is doing the work: the domain competitor family reaches 80 units per line on the widest report and Semrush: Backlinks is 45 units per line, so a thousand-row pull from either is a real number. Filter server-side rather than after the fact, so you stop paying for rows you discard, and put Semrush: API Units Balance in front of the expensive branch so a run stops itself rather than ending on a zero-balance error halfway through.
Everything fails at once with a rate or concurrency error
Semrush's usage restrictions document 10 requests per second and 10 simultaneous requests per account, and the account-wide part is the one that catches people: two workflows running at the same time share that budget, as does anyone using the same key from elsewhere. A workflow looping over a long list of domains with no pacing is the usual cause. Spread the schedule, batch where a report type allows it, and prefer Semrush: Keyword Overview with the batch report type over one call per keyword, which reduces both the request count and the unit spend at the same time.
A template reading the report rows resolves to nothing
Two likely causes. The classic reports are CSV, so the connector hands back a columns list plus a rows list of objects keyed by Semrush's own two-letter column codes rather than by friendly names: bind to the code, not to a name you invented. The v4 endpoints return JSON with the vendor's own data array, and the connector adds a flat rows alias beside it so charts and datasets have one consistent path across both halves of the connector. Check the node's sample output for the exact shape before writing the path. If the rows list is shorter than you expected, check the truncation flag: the connector caps rows at 10,000 and reports it rather than hiding it.
Numbers arrive as text and will not chart
Values from the classic reports are returned as strings, uncast, and that is a deliberate decision rather than an oversight. One Semrush table can mix integers, decimals, a packed date stamp, a unix timestamp and a comma-joined twelve-month trend series in a single row, with no per-column type information on the wire, so a blanket numeric cast would quietly rewrite the date stamp into an integer while looking correct everywhere else. Cast the specific columns you need in the workflow, where you know which column is which.
A backlinks report is missing something the older API had
The backlinks nodes here are built on Semrush's v4 JSON endpoints, not the older CSV backlinks family, because Semrush's own documentation marks that older family as deprecated and not recommended for new integrations. Building it would have meant shipping something the vendor tells new integrations not to use. v4 is also a genuine superset in this family: it adds Semrush: Backlinks Historical Summary and Semrush: Authority Score Distribution, which the older family did not have. If a specific legacy report has no equivalent, Semrush: Run Any Report forwards an unrecognised report type to the classic endpoint, so it remains reachable with a hand-typed value.
There is no date range on the report I want to backfill
There is not one to find. The classic Analytics API has no start and end parameters anywhere: its only period control pins a single month, even on the reports that are genuinely historical, and Semrush: Keyword Metrics (v4) has the same one-month shape. The way to build a series is to run the report once per period on a schedule and store the results yourself, which is why only Semrush: Backlinks Historical Summary declares a window, since it is the one node that accepts a real start and end. Two things to carry into that design: pinning a past month costs five times the current-month rate on the reports that publish a historical price, and Semrush's usage restrictions do not permit caching API data for more than one month without written consent, so the store you build needs a retention policy rather than an archive.
The key works for reports but not for projects, or the other way round
One key covers both surfaces, but they are entitled and addressed differently, so a split failure is informative rather than mysterious. The classic Analytics reports take the key as a query parameter and need the Standard API entitlement, meaning the SEO Business subscription plus a purchased units package. The v4 endpoints, which are the backlinks family, keyword metrics and projects, take an Authorization header on a different path. The connection test only exercises the classic side, which is why the verify path above also runs a v4 node. If the classic reports work and the v4 ones do not, check the subscription rather than the key.

Semrush is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products