How to Integrate Bolt.new with Moz

1# .env — Moz API credentials
2# Found at moz.com/products/mozscape/access after logging in
3MOZ_ACCESS_ID=mozscape-your-access-id
4MOZ_SECRET_KEY=your-secret-key
5
6# Moz API v2 base URL
7MOZ_API_BASE=https://lsapi.seomoz.com/v2
8
9# For Next.js server-side: process.env.MOZ_ACCESS_ID
10# Never use NEXT_PUBLIC_ prefix — these are server-side only credentials

1// app/api/moz/url-metrics/route.ts
2import { NextResponse } from 'next/server';
3import { createClient } from '@supabase/supabase-js';
4
5const MOZ_AUTH = Buffer.from(
6  `${process.env.MOZ_ACCESS_ID}:${process.env.MOZ_SECRET_KEY}`
7).toString('base64');
8
9function normalizeUrl(url: string): string {
10  const trimmed = url.trim();
11  if (!trimmed.startsWith('http')) return `https://${trimmed}`;
12  return trimmed.replace(/\/$/, '');
13}
14
15export async function POST(request: Request) {
16  const body = await request.json();
17  const inputUrls: string[] = Array.isArray(body.urls)
18    ? body.urls
19    : body.url
20    ? [body.url]
21    : [];
22
23  if (inputUrls.length === 0) {
24    return NextResponse.json({ error: 'url or urls is required' }, { status: 400 });
25  }
26
27  const targets = inputUrls.map(normalizeUrl);
28
29  const supabase = createClient(
30    process.env.NEXT_PUBLIC_SUPABASE_URL!,
31    process.env.SUPABASE_SERVICE_ROLE_KEY!
32  );
33
34  // Check cache for all targets
35  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
36  const { data: cached } = await supabase
37    .from('moz_metrics_cache')
38    .select('*')
39    .in('url', targets)
40    .gt('cached_at', yesterday);
41
42  const cachedUrls = new Set(cached?.map((c) => c.url) ?? []);
43  const uncachedTargets = targets.filter((t) => !cachedUrls.has(t));
44
45  let freshResults: Array<Record<string, number | string>> = [];
46
47  if (uncachedTargets.length > 0) {
48    const mozResponse = await fetch(`${process.env.MOZ_API_BASE}/url_metrics`, {
49      method: 'POST',
50      headers: {
51        'Authorization': `Basic ${MOZ_AUTH}`,
52        'Content-Type': 'application/json',
53      },
54      body: JSON.stringify({ targets: uncachedTargets }),
55    });
56
57    if (!mozResponse.ok) {
58      const errorText = await mozResponse.text();
59      return NextResponse.json(
60        { error: `Moz API error: ${errorText}` },
61        { status: mozResponse.status }
62      );
63    }
64
65    const mozData = await mozResponse.json();
66    freshResults = mozData.results ?? [];
67
68    // Cache fresh results
69    const toCache = freshResults.map((result, i) => ({
70      url: uncachedTargets[i],
71      domain_authority: result.domain_authority,
72      page_authority: result.page_authority,
73      spam_score: result.spam_score,
74      linking_root_domains: result.root_domains_to_root_domain,
75      total_links: result.links_to_root_domain,
76      cached_at: new Date().toISOString(),
77    }));
78
79    await supabase
80      .from('moz_metrics_cache')
81      .upsert(toCache, { onConflict: 'url' });
82  }
83
84  // Merge cached + fresh, preserving input order
85  const allResults = targets.map((url) => {
86    const fromCache = cached?.find((c) => c.url === url);
87    if (fromCache) return fromCache;
88    const freshIdx = uncachedTargets.indexOf(url);
89    return freshResults[freshIdx] ? { url, ...freshResults[freshIdx] } : { url, error: 'not found' };
90  });
91
92  return NextResponse.json({ results: allResults });
93}

