SEMrush

Before opening Bubble, test the SEMrush API in your browser to understand what you're working with. Open this URL (replace YOUR_API_KEY and example.com with your own): `https://api.semrush.com/?type=domain_ranks&key=YOUR_API_KEY&domain=example.com&database=us&export_columns=Or,Ot,Oc,Ad,At,Ac` You'll see a response like: ``` Or;Ot;Oc;Ad;At;Ac 12345;450000;3.50;200;15000;2.00 ``` The first line is a semicolon-delimited header row. The second line (and any following lines) are the data rows. Each value maps to its column header. Bubble's API Connector cannot parse this format natively — it expects JSON. This is why parsing is a mandatory step, not optional. Also note the domain format: SEMrush requires the bare domain without protocol or trailing slash. Enter `example.com` not `https://www.example.com/`. This is the #1 cause of the 'ERROR 50: NOTHING FOUND' response — the domain format is wrong, not a data availability issue. The column codes for domain_ranks report: Or = organic keywords count, Ot = organic traffic estimate, Oc = organic traffic cost (in USD), Ad = paid keywords, At = paid traffic, Ac = paid traffic cost.

1// SEMrush API response format — semicolon-delimited text
2// Example: GET https://api.semrush.com/?type=domain_ranks&key=API_KEY&domain=example.com&database=us
3
4// Response (plain text, NOT JSON):
5Or;Ot;Oc;Ad;At;Ac
612345;450000;3.50;200;15000;2.00
7
8// Column meanings for domain_ranks:
9// Or = organic keyword count
10// Ot = estimated monthly organic traffic
11// Oc = organic traffic cost (USD)
12// Ad = paid keyword count
13// At = estimated paid traffic
14// Ac = paid traffic cost (USD)
15
16// For domain_organic (keyword list) — costs units per row:
17// Keyword positions report returns one data row per keyword
18// Use display_limit=50 to limit rows and control unit consumption
19
20// ERROR 50 example (domain not found or wrong format):
21// ERROR 50 :: NOTHING FOUND

In Bubble, click the Plugins tab → 'API Connector'. Click 'Add another API'. Name it 'SEMrush API'. Set the base URL to `https://api.semrush.com`. Do NOT add any shared headers. SEMrush authentication is done entirely via URL parameters, not headers. The API does not accept an Authorization header. Click 'Add a call'. Name it 'Get Domain Ranks'. Set method to GET, path to `/` (the SEMrush API uses a single base endpoint with the report type as a parameter). Add URL parameters: - `type` — value: `domain_ranks` (selects the report type) - `key` — value: your SEMrush API key — IMPORTANT: enable the **Private** checkbox on this parameter. In Bubble's API Connector, URL parameters can be marked Private just like headers, which keeps the key on Bubble's server and out of the browser. Enter your actual key value here. - `domain` — leave as a dynamic parameter (you'll pass domain names from your Bubble UI) - `database` — value: `us` (or your target country: uk, de, fr, au, etc.) - `export_columns` — value: `Or,Ot,Oc,Ad,At,Ac` (select only the columns you need) - `display_limit` — value: `1` (domain_ranks always returns 1 row; for keyword-level reports, set this to 50 to limit unit consumption) IMPORTANT: Do NOT click 'Initialize call' yet. SEMrush returns plain text, not JSON. If you try to Initialize now, Bubble will fail to parse the response and show 'There was an issue setting up your call'. You'll handle initialization after adding the parsing step.

1// API Connector: SEMrush API
2{
3  "api_name": "SEMrush API",
4  "base_url": "https://api.semrush.com",
5  "authentication": "none",
6  "calls": [
7    {
8      "name": "Get Domain Ranks",
9      "method": "GET",
10      "path": "/",
11      "params": [
12        { "name": "type", "value": "domain_ranks" },
13        {
14          "name": "key",
15          "value": "YOUR_SEMRUSH_API_KEY",
16          "private": true
17        },
18        { "name": "domain", "value": "<dynamic>" },
19        { "name": "database", "value": "us" },
20        { "name": "export_columns", "value": "Or,Ot,Oc,Ad,At,Ac" },
21        { "name": "display_limit", "value": "1" }
22      ]
23    }
24  ]
25}

Go to Plugins tab → 'Add plugins' → search 'Toolbox' → Install 'Toolbox' by Bubble (free). This plugin adds a 'Server Script' action to Bubble workflows that runs JavaScript server-side, which you'll use to parse SEMrush's semicolon-delimited text. Now build the parsing workflow. In the Bubble editor, create a Backend Workflow named 'Fetch SEMrush Domain Data'. Add a text input parameter to this workflow named 'domain' (this is passed when the workflow is called from a page). Add the following actions to the workflow: Action 1: 'Plugins → SEMrush API - Get Domain Ranks'. Set the domain parameter to: This workflow's domain. This makes the API call and stores the result as Step 1's text response. Action 2: 'Toolbox - Server Script'. In the Script field, enter the JavaScript parsing code below. This script receives the SEMrush plain text, splits it into headers and values, and returns a structured JSON object. Set the 'Result type' to 'text' or 'object' depending on how you'll use the output. Action 3: 'Create a new DomainMetric' (your Bubble data type, created in the next step). Map the fields from the Server Script's output: organic_keywords = Step 2's result's Or, organic_traffic = Step 2's result's Ot, etc. To trigger this workflow from a Bubble page, add a 'Schedule API Workflow' action on a 'Refresh SEMrush Data' button, passing the domain input value as the workflow's domain parameter.

1// Toolbox Server Script — parse SEMrush semicolon-delimited text
2// Action type: Server Script in Backend Workflow
3// Input: Step 1's body (the raw SEMrush API text response)
4
5var raw = properties.text_input; // the raw SEMrush response text
6var lines = raw.split('\n').filter(function(l) { return l.trim().length > 0; });
7
8if (lines.length < 2) {
9  // No data or error response
10  return { error: raw };
11}
12
13var headers = lines[0].split(';');
14var values = lines[1].split(';');
15
16var result = {};
17for (var i = 0; i < headers.length; i++) {
18  result[headers[i]] = values[i] || '';
19}
20
21return result;
22
23// Example output for domain_ranks:
24// { Or: "12345", Ot: "450000", Oc: "3.50", Ad: "200", At: "15000", Ac: "2.00" }

Before running the Backend Workflow, create the Bubble data type that will store cached SEMrush results. Go to Data tab → Data types → 'Create a new type' → name it 'DomainMetric'. Add these fields: - `domain` (text) — the queried domain (bare format, e.g., 'example.com') - `organic_keywords` (number) — from SEMrush Or column - `organic_traffic` (number) — from SEMrush Ot column - `organic_cost` (number) — from SEMrush Oc column - `paid_keywords` (number) — from SEMrush Ad column - `paid_traffic` (number) — from SEMrush At column - `fetched_at` (date) — when this data was last retrieved - `database` (text) — the SEMrush geographic database used (e.g., 'us', 'uk') In the Backend Workflow's Action 3, map the Server Script output to these fields. Note that all SEMrush values come back as strings even when they're numbers — convert them using Bubble's ':converted to number' operator on each field. Add a cache check to avoid re-fetching within 24 hours. At the start of your Backend Workflow, add a conditional: if a DomainMetric already exists for this domain with fetched_at within the last 24 hours, stop the workflow (Only when: search for DomainMetrics where domain = this workflow's domain, fetched_at > Current date/time - 1 day → count = 0). Set Privacy rules: Data tab → Privacy → DomainMetric. SEMrush data is paid competitive intelligence. Restrict access to admin-role users or logged-in users only. Do not allow anonymous access through Bubble's Data API. WU note: each Backend Workflow run that calls SEMrush consumes both Bubble WU (API call, workflow steps, database write) and SEMrush API units. The 24-hour cache prevents both types of consumption from adding up on high-traffic dashboards.

