AI ਕ੍ਰੌਲਰਾਂ ਨੂੰ ਤੁਹਾਡੀ ਸਾਈਟ ਤੋਂ ਅਸਲ ਵਿੱਚ ਕੀ ਮਿਲਦਾ ਹੈ? 66 ਲਾਈਨ ਦੀ ਸਕ੍ਰਿਪਟ

ਪ੍ਰਕਾਸ਼ਿਤ

ਛੋਟਾ ਜਵਾਬ

ਆਪਣੇ ਪੰਨੇ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਜੋਂ ਅਤੇ ਹਰ AI ਕ੍ਰੌਲਰ ਵਜੋਂ ਮੰਗੋ, ਫਿਰ ਤੁਲਨਾ ਕਰੋ। ਜੇ ਸਿਰਫ਼ ਕ੍ਰੌਲਰ ਨੂੰ 403, 429 ਜਾਂ ਚੈਲੰਜ ਪੰਨਾ ਮਿਲੇ, ਜਾਂ 200 ਜਵਾਬ ਬ੍ਰਾਊਜ਼ਰ ਵਾਲੇ ਪੰਨੇ ਨਾਲੋਂ ਬਹੁਤ ਛੋਟਾ ਹੋਵੇ, ਤਾਂ ਫਾਇਰਵਾਲ ਉਸਨੂੰ ਰੋਕ ਰਿਹਾ ਹੈ, ਭਾਵੇਂ robots.txt ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੋਵੇ। 66 ਲਾਈਨ ਦੀ Node ਸਕ੍ਰਿਪਟ ਸੱਤ ਕ੍ਰੌਲਰਾਂ ਲਈ ਇਹ ਜਾਂਚ ਕਰਦੀ ਹੈ ਅਤੇ robots.txt ਨੂੰ RFC 9309 ਦੇ ਨਿਯਮਾਂ ਅਨੁਸਾਰ ਪੜ੍ਹਦੀ ਹੈ।

robots.txt ਕ੍ਰੌਲਰ ਨੂੰ ਦੱਸਦੀ ਹੈ ਕਿ ਉਹ ਕੀ ਲੈ ਸਕਦਾ ਹੈ। ਇਹ ਨਹੀਂ ਦੱਸਦੀ ਕਿ ਤੁਹਾਡਾ ਫਾਇਰਵਾਲ ਜਾਂ CDN ਅਸਲ ਵਿੱਚ ਕੀ ਵਾਪਸ ਭੇਜਦਾ ਹੈ। ਇਸ ਪੋਸਟ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਦੋਵੇਂ ਗੱਲਾਂ ਨਾਲ-ਨਾਲ ਦਿਖਾਉਂਦੀ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਦੇਖ ਸਕੋ ਕਿ ਦੋਵੇਂ ਕਿੱਥੇ ਵੱਖਰੀਆਂ ਹਨ।

ਇਸ ਪੰਨੇ 'ਤੇ
  1. robots.txt ਇਹ ਕਿਉਂ ਨਹੀਂ ਦੱਸਦੀ ਕਿ ਕ੍ਰੌਲਰ ਨੂੰ ਕੀ ਮਿਲਦਾ ਹੈ?
  2. ਸਕ੍ਰਿਪਟ
  3. ਇਸਨੂੰ ਕਿਵੇਂ ਚਲਾਵਾਂ?
  4. ਆਉਟਪੁੱਟ ਕਿਹੋ ਜਿਹੀ ਦਿਸਦੀ ਹੈ?
  5. ਮੈਂ ਟੇਬਲ ਕਿਵੇਂ ਪੜ੍ਹਾਂ?
  6. ਸਕ੍ਰਿਪਟ ਕੀ ਨਹੀਂ ਦੱਸ ਸਕਦੀ?
  7. ਅਸਲ ਵੈੱਬਸਾਈਟਾਂ ਉੱਤੇ ਅਸੀਂ ਕੀ ਦੇਖਦੇ ਹਾਂ?

