Ahrefs

Before touching Bubble, set up Ahrefs API access and understand the billing model that shapes every decision in this integration. Log in to Ahrefs and navigate to your account settings. Find the API section — this is only accessible on Advanced and Enterprise plans. If the API menu item doesn't appear, your current plan doesn't include API access. Generate a new API token and copy it immediately — the token is shown only once after creation. If you miss it, you'll need to regenerate. The Ahrefs API charges units per row returned from each endpoint call. The exact unit cost per row depends on the endpoint — the backlinks endpoint costs more per row than the domain overview endpoint. Check the Ahrefs API documentation for current unit rates for each endpoint you plan to use. This is not a cost you can ignore: on the Dashboard page of your Bubble app, if the Repeating Group data source is a live Ahrefs API call and 100 users load that page, you've made 100 API calls consuming units proportional to the rows returned in each. The unit consumption pattern guides the architecture you'll build: - Fetch once per day in a Backend Workflow - Store in Bubble database - Read from database on every page load - Use a 'Refresh' button for on-demand updates Also familiarize yourself with the `mode` parameter that most Ahrefs endpoints accept. The most common values are: - `domain`: all pages on the domain and all subdomains - `subdomains`: root domain only, no subdomains - `exact`: one specific URL For most backlink monitoring use cases, `domain` is correct. Wrong mode = data that looks empty or incomplete.

Open your Bubble editor and go to Plugins → Add plugins. Search for 'API Connector' and install the one by Bubble (free). In the API Connector panel, click 'Add another API'. Name it 'Ahrefs'. In the Base URL field, enter: `https://api.ahrefs.com/v3` For authentication, do NOT select 'Username & Password' or 'Private key in header' dropdown options. Instead, use a shared header approach: Click 'Add a shared header'. In the key field, enter: `Authorization`. In the value field, enter: `Bearer YOUR_TOKEN_HERE` — but replace `YOUR_TOKEN_HERE` with your actual Ahrefs API token. Check the 'Private' checkbox on this header row. The 'Private' checkbox is what keeps your token server-side — without it, the Authorization header value would be visible in browser network requests. The full header value (including the word 'Bearer' followed by a space) looks like: `Bearer eyJhbGci...` (your actual token string after the space). Do not put the token alone in the value field — Ahrefs requires the `Bearer ` prefix. A token without the prefix returns a 401 Unauthorized. Click 'Save'. Unlike Campaign Monitor's unusual Basic Auth, Ahrefs uses completely standard Bearer token auth — there are no surprises here beyond making sure the Private checkbox is enabled.

1{
2  "base_url": "https://api.ahrefs.com/v3",
3  "shared_headers": [
4    {
5      "key": "Authorization",
6      "value": "Bearer <private: your_ahrefs_api_token>",
7      "private": true
8    }
9  ],
10  "note": "Include 'Bearer ' prefix (with space) before the token value."
11}

Add your first Ahrefs API call: the Domain Rating endpoint. This is the fastest and most unit-efficient call to start with. Click 'Add a new call' under the Ahrefs API. Name it 'Get Domain Rating'. Set Method to GET. Set the path to `/site-explorer/domain-rating`. Set 'Use as' to Data. Add URL parameters: - `target`: set to dynamic (`<dynamic: target>`) — this will be the bare domain you pass in - `date`: optional, ISO format date — leave blank for current DR Click 'Initialize call'. In the dynamic fields, enter a real bare domain you want to test with (e.g., `ahrefs.com` or your own domain). Do NOT enter `https://ahrefs.com` or `ahrefs.com/` — just the bare domain. Click Initialize. A successful response looks like: ```json { "domain": "ahrefs.com", "domain_rating": 90 } ``` Bubble detects the `domain` and `domain_rating` fields. After initialization, you can bind these fields in your Bubble UI: a text element with expression `Get Domain Rating's domain_rating` displays the DR score. Also create a second call for Domain Rating history. Name it 'Get DR History'. Path = `/site-explorer/domain-rating-history`. Parameters: - `target`: dynamic - `history_grouping`: `monthly` (returns one data point per month) - `limit`: `12` (last 12 months) Initialize with your test domain. The response is an array of objects with `date` and `domain_rating` fields — perfect for binding to a Bubble Chart element for a visual DR trend.

