How to Integrate Replit with Serpstat

1// test-serpstat.js — Verify Serpstat API token
2const axios = require('axios');
3
4const SERPSTAT_TOKEN = process.env.SERPSTAT_API_TOKEN;
5const API_BASE = 'https://api.serpstat.com/v4';
6
7async function testConnection() {
8  // Get user info to verify token
9  const resp = await axios.get(`${API_BASE}/`, {
10    params: {
11      token: SERPSTAT_TOKEN,
12      method: 'SerpstatApiV2.getStats'
13    }
14  });
15  const data = resp.data;
16  if (data.error) {
17    throw new Error(`Serpstat API error: ${data.error.message}`);
18  }
19  console.log('Serpstat connection OK');
20  console.log('API credits remaining:', data.result?.credits_left ?? 'N/A');
21}
22
23testConnection().catch(err => {
24  console.error('Connection test failed:', err.message);
25  if (!process.env.SERPSTAT_API_TOKEN) {
26    console.error('SERPSTAT_API_TOKEN not found. Add it to Replit Secrets (lock icon 🔒).');
27  }
28});

1# serpstat_domain.py — Query domain keywords from Serpstat (Python)
2import os
3import requests
4from flask import Flask, request, jsonify
5
6API_BASE = 'https://api.serpstat.com/v4'
7SERPSTAT_TOKEN = os.environ['SERPSTAT_API_TOKEN']
8
9def get_domain_keywords(domain, search_engine='g_us', page=1, size=100):
10    """Retrieve organic keywords a domain ranks for."""
11    resp = requests.get(API_BASE, params={
12        'token': SERPSTAT_TOKEN,
13        'method': 'SerpstatApiV2.getDomainKeywords',
14        'query': domain,
15        'se': search_engine,
16        'page': page,
17        'size': size
18    })
19    resp.raise_for_status()
20    data = resp.json()
21    if 'error' in data:
22        raise ValueError(f"Serpstat error: {data['error']['message']}")
23    return data.get('result', {})
24
25def get_domain_overview(domain, search_engine='g_us'):
26    """Get top-level domain metrics: visibility, traffic, keyword count."""
27    resp = requests.get(API_BASE, params={
28        'token': SERPSTAT_TOKEN,
29        'method': 'SerpstatApiV2.getDomainInfo',
30        'query': domain,
31        'se': search_engine
32    })
33    resp.raise_for_status()
34    data = resp.json()
35    if 'error' in data:
36        raise ValueError(f"Serpstat error: {data['error']['message']}")
37    return data.get('result', {})
38
39app = Flask(__name__)
40
41@app.route('/api/domain/overview')
42def domain_overview():
43    domain = request.args.get('domain')
44    if not domain:
45        return jsonify({'error': 'domain parameter required'}), 400
46    try:
47        data = get_domain_overview(domain)
48        return jsonify({
49            'domain': domain,
50            'keywords': data.get('keywords', 0),
51            'traffic': data.get('traff', 0),
52            'visibility': data.get('visible', 0)
53        })
54    except Exception as e:
55        return jsonify({'error': str(e)}), 500
56
57@app.route('/api/domain/keywords')
58def domain_keywords():
59    domain = request.args.get('domain')
60    if not domain:
61        return jsonify({'error': 'domain parameter required'}), 400
62    try:
63        result = get_domain_keywords(domain, size=50)
64        keywords = result.get('data', [])
65        return jsonify({'domain': domain, 'count': len(keywords), 'keywords': keywords})
66    except Exception as e:
67        return jsonify({'error': str(e)}), 500
68
69if __name__ == '__main__':
70    app.run(host='0.0.0.0', port=3000)

