How to Integrate Replit with Ubersuggest

1import os
2import requests
3from flask import Flask, request, jsonify
4
5app = Flask(__name__)
6
7UBERSUGGEST_API_KEY = os.environ["UBERSUGGEST_API_KEY"]
8BASE_URL = "https://app.neilpatel.com/api/v2"
9
10HEADERS = {
11    "Authorization": f"Bearer {UBERSUGGEST_API_KEY}",
12    "Content-Type": "application/json",
13    "Accept": "application/json"
14}
15
16
17def ubersuggest_get(endpoint: str, params: dict) -> dict:
18    """Make a GET request to the Ubersuggest API."""
19    resp = requests.get(f"{BASE_URL}{endpoint}", params=params, headers=HEADERS)
20    resp.raise_for_status()
21    return resp.json()
22
23
24@app.route("/keyword-suggestions")
25def keyword_suggestions():
26    """
27    Get keyword suggestions for a seed keyword.
28    Params: keyword, country (default 'us'), language (default 'en')
29    """
30    keyword = request.args.get("keyword")
31    country = request.args.get("country", "us")
32    language = request.args.get("language", "en")
33
34    if not keyword:
35        return jsonify({"error": "keyword parameter required"}), 400
36
37    try:
38        data = ubersuggest_get("/keywords/suggestions", {
39            "keyword": keyword,
40            "country": country,
41            "language": language
42        })
43        return jsonify(data)
44    except requests.HTTPError as e:
45        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
46
47
48@app.route("/keyword-overview")
49def keyword_overview():
50    """
51    Get detailed stats for a specific keyword.
52    Params: keyword, country, language
53    """
54    keyword = request.args.get("keyword")
55    country = request.args.get("country", "us")
56    language = request.args.get("language", "en")
57
58    if not keyword:
59        return jsonify({"error": "keyword parameter required"}), 400
60
61    try:
62        data = ubersuggest_get("/keywords/overview", {
63            "keyword": keyword,
64            "country": country,
65            "language": language
66        })
67        return jsonify(data)
68    except requests.HTTPError as e:
69        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
70
71
72@app.route("/domain-keywords")
73def domain_keywords():
74    """
75    Get top organic keywords for a domain.
76    Params: domain, country
77    """
78    domain = request.args.get("domain")
79    country = request.args.get("country", "us")
80
81    if not domain:
82        return jsonify({"error": "domain parameter required"}), 400
83
84    try:
85        data = ubersuggest_get("/traffic/keywords", {
86            "url": domain,
87            "country": country
88        })
89        return jsonify(data)
90    except requests.HTTPError as e:
91        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
92
93
94@app.route("/content-ideas")
95def content_ideas():
96    """
97    Get top-performing content for a keyword.
98    Params: keyword, country
99    """
100    keyword = request.args.get("keyword")
101    country = request.args.get("country", "us")
102
103    if not keyword:
104        return jsonify({"error": "keyword parameter required"}), 400
105
106    try:
107        data = ubersuggest_get("/content/ideas", {
108            "keyword": keyword,
109            "country": country
110        })
111        return jsonify(data)
112    except requests.HTTPError as e:
113        return jsonify({"error": str(e)}), e.response.status_code if e.response else 500
114
115
116if __name__ == "__main__":
117    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 UBERSUGGEST_API_KEY = process.env.UBERSUGGEST_API_KEY;
8const BASE_URL = 'https://app.neilpatel.com/api/v2';
9
10const HEADERS = {
11  Authorization: `Bearer ${UBERSUGGEST_API_KEY}`,
12  'Content-Type': 'application/json',
13  Accept: 'application/json'
14};
15
16async function ubersuggestGet(endpoint, params = {}) {
17  const { data } = await axios.get(`${BASE_URL}${endpoint}`, { params, headers: HEADERS });
18  return data;
19}
20
21// Keyword suggestions
22app.get('/keyword-suggestions', async (req, res) => {
23  const { keyword, country = 'us', language = 'en' } = req.query;
24  if (!keyword) return res.status(400).json({ error: 'keyword parameter required' });
25  try {
26    const data = await ubersuggestGet('/keywords/suggestions', { keyword, country, language });
27    res.json(data);
28  } catch (err) {
29    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
30  }
31});
32
33// Keyword overview with full stats
34app.get('/keyword-overview', async (req, res) => {
35  const { keyword, country = 'us', language = 'en' } = req.query;
36  if (!keyword) return res.status(400).json({ error: 'keyword parameter required' });
37  try {
38    const data = await ubersuggestGet('/keywords/overview', { keyword, country, language });
39    res.json(data);
40  } catch (err) {
41    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
42  }
43});
44
45// Filter keywords by difficulty and min volume
46app.get('/keyword-filter', async (req, res) => {
47  const {
48    keyword,
49    country = 'us',
50    language = 'en',
51    max_difficulty = 50,
52    min_volume = 100
53  } = req.query;
54
55  if (!keyword) return res.status(400).json({ error: 'keyword parameter required' });
56
57  try {
58    const data = await ubersuggestGet('/keywords/suggestions', { keyword, country, language });
59    const suggestions = data.suggestions || data.keywords || [];
60
61    const filtered = suggestions
62      .filter(k => (
63        (k.sd || k.difficulty || 0) <= Number(max_difficulty) &&
64        (k.sv || k.search_volume || 0) >= Number(min_volume)
65      ))
66      .sort((a, b) => (b.sv || b.search_volume || 0) - (a.sv || a.search_volume || 0));
67
68    res.json({
69      seed_keyword: keyword,
70      total_filtered: filtered.length,
71      keywords: filtered.slice(0, 50)
72    });
73  } catch (err) {
74    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
75  }
76});
77
78// Domain keywords
79app.get('/domain-keywords', async (req, res) => {
80  const { domain, country = 'us' } = req.query;
81  if (!domain) return res.status(400).json({ error: 'domain parameter required' });
82  try {
83    const data = await ubersuggestGet('/traffic/keywords', { url: domain, country });
84    res.json(data);
85  } catch (err) {
86    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
87  }
88});
89
90app.listen(3000, '0.0.0.0', () => {
91  console.log('Ubersuggest integration server running on port 3000');
92});

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