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.
Connect Semrush to Mattering
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
A report came back empty but the credential is fine
Units are draining faster than expected
Everything fails at once with a rate or concurrency error
A template reading the report rows resolves to nothing
Numbers arrive as text and will not chart
A backlinks report is missing something the older API had
There is no date range on the report I want to backfill
The key works for reports but not for projects, or the other way round
Related
The Semrush MCP
What connecting Semrush unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
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.