robots.txt ਇਹ ਕਿਉਂ ਨਹੀਂ ਦੱਸਦੀ ਕਿ ਕ੍ਰੌਲਰ ਨੂੰ ਕੀ ਮਿਲਦਾ ਹੈ?

robots.txt ਇੱਕ ਬੇਨਤੀ ਹੈ। ਅਸਲ ਵਿੱਚ ਕੀ ਵਾਪਸ ਭੇਜਿਆ ਜਾਵੇ, ਇਹ ਫਾਇਰਵਾਲ, CDN ਜਾਂ ਬੋਟ-ਸੁਰੱਖਿਆ ਨਿਯਮ ਤੈਅ ਕਰਦੇ ਹਨ। ਉਹ OAI-SearchBot ਜਾਂ PerplexityBot ਨੂੰ 403, 429 ਜਾਂ "Just a moment..." ਪੰਨਾ ਦੇ ਸਕਦੇ ਹਨ, ਜਦਕਿ ਤੁਹਾਡੇ ਆਪਣੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਸਭ ਕੁਝ ਠੀਕ ਲੱਗਦਾ ਹੈ।

ਜਾਂਚ ਇਹ ਹੈ ਕਿ ਇੱਕੋ URL ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਜੋਂ ਅਤੇ ਕ੍ਰੌਲਰ ਵਜੋਂ ਮੰਗੋ ਅਤੇ ਤੁਲਨਾ ਕਰੋ। ਜੇ ਸਿਰਫ਼ ਕ੍ਰੌਲਰ ਨੂੰ 403, 429 ਜਾਂ 503 ਮਿਲੇ, ਪੰਨੇ ਦਾ ਸਿਰਲੇਖ Just a moment... ਹੋਵੇ, ਜਾਂ 200 ਜਵਾਬ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਜਵਾਬ ਨਾਲੋਂ ਬਹੁਤ ਛੋਟਾ ਹੋਵੇ, ਤਾਂ ਇਹ ਸਭ ਫਾਇਰਵਾਲ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ।

ਸਕ੍ਰਿਪਟ

ਇਸਨੂੰ ai-crawler-view.mjs ਨਾਮ ਨਾਲ ਸੰਭਾਲੋ। ਇਸ ਲਈ Node 18 ਜਾਂ ਨਵਾਂ ਵਰਜ਼ਨ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਕੋਈ ਪੈਕੇਜ ਨਹੀਂ ਚਾਹੀਦਾ। ਇਹ robots.txt ਇੱਕ ਵਾਰ ਪੜ੍ਹਦੀ ਹੈ, ਫਿਰ ਤੁਹਾਡਾ ਪੰਨਾ ਬ੍ਰਾਊਜ਼ਰ ਵਜੋਂ ਅਤੇ ਸੱਤ AI ਕ੍ਰੌਲਰਾਂ ਵਜੋਂ ਮੰਗਦੀ ਹੈ: OAI-SearchBot, ChatGPT-User, GPTBot, Claude-SearchBot, ClaudeBot, PerplexityBot ਅਤੇ Perplexity-User।