1// Bubble data type: DomainMetric
2// domain            (text)
3// organic_keywords  (number)
4// organic_traffic   (number)
5// organic_cost      (number)
6// paid_keywords     (number)
7// paid_traffic      (number)
8// fetched_at        (date)
9// database          (text)
10
11// Privacy Rule (Data tab → Privacy → DomainMetric):
12// Condition: Current User is logged in
13// Access: View all fields = YES
14
15// Cache check condition in Backend Workflow:
16// Only when: Do a search for DomainMetrics
17//   constraint: domain = This workflow's domain
18//   constraint: fetched_at > Current date/time - 1 day
19//   :count is 0
20// (Skip the fetch if recent data exists)

Create a new Bubble page called 'seo-dashboard'. This page displays SEMrush metrics for your domain and competitor domains side by side, reading from the cached DomainMetric data type. Add a Repeating Group with type 'DomainMetric'. Set the data source to 'Do a search for DomainMetrics', sorted by organic_traffic descending. In each row, display: - domain (text) - organic_keywords (formatted with commas as a number) - organic_traffic (formatted as a number with commas) - organic_cost (formatted as currency '$###,###') - paid_keywords (formatted with commas) - fetched_at (formatted as 'Last updated: MMM D, YYYY') Add a text Input element above the Repeating Group labeled 'Add domain to track'. Add a button 'Fetch SEMrush Data' with a workflow: trigger Backend Workflow 'Fetch SEMrush Domain Data' with domain = Input's value. Add validation: the Input value must not be empty and must not start with 'http' (bare domain only — strip protocol if users accidentally include it). For the bar chart comparison view, add a visual chart element. If your Bubble plan includes charts, create a bar or horizontal bar chart bound to the DomainMetric search with organic_traffic as the value axis and domain as the category axis. This gives an instant visual comparison of estimated organic traffic across tracked domains. RapidDev's team has helped agencies build Bubble-based SEO intelligence portals using SEMrush, Ahrefs, and Google Search Console in unified dashboards — if you need a multi-source competitive dashboard built, reach out at rapidevelopers.com/contact.

1// SEO Dashboard — Repeating Group layout
2
3// Repeating Group data source:
4// Search for DomainMetrics
5// Sort: organic_traffic descending
6// Columns: domain | organic_keywords | organic_traffic | organic_cost | fetched_at
7
8// 'Add Domain' input validation workflow:
9// Condition: Input's value is empty → show alert 'Please enter a domain'
10// Condition: Input's value contains 'http' → show alert 'Enter bare domain only (e.g. example.com)'
11// Otherwise: Schedule API Workflow 'Fetch SEMrush Domain Data'
12//   with domain = Input's value
13
14// Number formatting examples in text elements:
15// organic_traffic: Current cell's DomainMetric's organic_traffic:formatted as ###,###
16// organic_cost: Current cell's DomainMetric's organic_cost:formatted as $###,###.##
17// fetched_at: Current cell's DomainMetric's fetched_at:formatted as 'MMM D, YYYY'