How to Integrate Bolt.new with Serpstat

1# .env — Serpstat API credentials
2# Found in serpstat.com → Profile → API
3SERPSTAT_API_TOKEN=your-serpstat-api-token
4
5# Serpstat v4 API base URL
6SERPSTAT_API_BASE=https://api.serpstat.com/v4
7
8# Default search engine database (se = search engine)
9# Use 'g_us' for Google US, 'g_uk' for Google UK, etc.
10SERPSTAT_DEFAULT_SE=g_us
11
12# For Next.js server-side: process.env.SERPSTAT_API_TOKEN
13# NEVER use NEXT_PUBLIC_ prefix — this is a server-side credential only

1// app/api/serpstat/keyword-data/route.ts
2import { NextResponse } from 'next/server';
3
4const SERPSTAT_API_BASE = process.env.SERPSTAT_API_BASE ?? 'https://api.serpstat.com/v4';
5
6export async function POST(request: Request) {
7  const token = process.env.SERPSTAT_API_TOKEN;
8  if (!token) {
9    return NextResponse.json({ error: 'SERPSTAT_API_TOKEN not configured' }, { status: 500 });
10  }
11
12  const { keyword, se = process.env.SERPSTAT_DEFAULT_SE ?? 'g_us' } = await request.json();
13
14  if (!keyword) {
15    return NextResponse.json({ error: 'keyword is required' }, { status: 400 });
16  }
17
18  const serpstatResponse = await fetch(`${SERPSTAT_API_BASE}/?token=${token}`, {
19    method: 'POST',
20    headers: { 'Content-Type': 'application/json' },
21    body: JSON.stringify({
22      id: '1',
23      method: 'SerpstatKeyword.getKeywordsInfo',
24      params: {
25        se,
26        keywords: [keyword],
27      },
28    }),
29  });
30
31  if (!serpstatResponse.ok) {
32    return NextResponse.json(
33      { error: `Serpstat API error: ${serpstatResponse.status}` },
34      { status: serpstatResponse.status }
35    );
36  }
37
38  const data = await serpstatResponse.json();
39
40  if (data.error) {
41    return NextResponse.json(
42      { error: data.error.message ?? 'Serpstat API error' },
43      { status: 400 }
44    );
45  }
46
47  const keywordData = data.result?.data?.[keyword];
48
49  if (!keywordData) {
50    return NextResponse.json({
51      keyword,
52      found: false,
53      message: 'No data found for this keyword in the selected search engine',
54    });
55  }
56
57  return NextResponse.json({
58    keyword,
59    found: true,
60    search_volume: keywordData.volume ?? 0,
61    keyword_difficulty: keywordData.difficulty ?? 0,
62    cpc: keywordData.cpc ?? 0,
63    competition: keywordData.competition ?? 0,
64    results_count: keywordData.results ?? 0,
65    left_credits: data.result?.summary?.left_lines ?? null,
66  });
67}