1// keyword-research.js — Keyword research via Serpstat API (Node.js)
2const axios = require('axios');
3
4const API_BASE = 'https://api.serpstat.com/v4';
5const TOKEN = process.env.SERPSTAT_API_TOKEN;
6
7async function getKeywordInfo(keyword, searchEngine = 'g_us') {
8  const resp = await axios.get(API_BASE, {
9    params: {
10      token: TOKEN,
11      method: 'SerpstatApiV2.getKeywordInfo',
12      query: keyword,
13      se: searchEngine
14    }
15  });
16  const data = resp.data;
17  if (data.error) throw new Error(data.error.message);
18  return data.result;
19}
20
21async function getKeywordSuggestions(keyword, searchEngine = 'g_us', size = 50) {
22  const resp = await axios.get(API_BASE, {
23    params: {
24      token: TOKEN,
25      method: 'SerpstatApiV2.getKeywordSuggestions',
26      query: keyword,
27      se: searchEngine,
28      size
29    }
30  });
31  const data = resp.data;
32  if (data.error) throw new Error(data.error.message);
33  return data.result?.data || [];
34}
35
36async function findOpportunities(seedKeyword) {
37  console.log(`\nAnalyzing seed keyword: "${seedKeyword}"`);
38
39  const info = await getKeywordInfo(seedKeyword);
40  console.log(`Volume: ${info.volume}, Difficulty: ${info.difficulty}, CPC: $${info.cost}`);
41
42  const suggestions = await getKeywordSuggestions(seedKeyword, 'g_us', 100);
43  const opportunities = suggestions
44    .filter(k => k.difficulty < 40 && k.volume > 100)
45    .sort((a, b) => b.volume - a.volume)
46    .slice(0, 10);
47
48  console.log(`\nTop 10 low-difficulty opportunities (difficulty < 40, volume > 100):`);
49  opportunities.forEach(k => {
50    console.log(`  "${k.keyword}" — vol: ${k.volume}, difficulty: ${k.difficulty}`);
51  });
52
53  return opportunities;
54}
55
56findOpportunities('replit tutorial').catch(console.error);

1// cached-seo-api.js — Serpstat with in-memory caching (Node.js Express)
2const axios = require('axios');
3const express = require('express');
4
5const API_BASE = 'https://api.serpstat.com/v4';
6const TOKEN = process.env.SERPSTAT_API_TOKEN;
7
8// Simple in-memory cache with TTL
9const cache = new Map();
10const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
11
12function getCached(key) {
13  const entry = cache.get(key);
14  if (!entry) return null;
15  if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
16    cache.delete(key);
17    return null;
18  }
19  return entry.data;
20}
21
22function setCached(key, data) {
23  cache.set(key, { data, timestamp: Date.now() });
24}
25
26async function serpstatRequest(method, params) {
27  const cacheKey = `${method}:${JSON.stringify(params)}`;
28  const cached = getCached(cacheKey);
29  if (cached) {
30    console.log(`Cache HIT: ${cacheKey}`);
31    return cached;
32  }
33
34  console.log(`Cache MISS: calling Serpstat for ${method}`);
35  const resp = await axios.get(API_BASE, {
36    params: { token: TOKEN, method, ...params }
37  });
38  const data = resp.data;
39  if (data.error) throw new Error(data.error.message);
40  setCached(cacheKey, data.result);
41  return data.result;
42}
43
44const app = express();
45
46app.get('/api/seo/domain', async (req, res) => {
47  const { domain, se = 'g_us' } = req.query;
48  if (!domain) return res.status(400).json({ error: 'domain required' });
49  try {
50    const result = await serpstatRequest('SerpstatApiV2.getDomainInfo', { query: domain, se });
51    res.set('Cache-Control', 'public, max-age=3600');
52    res.json({ domain, data: result });
53  } catch (err) {
54    res.status(500).json({ error: err.message });
55  }
56});
57
58app.get('/api/seo/keywords', async (req, res) => {
59  const { keyword, se = 'g_us' } = req.query;
60  if (!keyword) return res.status(400).json({ error: 'keyword required' });
61  try {
62    const result = await serpstatRequest('SerpstatApiV2.getKeywordInfo', { query: keyword, se });
63    res.json({ keyword, data: result });
64  } catch (err) {
65    res.status(500).json({ error: err.message });
66  }
67});
68
69app.listen(3000, '0.0.0.0', () => console.log('SEO API with caching running on port 3000'));