1{
2  "get_domain_rating": {
3    "method": "GET",
4    "path": "/site-explorer/domain-rating",
5    "params": {
6      "target": "<dynamic: target>"
7    },
8    "example_response": {
9      "domain": "example.com",
10      "domain_rating": 67
11    }
12  },
13  "get_dr_history": {
14    "method": "GET",
15    "path": "/site-explorer/domain-rating-history",
16    "params": {
17      "target": "<dynamic: target>",
18      "history_grouping": "monthly",
19      "limit": "12"
20    },
21    "example_response": {
22      "domain_rating": [
23        { "date": "2026-06-01", "domain_rating": 65 },
24        { "date": "2026-07-01", "domain_rating": 67 }
25      ]
26    }
27  }
28}

Add the backlink calls that power the monitoring dashboard. These are the most unit-intensive calls — configure them with conservative limits. Add a new call. Name it 'Get New Backlinks'. Method = GET. Path = `/site-explorer/all-backlinks`. Parameters: - `target`: dynamic - `mode`: `domain` - `limit`: `100` - `order_by`: `domain_rating_source:desc` - `where`: `is_new:eq:true` The `where` parameter filters for backlinks discovered in the last data refresh period. This narrows results to genuinely new links rather than your entire backlink profile. Add another call. Name it 'Get Lost Backlinks'. Same path and parameters but change: - `where`: `is_lost:eq:true` Initialize both calls with your test domain. The response for each is an array of backlink objects with fields including: - `url_from` — the page that links to your site - `domain_from` — the root domain of the linking site - `domain_rating_source` — the DR of the linking domain - `anchor` — the anchor text of the link - `url_to` — your page being linked to - `first_seen` — date the link was first detected (for new backlinks) - `lost_date` — date the link was lost (for lost backlinks) Set 'Use as' to Data for both calls. Now create the Bubble data types to store these results. In the Data tab, create: - **AhrefsBacklink** with fields: domain_from (text), url_from (text), domain_rating_source (number), anchor (text), url_to (text), first_seen (date), link_type (text — 'new' or 'lost'), target_domain (text), snapshot_date (date) - **AhrefsSnapshot** with fields: target_domain (text), dr (number), referring_domains (number), snapshot_date (date) These data types are what your dashboard reads from — not the live API.

1{
2  "get_new_backlinks": {
3    "method": "GET",
4    "path": "/site-explorer/all-backlinks",
5    "params": {
6      "target": "<dynamic: target>",
7      "mode": "domain",
8      "limit": "100",
9      "order_by": "domain_rating_source:desc",
10      "where": "is_new:eq:true"
11    }
12  },
13  "get_lost_backlinks": {
14    "method": "GET",
15    "path": "/site-explorer/all-backlinks",
16    "params": {
17      "target": "<dynamic: target>",
18      "mode": "domain",
19      "limit": "100",
20      "order_by": "domain_rating_source:desc",
21      "where": "is_lost:eq:true"
22    }
23  },
24  "example_backlink_object": {
25    "url_from": "https://example.com/blog/post",
26    "domain_from": "example.com",
27    "domain_rating_source": 72,
28    "anchor": "great resource",
29    "url_to": "https://yoursite.com/page",
30    "first_seen": "2026-07-08"
31  }
32}