1// components/MozMetricsCards.tsx
2'use client';
3
4interface MozMetrics {
5  url: string;
6  domain_authority: number;
7  page_authority: number;
8  spam_score: number;
9  linking_root_domains: number;
10  total_links: number;
11}
12
13function getDAColor(da: number): string {
14  if (da >= 50) return 'bg-green-100 text-green-800 border-green-200';
15  if (da >= 30) return 'bg-yellow-100 text-yellow-800 border-yellow-200';
16  return 'bg-red-100 text-red-800 border-red-200';
17}
18
19function getSpamColor(spam: number): string {
20  if (spam <= 3) return 'text-green-600';
21  if (spam <= 7) return 'text-yellow-600';
22  return 'text-red-600';
23}
24
25export function MozMetricsCards({ metrics }: { metrics: MozMetrics }) {
26  const daColor = getDAColor(metrics.domain_authority);
27
28  return (
29    <div className="space-y-4">
30      <p className="text-sm text-gray-500 break-all">{metrics.url}</p>
31      <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
32        <div className={`p-4 rounded-xl border-2 ${daColor}`}>
33          <p className="text-xs font-medium uppercase tracking-wide opacity-70">Domain Authority</p>
34          <p className="text-4xl font-bold mt-1">{metrics.domain_authority}</p>
35          <p className="text-xs mt-1">out of 100</p>
36        </div>
37        <div className="p-4 rounded-xl border-2 bg-blue-50 text-blue-800 border-blue-200">
38          <p className="text-xs font-medium uppercase tracking-wide opacity-70">Page Authority</p>
39          <p className="text-4xl font-bold mt-1">{metrics.page_authority}</p>
40          <p className="text-xs mt-1">out of 100</p>
41        </div>
42        <div className="p-4 rounded-xl border-2 bg-gray-50 border-gray-200">
43          <p className="text-xs font-medium uppercase tracking-wide text-gray-500">Spam Score</p>
44          <p className={`text-4xl font-bold mt-1 ${getSpamColor(metrics.spam_score)}`}>
45            {metrics.spam_score}
46          </p>
47          <p className="text-xs mt-1 text-gray-500">out of 17</p>
48        </div>
49        <div className="p-4 rounded-xl border-2 bg-purple-50 text-purple-800 border-purple-200">
50          <p className="text-xs font-medium uppercase tracking-wide opacity-70">Linking Domains</p>
51          <p className="text-3xl font-bold mt-1">
52            {metrics.linking_root_domains.toLocaleString()}
53          </p>
54          <p className="text-xs mt-1">root domains</p>
55        </div>
56      </div>
57    </div>
58  );
59}

1// app/api/moz/links/route.ts
2import { NextResponse } from 'next/server';
3
4const MOZ_AUTH = Buffer.from(
5  `${process.env.MOZ_ACCESS_ID}:${process.env.MOZ_SECRET_KEY}`
6).toString('base64');
7
8export async function POST(request: Request) {
9  const { url, limit = 25, minDA = 0 } = await request.json();
10
11  if (!url) {
12    return NextResponse.json({ error: 'url is required' }, { status: 400 });
13  }
14
15  const target = url.startsWith('http') ? url : `https://${url}`;
16
17  const mozResponse = await fetch(`${process.env.MOZ_API_BASE}/links`, {
18    method: 'POST',
19    headers: {
20      'Authorization': `Basic ${MOZ_AUTH}`,
21      'Content-Type': 'application/json',
22    },
23    body: JSON.stringify({
24      target,
25      target_scope: 'root_domain',
26      source_scope: 'page',
27      limit,
28      sort: 'page_authority',
29    }),
30  });
31
32  if (!mozResponse.ok) {
33    const errorText = await mozResponse.text();
34    return NextResponse.json(
35      { error: `Moz API error: ${errorText}` },
36      { status: mozResponse.status }
37    );
38  }
39
40  const data = await mozResponse.json();
41  const links = (data.results ?? []).filter(
42    (link: { source_domain_authority: number }) => link.source_domain_authority >= minDA
43  );
44
45  return NextResponse.json({
46    target,
47    total_links: data.total_links,
48    results: links.map((link: {
49      source_url: string;
50      target_url: string;
51      anchor_text: string;
52      source_domain_authority: number;
53      source_page_authority: number;
54      flags: number;
55    }) => ({
56      source_url: link.source_url,
57      target_url: link.target_url,
58      anchor_text: link.anchor_text ?? '',
59      source_domain_authority: link.source_domain_authority,
60      source_page_authority: link.source_page_authority,
61      is_nofollow: Boolean(link.flags & 32),
62    })),
63  });
64}