How to Integrate Replit with SpyFu

1import os
2import requests
3from flask import Flask, request, jsonify
4
5app = Flask(__name__)
6
7SPYFU_API_KEY = os.environ["SPYFU_API_KEY"]
8BASE_URL = "https://www.spyfu.com/apis/core_api/v2"
9
10
11def spyfu_get(endpoint: str, params: dict) -> dict:
12    """Make a GET request to the SpyFu API."""
13    params["api_key"] = SPYFU_API_KEY
14    resp = requests.get(f"{BASE_URL}{endpoint}", params=params)
15    resp.raise_for_status()
16    return resp.json()
17
18
19@app.route("/domain-stats")
20def domain_stats():
21    """Get high-level SEO and PPC stats for a domain."""
22    domain = request.args.get("domain")
23    if not domain:
24        return jsonify({"error": "domain parameter required"}), 400
25    try:
26        data = spyfu_get("/domains/stats", {"q": domain})
27        return jsonify(data)
28    except requests.HTTPError as e:
29        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
30
31
32@app.route("/organic-keywords")
33def organic_keywords():
34    """Get top organic keywords for a domain."""
35    domain = request.args.get("domain")
36    page_size = int(request.args.get("page_size", 20))
37    starting_row = int(request.args.get("starting_row", 0))
38    if not domain:
39        return jsonify({"error": "domain parameter required"}), 400
40    try:
41        data = spyfu_get("/domains/organic_keywords", {
42            "q": domain,
43            "pageSize": min(page_size, 100),
44            "startingRow": starting_row,
45            "sortBy": "monthly_clicks",
46            "sortOrder": "descending"
47        })
48        return jsonify(data)
49    except requests.HTTPError as e:
50        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
51
52
53@app.route("/ppc-keywords")
54def ppc_keywords():
55    """Get PPC keywords and ad data for a domain."""
56    domain = request.args.get("domain")
57    page_size = int(request.args.get("page_size", 20))
58    starting_row = int(request.args.get("starting_row", 0))
59    if not domain:
60        return jsonify({"error": "domain parameter required"}), 400
61    try:
62        data = spyfu_get("/domains/ppc_keywords", {
63            "q": domain,
64            "pageSize": min(page_size, 100),
65            "startingRow": starting_row,
66            "sortBy": "monthly_clicks",
67            "sortOrder": "descending"
68        })
69        return jsonify(data)
70    except requests.HTTPError as e:
71        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
72
73
74@app.route("/competitor-report")
75def competitor_report():
76    """Generate a combined organic + PPC report for a domain."""
77    domain = request.args.get("domain")
78    if not domain:
79        return jsonify({"error": "domain parameter required"}), 400
80    try:
81        stats = spyfu_get("/domains/stats", {"q": domain})
82        organic = spyfu_get("/domains/organic_keywords", {
83            "q": domain, "pageSize": 10, "startingRow": 0,
84            "sortBy": "monthly_clicks", "sortOrder": "descending"
85        })
86        ppc = spyfu_get("/domains/ppc_keywords", {
87            "q": domain, "pageSize": 10, "startingRow": 0,
88            "sortBy": "monthly_clicks", "sortOrder": "descending"
89        })
90        return jsonify({
91            "domain": domain,
92            "stats": stats,
93            "top_organic_keywords": organic.get("results", []),
94            "top_ppc_keywords": ppc.get("results", [])
95        })
96    except requests.HTTPError as e:
97        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
98
99
100if __name__ == "__main__":
101    app.run(host="0.0.0.0", port=3000, debug=True)

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const SPYFU_API_KEY = process.env.SPYFU_API_KEY;
8const BASE_URL = 'https://www.spyfu.com/apis/core_api/v2';
9
10async function spyfuGet(endpoint, params = {}) {
11  const { data } = await axios.get(`${BASE_URL}${endpoint}`, {
12    params: { ...params, api_key: SPYFU_API_KEY }
13  });
14  return data;
15}
16
17// Domain overview stats
18app.get('/domain-stats', async (req, res) => {
19  const { domain } = req.query;
20  if (!domain) return res.status(400).json({ error: 'domain parameter required' });
21  try {
22    const data = await spyfuGet('/domains/stats', { q: domain });
23    res.json(data);
24  } catch (err) {
25    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
26  }
27});
28
29// Top organic keywords
30app.get('/organic-keywords', async (req, res) => {
31  const { domain, page_size = 20, starting_row = 0 } = req.query;
32  if (!domain) return res.status(400).json({ error: 'domain parameter required' });
33  try {
34    const data = await spyfuGet('/domains/organic_keywords', {
35      q: domain,
36      pageSize: Math.min(Number(page_size), 100),
37      startingRow: Number(starting_row),
38      sortBy: 'monthly_clicks',
39      sortOrder: 'descending'
40    });
41    res.json(data);
42  } catch (err) {
43    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
44  }
45});
46
47// PPC keywords
48app.get('/ppc-keywords', async (req, res) => {
49  const { domain, page_size = 20, starting_row = 0 } = req.query;
50  if (!domain) return res.status(400).json({ error: 'domain parameter required' });
51  try {
52    const data = await spyfuGet('/domains/ppc_keywords', {
53      q: domain,
54      pageSize: Math.min(Number(page_size), 100),
55      startingRow: Number(starting_row),
56      sortBy: 'monthly_clicks',
57      sortOrder: 'descending'
58    });
59    res.json(data);
60  } catch (err) {
61    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
62  }
63});
64
65// Keyword-based competitor lookup
66app.get('/keyword-competitors', async (req, res) => {
67  const { keyword, page_size = 10 } = req.query;
68  if (!keyword) return res.status(400).json({ error: 'keyword parameter required' });
69  try {
70    const data = await spyfuGet('/keywords/organic_competitors', {
71      q: keyword,
72      pageSize: Math.min(Number(page_size), 50)
73    });
74    res.json(data);
75  } catch (err) {
76    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
77  }
78});
79
80app.listen(3000, '0.0.0.0', () => {
81  console.log('SpyFu integration server running on port 3000');
82});

1[[ports]]
2internalPort = 3000
3externalPort = 80
4
5[deployment]
6run = ["node", "server.js"]
7deploymentTarget = "cloudrun"