This step is the core of a production-ready Ahrefs integration. The Backend Workflow runs on a schedule, makes the Ahrefs API calls, and saves results to the Bubble database. The dashboard reads from the database — not from live API calls. In Bubble, go to the Backend Workflows tab (visible only on paid plans — this is a paid-plan feature). Click 'Add a new API Workflow'. Name it 'Refresh Ahrefs Data'. Enable 'Schedule this workflow'. In the workflow, add these steps: **Step 1: Get Domain Rating.** Use the 'Ahrefs - Get Domain Rating' action. Pass `target` = the domain you want to monitor (either a static value or a parameter passed into the workflow). **Step 2: Create AhrefsSnapshot.** Create a new AhrefsSnapshot Thing with: - target_domain = the target parameter - dr = Result of Step 1's domain_rating - snapshot_date = Current date/time **Step 3: Get New Backlinks.** Use 'Ahrefs - Get New Backlinks' with the same target. **Step 4: Save New Backlinks.** For each item in Step 3's result list, create an AhrefsBacklink record with link_type = 'new' and snapshot_date = Current date/time. Use Bubble's 'Make changes to a list' or a 'Schedule API workflow on a list' action to iterate through the results. **Step 5: Get Lost Backlinks** and **Step 6: Save Lost Backlinks** — same pattern with link_type = 'lost'. After setting up the workflow steps, go to the Schedule section. Set it to run once per day at a low-traffic time (e.g., 6:00 AM UTC). The workflow URL is shown at the top of the workflow editor — note it for reference. To trigger the workflow on demand from the UI (for a 'Refresh Now' button), add a button to your admin page. Its click workflow: 'Schedule API workflow → Refresh Ahrefs Data → Schedule for Current date/time + 1 second'. RapidDev's team has built SEO monitoring Bubble apps with this exact daily caching pattern — if you need to scale this to multiple domains or add automated alerting when DR drops, a free scoping call is available at rapidevelopers.com/contact.

1{
2  "backend_workflow_name": "Refresh Ahrefs Data",
3  "schedule": "Daily at 06:00 UTC",
4  "parameters": [
5    { "name": "target_domain", "type": "text" }
6  ],
7  "steps": [
8    "Step 1: Call Get Domain Rating with target = target_domain parameter",
9    "Step 2: Create AhrefsSnapshot — dr = Step 1's domain_rating, target_domain = parameter, snapshot_date = now",
10    "Step 3: Call Get New Backlinks with target = target_domain",
11    "Step 4: For each backlink in Step 3 result: Create AhrefsBacklink with link_type = 'new'",
12    "Step 5: Call Get Lost Backlinks with target = target_domain",
13    "Step 6: For each backlink in Step 5 result: Create AhrefsBacklink with link_type = 'lost'"
14  ],
15  "note": "Backend Workflows require a paid Bubble plan."
16}

With data flowing into the Bubble database, build the dashboard UI and lock down access. **Dashboard UI:** Add a Stats row at the top of the page: - DR Score: bind to 'Search for AhrefsSnapshot where target_domain = [your domain], sorted by snapshot_date descending, first item's dr' - Last Updated: bind to same query's snapshot_date, formatted as 'MM/DD/YYYY HH:mm' Add a Chart element (requires Bubble's built-in Charts element or a chart plugin). Set data source to all AhrefsSnapshot records for the target domain sorted by snapshot_date ascending. X axis = snapshot_date, Y axis = dr. This creates the visual DR trend line. Add two Repeating Groups below the chart: 1. **New Backlinks**: data source = AhrefsBacklink where link_type = 'new' AND snapshot_date >= [today - 1 day], sorted by domain_rating_source descending. Display: domain_from, domain_rating_source, anchor text, url_from. 2. **Lost Backlinks**: same structure with link_type = 'lost'. **Privacy Rules:** Go to Data tab → AhrefsSnapshot → Set privacy rules. Add: 'This thing is visible to' → Current User's role is 'Admin'. Apply the same restriction to AhrefsBacklink. Ahrefs subscription data represents paid competitive intelligence. If you're building a client-facing SEO dashboard (multi-tenant), add a second rule: 'Current User's domain = This AhrefsSnapshot's target_domain' to ensure Client A cannot see Client B's DR data. Without privacy rules, any logged-in Bubble user — or public visitors if your data type is exposed via Bubble's Data API — can read Domain Rating history and backlink data from your database. This is a common oversight on SEO monitoring apps.