How to Integrate Replit with SEMrush

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const SEMRUSH_API_KEY = process.env.SEMRUSH_API_KEY;
8const SEMRUSH_BASE_URL = 'https://api.semrush.com/';
9
10// Get organic keywords for a domain
11app.get('/api/domain-keywords', async (req, res) => {
12  const { domain, database = 'us', limit = 10 } = req.query;
13
14  if (!domain) {
15    return res.status(400).json({ error: 'domain parameter is required' });
16  }
17
18  try {
19    const params = new URLSearchParams({
20      type: 'domain_organic',
21      key: SEMRUSH_API_KEY,
22      domain,
23      database,
24      display_limit: limit,
25      export_columns: 'Ph,Po,Nq,Cp,Co,Tr,Tc,Nr,Td'
26    });
27
28    const response = await axios.get(`${SEMRUSH_BASE_URL}?${params}`);
29    const lines = response.data.trim().split('\n');
30    const headers = lines[0].split(';');
31    const rows = lines.slice(1).map(line => {
32      const values = line.split(';');
33      return headers.reduce((obj, header, i) => {
34        obj[header] = values[i];
35        return obj;
36      }, {});
37    });
38
39    res.json({ domain, database, keywords: rows });
40  } catch (error) {
41    console.error('SEMrush API error:', error.message);
42    res.status(500).json({ error: 'Failed to fetch keyword data' });
43  }
44});
45
46// Get keyword overview data
47app.get('/api/keyword-overview', async (req, res) => {
48  const { phrase, database = 'us' } = req.query;
49
50  if (!phrase) {
51    return res.status(400).json({ error: 'phrase parameter is required' });
52  }
53
54  try {
55    const params = new URLSearchParams({
56      type: 'phrase_this',
57      key: SEMRUSH_API_KEY,
58      phrase,
59      database,
60      export_columns: 'Ph,Nq,Cp,Co,Nr,Td'
61    });
62
63    const response = await axios.get(`${SEMRUSH_BASE_URL}?${params}`);
64    const lines = response.data.trim().split('\n');
65    const headers = lines[0].split(';');
66    const data = headers.reduce((obj, header, i) => {
67      obj[header] = lines[1] ? lines[1].split(';')[i] : null;
68      return obj;
69    }, {});
70
71    res.json({ phrase, database, overview: data });
72  } catch (error) {
73    console.error('SEMrush API error:', error.message);
74    res.status(500).json({ error: 'Failed to fetch keyword overview' });
75  }
76});
77
78app.listen(3000, '0.0.0.0', () => {
79  console.log('SEMrush proxy server running on port 3000');
80});

1import os
2import requests
3from flask import Flask, request, jsonify
4
5app = Flask(__name__)
6
7SEMRUSH_API_KEY = os.environ['SEMRUSH_API_KEY']
8SEMRUSH_BASE_URL = 'https://api.semrush.com/'
9
10def parse_semrush_response(text):
11    """Parse SEMrush semicolon-delimited response into list of dicts."""
12    lines = text.strip().split('\n')
13    if len(lines) < 2:
14        return []
15    headers = lines[0].split(';')
16    results = []
17    for line in lines[1:]:
18        values = line.split(';')
19        results.append(dict(zip(headers, values)))
20    return results
21
22@app.route('/api/domain-keywords')
23def domain_keywords():
24    domain = request.args.get('domain')
25    database = request.args.get('database', 'us')
26    limit = request.args.get('limit', 10)
27
28    if not domain:
29        return jsonify({'error': 'domain parameter is required'}), 400
30
31    params = {
32        'type': 'domain_organic',
33        'key': SEMRUSH_API_KEY,
34        'domain': domain,
35        'database': database,
36        'display_limit': limit,
37        'export_columns': 'Ph,Po,Nq,Cp,Co,Tr,Tc,Nr,Td'
38    }
39
40    try:
41        response = requests.get(SEMRUSH_BASE_URL, params=params, timeout=15)
42        response.raise_for_status()
43        keywords = parse_semrush_response(response.text)
44        return jsonify({'domain': domain, 'database': database, 'keywords': keywords})
45    except requests.RequestException as e:
46        return jsonify({'error': f'SEMrush API error: {str(e)}'}), 500
47
48@app.route('/api/keyword-overview')
49def keyword_overview():
50    phrase = request.args.get('phrase')
51    database = request.args.get('database', 'us')
52
53    if not phrase:
54        return jsonify({'error': 'phrase parameter is required'}), 400
55
56    params = {
57        'type': 'phrase_this',
58        'key': SEMRUSH_API_KEY,
59        'phrase': phrase,
60        'database': database,
61        'export_columns': 'Ph,Nq,Cp,Co,Nr,Td'
62    }
63
64    try:
65        response = requests.get(SEMRUSH_BASE_URL, params=params, timeout=15)
66        response.raise_for_status()
67        data = parse_semrush_response(response.text)
68        return jsonify({'phrase': phrase, 'database': database, 'overview': data[0] if data else {}})
69    except requests.RequestException as e:
70        return jsonify({'error': f'SEMrush API error: {str(e)}'}), 500
71
72if __name__ == '__main__':
73    app.run(host='0.0.0.0', port=3000)

1# .replit configuration for Node.js deployment
2# Add this to your .replit file
3
4# For Node.js:
5# [deployment]
6# run = ["node", "server.js"]
7# deploymentTarget = "cloudrun"
8#
9# [[ports]]
10# internalPort = 3000
11# externalPort = 80
12
13# For Python:
14# [deployment]
15# run = ["python", "app.py"]
16# deploymentTarget = "cloudrun"
17#
18# [[ports]]
19# internalPort = 3000
20# externalPort = 80
21
22# Add CORS to Node.js server (install: npm install cors)
23const cors = require('cors');
24app.use(cors({
25  origin: process.env.ALLOWED_ORIGIN || '*'
26}));
27
28# Simple in-memory cache for SEMrush responses
29const cache = new Map();
30const CACHE_TTL = 3600000; // 1 hour in milliseconds
31
32function getCached(key) {
33  const entry = cache.get(key);
34  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
35    return entry.data;
36  }
37  return null;
38}
39
40function setCached(key, data) {
41  cache.set(key, { data, timestamp: Date.now() });
42}