Build SEO Workflows Without Code: Introducing Rampify's Automation-First API

We've rebuilt our API from the ground up with one goal: make automation so easy you don't need to write JavaScript.

If you've ever tried building n8n or Zapier workflows that consume REST APIs, you know the pain:

• Writing JavaScript to filter and group data
• Manually categorizing items with switch statements
• Building complex IF/THEN logic just to route data
• Wrestling with JSON structures that weren't designed for automation

That ends today.

The Problem with Traditional APIs#

Most APIs are designed for developers writing code. They return raw data and expect you to:

1. Filter it yourself - Loop through arrays, check conditions, build new objects
2. Group it yourself - Categorize items, calculate counts, organize by type
3. Route it yourself - Write IF/THEN logic to decide what to do with the data

This works great if you're writing Python or Node.js. But in n8n or Zapier? You're stuck writing JavaScript in tiny code nodes, debugging JSON paths, and fighting with execution contexts.

Our Solution: Zero-Code Routing#

We added a ?view= parameter to our action items endpoint that completely eliminates the need for custom code:

1. The routing View - Boolean Flags for IF/THEN Logic#

Instead of this (old way):

// n8n Code Node - Manual filtering
const actions = $input.all();
const hasCritical = actions.some(a => a.priority === 'critical');
const hasAutoFixable = actions.some(a =>
  ['missing_meta_description', 'short_title'].includes(a.actionType)
);
return { hasCritical, hasAutoFixable };

You get this (new way):

GET /action-snapshots/{id}/actions?view=routing

Response:

{
  "routing_hints": {
    "has_critical": false,
    "has_auto_fixable_meta": true,
    "has_auto_fixable_schema": false,
    "has_indexing_issues": true,
    "recommended_next_action": "fix_meta_tags"
  },
  "counts": {
    "total_actions": 11,
    "auto_fixable": 8,
    "manual_review": 3
  }
}

Now in n8n, you just use IF nodes:

• Condition: {{ $json.routing_hints.has_critical }} equals true
• True branch: Send Slack alert
• False branch: Continue to next check

Zero JavaScript required.

2. The grouped View - Pre-Organized Data#

Instead of manually grouping actions by type, category, or priority, we do it for you:

GET /action-snapshots/{id}/actions?view=grouped

Response:

{
  "groups": {
    "auto_fixable": {
      "count": 8,
      "actions": [...]
    },
    "manual_review": {
      "count": 3,
      "actions": [...]
    },
    "by_priority": {
      "critical": { "count": 0, "actions": [] },
      "high": { "count": 5, "actions": [...] }
    }
  }
}

Perfect for batch processing - just iterate through groups.auto_fixable.actions and trigger your fix workflow.

3. The summary View - Dashboard-Ready Stats#

Building a dashboard or sending email reports? The summary view gives you exactly what you need:

GET /action-snapshots/{id}/actions?view=summary

Response:

{
  "overview": {
    "total_actions": 11,
    "health_score": 72,
    "improvement_potential": "28%"
  },
  "top_actions": [
    {
      "title": "Missing Meta Description (12 affected)",
      "priority": "high",
      "affectedCount": 12
    }
  ],
  "quick_wins": {
    "count": 5,
    "estimated_time": "30-60 minutes",
    "actions": [
      "Fix 12 missing meta descriptions",
      "Add schema to 3 pages"
    ]
  }
}

Drop this straight into a Slack message or email template. No transformation needed.

Real-World Use Cases#

Use Case 1: Daily SEO Monitor#

Goal: Check your site every morning, alert on critical issues, auto-fix simple ones.

n8n Workflow (no code needed):

1. Schedule Trigger - Runs at 10am daily
2. HTTP Request - POST /clients/{id}/analyze with { "callbackUrl": $execution.resumeUrl } (start site analysis)
3. Wait Node - Pauses workflow until callback is received
4. HTTP Request - POST /sites/{id}/action-snapshots/generate (create action plan)
5. HTTP Request - GET /action-snapshots/{id}/actions?view=routing (get routing hints)
6. IF Node - \{\{ $json.routing_hints.has_critical \}\} = true?
   • YES: Create GitHub issues for each critical item
   • NO: Continue to next check
7. IF Node - \{\{ $json.routing_hints.has_auto_fixable_meta \}\} = true?
   • YES: Trigger auto-fix workflow (call meta generation API)
   • NO: Continue
8. Send Email - Daily summary with \{\{ $json.counts.total_actions \}\} issues found

Key Innovation: Callback Pattern

Instead of polling the API every few seconds to check if analysis is complete, we use n8n's Wait node with webhook callbacks:

// Step 2: Trigger analysis with callback URL
POST /clients/{id}/analyze
{
  "callbackUrl": "{{ $execution.resumeUrl }}"
}

How it works:

1. n8n generates a unique resume URL for each workflow execution (via $execution.resumeUrl)
2. Rampify stores this URL in the database alongside the site check
3. Analysis runs in the background (Inngest handles the crawl, no timeout limits)
4. When complete, Rampify POSTs results to the stored callback URL
5. n8n workflow resumes with all the analysis data available in $json

Why this is better than polling:

| Polling Approach | Callback Approach | |------------------|-------------------| | Check every 10s: "done yet?" | One ping when actually done | | 30+ API requests wasted | 2 total requests (start + callback) | | Workflow keeps running ($$$) | Workflow paused (free) | | 10-minute timeout limit | No timeout (can run hours) |