#!/usr/bin/env node
// ai-crawler-view: what do AI crawlers get from YOUR site, compared with a browser?
// Usage: node ai-crawler-view.mjs https://your-site.com/page [--expect "a sentence from your page"]
// Node 18+, no dependencies. Run it against sites you own: it sends requests with crawler user agents.
const BROWSER = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
const BOTS = [ // [robots.txt token, user agent]; Anthropic prints no full strings, so Claude gets a token-based one
  ["OAI-SearchBot", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OAI-SearchBot/1.0; +https://openai.com/searchbot"],
  ["ChatGPT-User", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot"],
  ["GPTBot", "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.1; +https://openai.com/gptbot"],
  ["Claude-SearchBot", "Mozilla/5.0 (compatible; Claude-SearchBot/1.0)"],
  ["ClaudeBot", "Mozilla/5.0 (compatible; ClaudeBot/1.0)"],
  ["PerplexityBot", "Mozilla/5.0 (compatible; PerplexityBot/1.0; +https://perplexity.ai/perplexitybot)"],
  ["Perplexity-User", "Mozilla/5.0 (compatible; Perplexity-User/1.0; +https://perplexity.ai/perplexity-user)"],
];
const BLOCK = new Set([401, 403, 406, 429, 451, 503, 999]);
const CHALLENGE = /Just a moment\.\.\.|Attention Required! \| Cloudflare|\/cdn-cgi\/challenge-platform|_Incapsula_Resource|Access Denied/i;

const [url, ...rest] = process.argv.slice(2);
const expect = rest.includes("--expect") ? rest[rest.indexOf("--expect") + 1] : "";
if (!url) { console.error("usage: node ai-crawler-view.mjs https://site/page [--expect \"text\"]"); process.exit(2); }

async function get(u, ua) {
  try {
    const r = await fetch(u, { headers: { "user-agent": ua }, redirect: "follow", signal: AbortSignal.timeout(15000) });
    return { status: r.status, body: (await r.text()).slice(0, 500000) };
  } catch (e) { return { status: 0, body: "", error: e.cause?.code || e.name }; }
}

// robots.txt, RFC 9309 in short: the group naming the token wins, else "*"; longest match wins; Allow wins a tie.
function robotsVerdict(txt, token, path) {
  const groups = []; let cur = null;
  for (const raw of txt.split(/\r?\n/)) {
    const m = raw.replace(/#.*/, "").match(/^\s*([A-Za-z-]+)\s*:\s*(.*?)\s*$/); if (!m) continue;
    const [k, v] = [m[1].toLowerCase(), m[2]];
    if (k === "user-agent") { if (!cur || cur.rules.length) groups.push(cur = { agents: [], rules: [] }); cur.agents.push(v.toLowerCase()); }
    else if (cur && (k === "allow" || k === "disallow") && v) cur.rules.push([k, v]);
  }
  const g = groups.find(x => x.agents.includes(token.toLowerCase())) || groups.find(x => x.agents.includes("*"));
  if (!g) return "no rule";
  let best = null;
  for (const [k, p] of g.rules) {
    const re = new RegExp("^" + p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\\\$$/, "$"));
    if (re.test(path) && (!best || p.length > best[1].length || (p.length === best[1].length && k === "allow"))) best = [k, p];
  }
  return best ? `${best[0]}: ${best[1]}` : "no rule";
}

const target = new URL(url);
const robots = await get(new URL("/robots.txt", target).href, BROWSER);
const robotsOk = robots.status >= 200 && robots.status < 300 && !/<html/i.test(robots.body);
const control = await get(url, BROWSER);
const cLen = control.body.length;
console.log(`control (browser): HTTP ${control.status}, ${cLen} bytes${expect ? `, expected text ${control.body.includes(expect) ? "found" : "MISSING"}` : ""}`);
if (control.status === 0 || BLOCK.has(control.status)) console.log("  the browser request itself failed or was refused: results below are not meaningful");
console.log(`robots.txt: ${robots.status >= 500 ? "server error (RFC 9309: crawlers must assume everything is disallowed)" : robotsOk ? "read" : "none or not valid"}\n`);
console.log("crawler           robots.txt          HTTP  bytes   verdict");
for (const [token, ua] of BOTS) {
  const r = await get(url, ua);
  const rule = robotsOk ? robotsVerdict(robots.body, token, target.pathname + target.search) : "no rule";
  const challenge = CHALLENGE.test(r.body.slice(0, 20000)) && r.body.length < 20000;
  const verdict = BLOCK.has(r.status) || challenge ? "BLOCKED by the server"
    : r.status >= 400 || r.status === 0 ? `error ${r.status || r.error}`
    : r.body.length < cLen * 0.5 ? "THIN: much smaller than the browser's page"
    : expect && !r.body.includes(expect) ? "text MISSING from the HTML" : "ok";
  console.log(`${token.padEnd(17)} ${rule.padEnd(19)} ${String(r.status).padEnd(5)} ${String(r.body.length).padEnd(7)} ${verdict}${rule.startsWith("disallow") ? "  (robots.txt asks it to stay away)" : ""}`);
}

Anthropic ਪੂਰੀਆਂ user agent ਸਤਰਾਂ ਨਹੀਂ ਛਾਪਦੀ, ਇਸ ਲਈ ਦੋਵੇਂ Claude ਲਾਈਨਾਂ ਸਿਰਫ਼ ਕ੍ਰੌਲਰ ਟੋਕਨ ਵਰਤਦੀਆਂ ਹਨ। ਟੋਕਨ ਨਾਲ ਮੇਲ ਕਰਨ ਵਾਲਾ ਫਾਇਰਵਾਲ ਉਸੇ ਤਰ੍ਹਾਂ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦਾ ਹੈ।

ਇਸਨੂੰ ਕਿਵੇਂ ਚਲਾਵਾਂ?

ਇਸਨੂੰ ਆਪਣੀ ਸਾਈਟ ਦੇ ਕਿਸੇ ਪੰਨੇ ਉੱਤੇ ਚਲਾਓ। ਵਿਕਲਪਿਕ --expect ਫਲੈਗ ਜਾਂਚਦਾ ਹੈ ਕਿ ਤੁਹਾਡੀ ਮੁੱਖ ਸਮੱਗਰੀ ਦਾ ਇੱਕ ਵਾਕ ਹਰ ਕ੍ਰੌਲਰ ਨੂੰ ਮਿਲਣ ਵਾਲੇ ਕੱਚੇ HTML ਵਿੱਚ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਇਹ ਗੈਰਹਾਜ਼ਰ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟਾਂ ਲੋਡ ਤੋਂ ਬਾਅਦ ਟੈਕਸਟ ਜੋੜਦੀਆਂ ਹਨ, ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਕ੍ਰੌਲਰ ਉਸਨੂੰ ਨਹੀਂ ਦੇਖਣਗੇ।

node ai-crawler-view.mjs https://your-site.com/pricing/ --expect "a sentence from your page"

ਇਸਨੂੰ ਸਿਰਫ਼ ਉਨ੍ਹਾਂ ਸਾਈਟਾਂ ਉੱਤੇ ਚਲਾਓ ਜੋ ਤੁਹਾਡੀਆਂ ਹਨ ਜਾਂ ਜਿੱਥੇ ਟੈਸਟ ਦੀ ਇਜਾਜ਼ਤ ਹੈ। ਇਹ ਨੌਂ ਬੇਨਤੀਆਂ ਭੇਜਦੀ ਹੈ: robots.txt, ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ਹਰ ਕ੍ਰੌਲਰ ਲਈ ਇੱਕ।

ਆਉਟਪੁੱਟ ਕਿਹੋ ਜਿਹੀ ਦਿਸਦੀ ਹੈ?

ਇਹ ਇੱਕ ਜਾਣ-ਬੁੱਝ ਕੇ ਵਿਰੋਧੀ ਬਣਾਏ ਲੋਕਲ ਟੈਸਟ ਸਰਵਰ ਦਾ ਨਤੀਜਾ ਹੈ, ਜੋ OAI-SearchBot ਨੂੰ ਚੈਲੰਜ ਕਰਦਾ ਹੈ, ClaudeBot ਦੀ ਦਰ ਸੀਮਤ ਕਰਦਾ ਹੈ, PerplexityBot ਨੂੰ ਖਾਲੀ ਢਾਂਚਾ ਦਿੰਦਾ ਹੈ ਅਤੇ robots.txt ਵਿੱਚ GPTBot ਨੂੰ ਮਨ੍ਹਾ ਕਰਦਾ ਹੈ:

control (browser): HTTP 200, 2618 bytes, expected text found
robots.txt: read

crawler           robots.txt          HTTP  bytes   verdict
OAI-SearchBot     allow: /            403   31      BLOCKED by the server
ChatGPT-User      allow: /            200   2618    ok
GPTBot            disallow: /         200   2618    ok  (robots.txt asks it to stay away)
Claude-SearchBot  allow: /            200   2618    ok
ClaudeBot         allow: /            429   9       BLOCKED by the server
PerplexityBot     allow: /            200   36      THIN: much smaller than the browser's page
Perplexity-User   allow: /            200   2618    ok

aiseewhy.com ਉੱਤੇ ਹਰ ਕ੍ਰੌਲਰ ਨੂੰ ਪੂਰਾ ਪੰਨਾ ਮਿਲਦਾ ਹੈ, ਬ੍ਰਾਊਜ਼ਰ ਵਾਲੇ ਸਮਾਨ status ਅਤੇ ਆਕਾਰ ਨਾਲ।

ਮੈਂ ਟੇਬਲ ਕਿਵੇਂ ਪੜ੍ਹਾਂ?

ਸਕ੍ਰਿਪਟ ਕੀ ਨਹੀਂ ਦੱਸ ਸਕਦੀ?

ਅਸਲ ਵੈੱਬਸਾਈਟਾਂ ਉੱਤੇ ਅਸੀਂ ਕੀ ਦੇਖਦੇ ਹਾਂ?

AISeeWhy 14 ਕ੍ਰੌਲਰਾਂ ਲਈ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਜਾਂਚ ਚਲਾਉਂਦਾ ਹੈ। ਅਮਰੀਕਾ, ਯੂਕੇ ਅਤੇ ਫਰਾਂਸ ਦੀਆਂ 165 ਕਾਰੋਬਾਰੀ ਵੈੱਬਸਾਈਟਾਂ ਵਿੱਚੋਂ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਸੀਂ ਟੈਸਟ ਕਰ ਸਕੇ, 38% (63 ਸਾਈਟਾਂ) ਨੇ ਸਰਵਰ ਉੱਤੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ AI ਕ੍ਰੌਲਰ ਨੂੰ ਮੋੜ ਦਿੱਤਾ, ਜਦਕਿ ਉਸੇ ਪਤੇ ਤੋਂ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਪੰਨਾ ਮਿਲ ਗਿਆ। ਇਨ੍ਹਾਂ ਸਾਰੀਆਂ ਸਾਈਟਾਂ ਨੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਟ੍ਰੇਨਿੰਗ ਜਾਂ ਸਕ੍ਰੇਪਰ ਬੋਟ ਨੂੰ ਰੋਕਿਆ, ਅਤੇ 10% (16 ਸਾਈਟਾਂ) ਨੇ ਘੱਟੋ-ਘੱਟ ਇੱਕ AI ਖੋਜ ਕ੍ਰੌਲਰ ਨੂੰ ਵੀ ਰੋਕਿਆ, ਜਿਵੇਂ PerplexityBot (11 ਸਾਈਟਾਂ) ਜਾਂ OAI-SearchBot (5)।

ਇਹ ਸਾਈਟਾਂ ਕੋਈ ਬੇਤਰਤੀਬ ਨਮੂਨਾ ਨਹੀਂ ਹਨ, ਅਤੇ 53 ਹੋਰ ਟੈਸਟ ਨਹੀਂ ਹੋ ਸਕੀਆਂ ਕਿਉਂਕਿ ਸਾਧਾਰਨ ਬ੍ਰਾਊਜ਼ਰ ਬੇਨਤੀ ਵੀ ਰੱਦ ਹੋਈ ਜਾਂ ਉਸਦਾ ਜਵਾਬ ਨਹੀਂ ਮਿਲਿਆ। ਇਸਨੂੰ ਆਪਣੀ ਸਾਈਟ ਉੱਤੇ ਜਾਂਚਣ ਯੋਗ ਰੁਝਾਨ ਸਮਝੋ, ਮਰਦਮਸ਼ੁਮਾਰੀ ਨਹੀਂ।

ਮੁਫ਼ਤ ਟੂਲ

ਅਗਲੇ ਕਦਮ

ਇਸ ਲੇਖ ਵਿਚਲੇ ਕ੍ਰੌਲਰ

ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

ਕੀ ਇਸਨੂੰ ਕਿਸੇ ਵੀ ਸਾਈਟ ਉੱਤੇ ਚਲਾਉਣਾ ਸੁਰੱਖਿਅਤ ਹੈ?

ਇਸਨੂੰ ਸਿਰਫ਼ ਉਨ੍ਹਾਂ ਸਾਈਟਾਂ ਉੱਤੇ ਚਲਾਓ ਜੋ ਤੁਹਾਡੀਆਂ ਹਨ ਜਾਂ ਜਿੱਥੇ ਟੈਸਟ ਦੀ ਇਜਾਜ਼ਤ ਹੈ। ਇਹ ਕ੍ਰੌਲਰ user agents ਨਾਲ ਬੇਨਤੀਆਂ ਭੇਜਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਕੁਝ ਬੋਟ ਸੁਰੱਖਿਆ ਪ੍ਰਣਾਲੀਆਂ ਵਿਰੋਧੀ ਮੰਨਦੀਆਂ ਹਨ।

robots.txt ਵੱਲੋਂ ਮਨ੍ਹਾ ਕਰਨ ਦੇ ਬਾਵਜੂਦ GPTBot ਲਈ ok ਕਿਉਂ ਦਿਸਦਾ ਹੈ?

robots.txt ਇੱਕ ਬੇਨਤੀ ਹੈ, ਤਾਲਾ ਨਹੀਂ। ਸਰਵਰ ਹਰ ਉਸ ਨੂੰ ਜਵਾਬ ਦਿੰਦਾ ਹੈ ਜੋ ਇਸਨੂੰ ਅਣਡਿੱਠਾ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ HTTP ਕਾਲਮ ਵਿੱਚ ok ਦਿਸਦਾ ਹੈ। ਨਾਲ ਵਾਲਾ ਨਿਯਮ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮ ਮੰਨਣ ਵਾਲਾ ਕ੍ਰੌਲਰ ਕੀ ਮੰਨਦਾ ਹੈ।

ਕੀ ਸਕ੍ਰਿਪਟ JavaScript ਚਲਾਉਂਦੀ ਹੈ?

ਨਹੀਂ, ਜਾਣ-ਬੁੱਝ ਕੇ। ਇਹ ਉਹ HTML ਦਿਖਾਉਂਦੀ ਹੈ ਜੋ ਪੰਨੇ ਰੈਂਡਰ ਨਾ ਕਰਨ ਵਾਲੇ ਕ੍ਰੌਲਰ ਨੂੰ ਮਿਲਦਾ ਹੈ। --expect ਫਲੈਗ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਹਾਡਾ ਮੁੱਖ ਟੈਕਸਟ ਪਹਿਲਾਂ ਹੀ ਉਸ HTML ਵਿੱਚ ਹੈ ਜਾਂ ਨਹੀਂ।

ਕੀ ਸਾਫ਼ ਨਤੀਜੇ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ChatGPT ਮੇਰੇ ਪੰਨੇ ਦਾ ਹਵਾਲਾ ਦੇਵੇਗਾ?

ਨਹੀਂ। ਪਹੁੰਚ ਜ਼ਰੂਰੀ ਹੈ ਪਰ ਕਾਫ਼ੀ ਨਹੀਂ। ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਕੋਈ ਸਹਾਇਕ ਤੁਹਾਡੀ ਸਾਈਟ ਦਾ ਨਾਮ ਲੈਂਦਾ ਹੈ ਜਾਂ ਨਹੀਂ, ਉਸ ਤੋਂ ਉਹ ਸਵਾਲ ਪੁੱਛੋ ਜੋ ਤੁਹਾਡੇ ਗਾਹਕ ਪੁੱਛਦੇ ਹਨ ਅਤੇ ਨੋਟ ਕਰੋ ਕਿ ਉਹ ਕਿਹੜੀਆਂ ਸਾਈਟਾਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ।

ਸਰੋਤ

ਹੋਰ ਲੇਖ