1// app/api/serpstat/domain-keywords/route.ts
2import { NextResponse } from 'next/server';
3import { createClient } from '@supabase/supabase-js';
4
5const SERPSTAT_API_BASE = process.env.SERPSTAT_API_BASE ?? 'https://api.serpstat.com/v4';
6
7function cleanDomain(input: string): string {
8  return input
9    .replace(/^https?:\/\//i, '')
10    .replace(/^www\./i, '')
11    .replace(/\/.*$/, '')
12    .trim();
13}
14
15export async function POST(request: Request) {
16  const token = process.env.SERPSTAT_API_TOKEN;
17  if (!token) {
18    return NextResponse.json({ error: 'SERPSTAT_API_TOKEN not configured' }, { status: 500 });
19  }
20
21  const { domain, se = 'g_us', limit = 20, minPosition = 10 } = await request.json();
22
23  if (!domain) {
24    return NextResponse.json({ error: 'domain is required' }, { status: 400 });
25  }
26
27  const cleanedDomain = cleanDomain(domain);
28  const cacheKey = `${cleanedDomain}:${se}`;
29
30  const supabase = createClient(
31    process.env.NEXT_PUBLIC_SUPABASE_URL!,
32    process.env.SUPABASE_SERVICE_ROLE_KEY!
33  );
34
35  // Check 6-hour cache
36  const sixHoursAgo = new Date(Date.now() - 6 * 60 * 60 * 1000).toISOString();
37  const { data: cached } = await supabase
38    .from('serpstat_domain_cache')
39    .select('keywords_data, cached_at')
40    .eq('cache_key', cacheKey)
41    .gt('cached_at', sixHoursAgo)
42    .single();
43
44  if (cached) {
45    const keywords = cached.keywords_data as Array<Record<string, unknown>>;
46    return NextResponse.json({
47      domain: cleanedDomain,
48      keywords: keywords.filter((k) => (k.position as number) <= minPosition).slice(0, limit),
49      cached: true,
50    });
51  }
52
53  const serpstatResponse = await fetch(`${SERPSTAT_API_BASE}/?token=${token}`, {
54    method: 'POST',
55    headers: { 'Content-Type': 'application/json' },
56    body: JSON.stringify({
57      id: '1',
58      method: 'SerpstatDomain.getKeywords',
59      params: {
60        se,
61        domain: cleanedDomain,
62        sort: { traffic: 'desc' },
63        page: 1,
64        size: 100, // fetch more, filter client-side
65      },
66    }),
67  });
68
69  const data = await serpstatResponse.json();
70
71  if (data.error) {
72    return NextResponse.json({ error: data.error.message }, { status: 400 });
73  }
74
75  const keywords = (data.result?.data ?? []).map((item: {
76    keyword: string;
77    position: number;
78    volume: number;
79    difficulty: number;
80    cpc: number;
81    traff: number;
82  }) => ({
83    keyword: item.keyword,
84    position: item.position,
85    search_volume: item.volume ?? 0,
86    keyword_difficulty: item.difficulty ?? 0,
87    cpc: item.cpc ?? 0,
88    traffic_estimate: item.traff ?? 0,
89  }));
90
91  // Cache results
92  await supabase
93    .from('serpstat_domain_cache')
94    .upsert({
95      cache_key: cacheKey,
96      domain: cleanedDomain,
97      se,
98      keywords_data: keywords,
99      cached_at: new Date().toISOString(),
100    }, { onConflict: 'cache_key' });
101
102  const filtered = keywords
103    .filter((k: { position: number }) => k.position <= minPosition)
104    .slice(0, limit);
105
106  return NextResponse.json({
107    domain: cleanedDomain,
108    keywords: filtered,
109    total_found: keywords.length,
110    cached: false,
111  });
112}

1// app/api/serpstat/serp/route.ts
2import { NextResponse } from 'next/server';
3
4const SERPSTAT_API_BASE = process.env.SERPSTAT_API_BASE ?? 'https://api.serpstat.com/v4';
5
6export async function POST(request: Request) {
7  const token = process.env.SERPSTAT_API_TOKEN;
8  if (!token) {
9    return NextResponse.json({ error: 'SERPSTAT_API_TOKEN not configured' }, { status: 500 });
10  }
11
12  const {
13    keyword,
14    se = 'g_us',
15    target_domain = '',
16  } = await request.json();
17
18  if (!keyword) {
19    return NextResponse.json({ error: 'keyword is required' }, { status: 400 });
20  }
21
22  const serpstatResponse = await fetch(`${SERPSTAT_API_BASE}/?token=${token}`, {
23    method: 'POST',
24    headers: { 'Content-Type': 'application/json' },
25    body: JSON.stringify({
26      id: '1',
27      method: 'SerpstatKeyword.getSerpResults',
28      params: { se, keyword },
29    }),
30  });
31
32  const data = await serpstatResponse.json();
33
34  if (data.error) {
35    return NextResponse.json({ error: data.error.message }, { status: 400 });
36  }
37
38  const cleanedTarget = target_domain
39    .replace(/^https?:\/\//i, '')
40    .replace(/^www\./i, '')
41    .replace(/\/.*$/, '')
42    .toLowerCase();
43
44  const results = (data.result?.data ?? []).map((item: {
45    position: number;
46    url: string;
47    title: string;
48    domain: string;
49    domain_rank: number;
50    traff: number;
51  }) => ({
52    position: item.position,
53    url: item.url,
54    title: item.title ?? '',
55    domain: item.domain,
56    domain_authority: item.domain_rank ?? 0,
57    traffic_estimate: item.traff ?? 0,
58    is_target: cleanedTarget
59      ? item.domain.toLowerCase().includes(cleanedTarget)
60      : false,
61  }));
62
63  const targetPosition = results.find((r: { is_target: boolean }) => r.is_target)?.position ?? null;
64
65  return NextResponse.json({
66    keyword,
67    se,
68    results,
69    target_position: targetPosition,
70    target_found: targetPosition !== null,
71  });
72}