Supports parallel workflows: Each execution gets its own unique callback URL, so you can run multiple site analyses simultaneously without conflicts.

Total JavaScript written: 0 lines

Get the workflow: Download from GitHub

Use Case 2: Pre-Deployment Check#

Goal: Before deploying, check staging site for SEO issues.

Make.com Scenario:

1. Webhook Trigger - Receives deployment event from CI/CD
2. HTTP Module - Trigger site analysis
3. Sleep Module - Wait for crawl to complete
4. HTTP Module - Get actions with ?view=routing&filter=critical
5. Router Module - Route based on routing_hints.has_critical
   • Route 1 (has critical): Block deployment, post to GitHub PR
   • Route 2 (no critical): Approve deployment, proceed

Total code: None. Just HTTP requests and routers.

Use Case 3: Weekly Client Reports#

Goal: Email clients their SEO health score and top issues every Monday.

Zapier Workflow:

1. Schedule - Every Monday 9am
2. Rampify API - Generate action snapshot
3. Rampify API - Get summary view: ?view=summary
4. Email by Zapier - Send formatted email:
   • Subject: "Your SEO Health Score: {health_score}"
   • Body template uses \{top_actions\} and \{quick_wins\}

Zapier Formatter needed: None. Data is already email-ready.

Filter Combinations#

Mix ?view= with ?filter= for powerful combinations:

# Get only auto-fixable issues, already grouped
?filter=auto_fixable&view=grouped

# Get only critical issues as a flat array
?filter=critical&view=flat

# Get routing hints for high-priority items
?filter=high&view=routing

# Get summary of just indexing issues
?filter=indexing&view=summary

Every filter + view combination is documented in our OpenAPI spec.

Decision Tree for Automation#

Here's the exact decision tree we recommend for n8n/Zapier:

1. GET actions with ?view=routing

2. IF has_critical = true
   → Send urgent alert (Slack/PagerDuty)
   → STOP (manual intervention needed)

3. IF has_auto_fixable_meta = true
   → GET actions with ?filter=auto_fixable&view=grouped
   → Iterate through groups.auto_fixable.actions
   → Call /meta/generate for each URL
   → Mark actions as completed

4. IF has_auto_fixable_schema = true
   → Similar auto-fix flow for schema

5. IF has_indexing_issues = true
   → GET actions with ?filter=indexing
   → Submit URLs to Google Search Console

6. IF has_any_actions = true
   → Send summary email with remaining issues
   ELSE
   → Send "All Good" notification

Every step uses boolean flags from the API. No JavaScript, no complex logic.

Technical Implementation#

Behind the scenes, we:

1. Pre-compute routing hints - Boolean flags are calculated server-side
2. Cache grouped views - Expensive aggregations happen once
3. Optimize for automation - Response structure matches n8n/Zapier data models
4. Document everything - OpenAPI spec with examples for every view type

Our philosophy: The API should do the hard work, not your automation tool.

Developer Experience#

For teams that DO want to write code, we still support the standard ?view=flat (default) that returns a clean array of action items. You can filter, group, and transform however you want.

But for the 90% of use cases where you just want to:

• Route based on severity
• Batch process auto-fixable items
• Display top issues in a dashboard

You don't need code anymore.

AI-Native Alternative: Claude Code Subagents#

While no-code tools like n8n and Zapier are powerful for workflow automation, there's another approach: AI-native automation with Claude Code subagents.

Key Difference:

• No-code tools: Visual workflows with pre-defined triggers and actions
• AI subagents: Natural language instructions with autonomous decision-making

Example workflow comparison:

n8n (No-Code):

1. Schedule trigger (daily)
2. GET /actions?view=routing
3. IF has_critical = true → Send Slack alert
4. IF has_auto_fixable_meta = true → Loop through actions
5. Call /meta/generate for each

Claude Code Subagent (AI-Native):

seo-agent> Check my site daily. If you find critical issues,
alert me on Slack. For auto-fixable meta tags, just fix them
and let me know what you changed.

The subagent handles the routing logic, API calls, and decision-making autonomously.

When to use each:

• Use n8n/Zapier: Multi-tool integrations (Slack + Airtable + Email)
• Use AI subagents: Content creation, SEO optimization, code generation
• Use both: n8n triggers the subagent for complex workflows

Learn more: Automate SEO Blog Writing with Claude Code Subagents

API Reference#

All of this is documented with real examples in our API Reference:

• Introduction section - Quick start workflow for n8n/Zapier
• Decision tree - Step-by-step routing logic with n8n expressions
• View examples - Complete JSON responses for all 4 view types
• Filter combinations - Every supported filter + view pair

Get Started#

1. Sign up at rampify.dev
2. Generate API key at Settings → API Keys
3. View the API docs at rampify.dev/api-reference
4. Import our n8n workflow from GitHub

Or just start with a simple workflow:

# Get your action plan with routing hints
curl -H "Authorization: Bearer sk_live_your_key" \
  "https://www.rampify.dev/api/action-snapshots/{id}/actions?view=routing"

Then use those boolean flags in your automation tool. No code needed.

Questions? Check the API docs.

Want to see the code? All workflows are open-sourced on GitHub.