seo analysis คือ

SEO Analysis คืออะไร

SEO Analysis (การวิเคราะห์ SEO) คือกระบวนการตรวจสอบและประเมินประสิทธิภาพของเว็บไซต์ในแง่ Search Engine Optimization เพื่อหาจุดแข็ง จุดอ่อน และโอกาสในการปรับปรุงอันดับบน Google ครอบคลุม Technical SEO, On-page SEO, Off-page SEO, Content Analysis และ Competitor Analysis การทำ SEO Analysis เป็นประจำช่วยให้เว็บไซต์ติดอันดับสูงขึ้น มี organic traffic มากขึ้น และแปลงเป็นรายได้ได้ดีขึ้น บทความนี้อธิบายวิธีวิเคราะห์ SEO ครบทุกด้าน พร้อม Python tools สำหรับ automate การวิเคราะห์

SEO Analysis Components

# seo_components.py — SEO Analysis components
import json

class SEOComponents:
    COMPONENTS = {
        "technical": {
            "name": "Technical SEO",
            "description": "โครงสร้างเว็บไซต์ที่ search engine crawl และ index ได้ง่าย",
            "checks": [
                "Site speed (Core Web Vitals: LCP, FID, CLS)",
                "Mobile-friendliness (responsive design)",
                "SSL certificate (HTTPS)",
                "XML sitemap + robots.txt",
                "Canonical tags (ป้องกัน duplicate content)",
                "Structured data (Schema.org markup)",
                "Crawl errors (404, 500, redirect chains)",
            ],
        },
        "onpage": {
            "name": "On-page SEO",
            "description": "เนื้อหาและ HTML elements ในแต่ละหน้า",
            "checks": [
                "Title tag (50-60 ตัวอักษร, มี keyword)",
                "Meta description (150-160 ตัวอักษร)",
                "H1-H6 heading structure",
                "Keyword density (1-3%)",
                "Internal linking",
                "Image alt text",
                "URL structure (สั้น, มี keyword)",
            ],
        },
        "offpage": {
            "name": "Off-page SEO",
            "description": "สัญญาณภายนอกเว็บไซต์ — backlinks, social signals",
            "checks": [
                "Backlink profile (quality + quantity)",
                "Domain Authority / Domain Rating",
                "Referring domains diversity",
                "Anchor text distribution",
                "Social media signals",
                "Brand mentions",
            ],
        },
        "content": {
            "name": "Content Analysis",
            "description": "คุณภาพและความเกี่ยวข้องของเนื้อหา",
            "checks": [
                "Content quality (E-E-A-T: Experience, Expertise, Authority, Trust)",
                "Content freshness (อัปเดตเป็นประจำ)",
                "Content depth (ครอบคลุม topic)",
                "Keyword targeting (primary + secondary + LSI)",
                "Content gap analysis (topics ที่ยังไม่มี)",
            ],
        },
        "competitor": {
            "name": "Competitor Analysis",
            "description": "วิเคราะห์คู่แข่งเพื่อหาโอกาส",
            "checks": [
                "Competitor keywords (keywords ที่คู่แข่งติดอันดับ)",
                "Content comparison (เนื้อหาของคู่แข่ง)",
                "Backlink gap (backlinks ที่คู่แข่งมี เราไม่มี)",
                "SERP features (featured snippets, PAA)",
            ],
        },
    }

    def show_components(self):
        print("=== SEO Analysis Components ===\n")
        for key, comp in self.COMPONENTS.items():
            print(f"[{comp['name']}]")
            print(f"  {comp['description']}")
            for check in comp["checks"][:4]:
                print(f"  • {check}")
            print()

seo = SEOComponents()
seo.show_components()

Python SEO Analyzer

# seo_analyzer.py — Python SEO analysis tool
import json
import re

class SEOAnalyzer:
    CODE = """
# seo_tool.py — Automated SEO analysis
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse
import re

class PageSEOAnalyzer:
    def __init__(self, url):
        self.url = url
        self.soup = None
        self.issues = []
        self.scores = {}
    
    def fetch(self):
        resp = requests.get(self.url, timeout=10)
        self.soup = BeautifulSoup(resp.text, 'html.parser')
        self.status_code = resp.status_code
        self.response_time = resp.elapsed.total_seconds()
        return self
    
    def check_title(self):
        title = self.soup.find('title')
        if not title:
            self.issues.append(('critical', 'Missing title tag'))
            self.scores['title'] = 0
            return
        
        text = title.get_text().strip()
        length = len(text)
        
        if length < 30:
            self.issues.append(('warning', f'Title too short ({length} chars)'))
            self.scores['title'] = 50
        elif length > 60:
            self.issues.append(('warning', f'Title too long ({length} chars)'))
            self.scores['title'] = 70
        else:
            self.scores['title'] = 100
    
    def check_meta_description(self):
        meta = self.soup.find('meta', attrs={'name': 'description'})
        if not meta or not meta.get('content'):
            self.issues.append(('critical', 'Missing meta description'))
            self.scores['meta_desc'] = 0
            return
        
        length = len(meta['content'])
        if length < 120:
            self.issues.append(('warning', f'Meta description short ({length} chars)'))
            self.scores['meta_desc'] = 60
        elif length > 160:
            self.issues.append(('warning', f'Meta description long ({length} chars)'))
            self.scores['meta_desc'] = 70
        else:
            self.scores['meta_desc'] = 100
    
    def check_headings(self):
        h1s = self.soup.find_all('h1')
        if len(h1s) == 0:
            self.issues.append(('critical', 'Missing H1 tag'))
            self.scores['h1'] = 0
        elif len(h1s) > 1:
            self.issues.append(('warning', f'Multiple H1 tags ({len(h1s)})'))
            self.scores['h1'] = 60
        else:
            self.scores['h1'] = 100
    
    def check_images(self):
        images = self.soup.find_all('img')
        missing_alt = [img for img in images if not img.get('alt')]
        
        if missing_alt:
            self.issues.append(('warning', f'{len(missing_alt)} images missing alt text'))
            self.scores['images'] = max(0, 100 - len(missing_alt) * 10)
        else:
            self.scores['images'] = 100
    
    def check_links(self):
        links = self.soup.find_all('a', href=True)
        internal = [l for l in links if urlparse(l['href']).netloc in ('', urlparse(self.url).netloc)]
        external = [l for l in links if l not in internal]
        
        self.scores['internal_links'] = min(100, len(internal) * 5)
        self.scores['external_links'] = min(100, len(external) * 10)
    
    def full_analysis(self):
        self.fetch()
        self.check_title()
        self.check_meta_description()
        self.check_headings()
        self.check_images()
        self.check_links()
        
        overall = sum(self.scores.values()) / max(len(self.scores), 1)
        return {
            'url': self.url,
            'overall_score': round(overall, 1),
            'scores': self.scores,
            'issues': self.issues,
            'response_time': self.response_time,
        }

# Usage
analyzer = PageSEOAnalyzer('https://example.com')
result = analyzer.full_analysis()
print(f"Score: {result['overall_score']}/100")
for severity, issue in result['issues']:
    print(f"  [{severity.upper()}] {issue}")
"""

    def show_code(self):
        print("=== SEO Analyzer ===")
        print(self.CODE[:600])

analyzer = SEOAnalyzer()
analyzer.show_code()

SEO Tools

# seo_tools.py — SEO tools comparison
import json

class SEOTools:
    FREE_TOOLS = {
        "google_search_console": {
            "name": "Google Search Console",
            "description": "ดู keywords ที่ Google แสดงเว็บไซต์, clicks, impressions, CTR, position",
            "best_for": "Keyword performance, indexing issues, Core Web Vitals",
            "cost": "ฟรี",
        },
        "google_analytics": {
            "name": "Google Analytics 4",
            "description": "วิเคราะห์ traffic, user behavior, conversions",
            "best_for": "Traffic analysis, user journey, conversion tracking",
            "cost": "ฟรี",
        },
        "google_pagespeed": {
            "name": "Google PageSpeed Insights",
            "description": "วัด Core Web Vitals และ performance score",
            "best_for": "Site speed, mobile performance, CWV",
            "cost": "ฟรี",
        },
        "google_trends": {
            "name": "Google Trends",
            "description": "ดู trend ของ keywords ตาม timeline และ region",
            "best_for": "Keyword trends, seasonal content planning",
            "cost": "ฟรี",
        },
    }

    PAID_TOOLS = {
        "ahrefs": {
            "name": "Ahrefs",
            "description": "Backlink analysis, keyword research, site audit",
            "best_for": "Backlink analysis ดีที่สุด, competitor research",
            "cost": "$99-999/month",
        },
        "semrush": {
            "name": "SEMrush",
            "description": "All-in-one SEO toolkit — keyword, audit, content, PPC",
            "best_for": "Keyword research, content marketing, PPC analysis",
            "cost": "$119-449/month",
        },
        "screaming_frog": {
            "name": "Screaming Frog SEO Spider",
            "description": "Website crawler — technical SEO audit",
            "best_for": "Technical SEO audit, crawl analysis",
            "cost": "ฟรี (500 URLs) / £199/year (unlimited)",
        },
        "surfer": {
            "name": "Surfer SEO",
            "description": "Content optimization — วิเคราะห์ SERP แนะนำ content",
            "best_for": "Content optimization, NLP-based recommendations",
            "cost": "$49-199/month",
        },
    }

    def show_free(self):
        print("=== Free SEO Tools ===\n")
        for key, tool in self.FREE_TOOLS.items():
            print(f"[{tool['name']}] {tool['cost']}")
            print(f"  Best for: {tool['best_for']}")
            print()

    def show_paid(self):
        print("=== Paid SEO Tools ===")
        for key, tool in self.PAID_TOOLS.items():
            print(f"  [{tool['name']}] {tool['cost']} — {tool['best_for']}")

tools = SEOTools()
tools.show_free()
tools.show_paid()

Keyword Research

# keyword_research.py — Keyword research guide
import json
import random

class KeywordResearch:
    PROCESS = {
        "seed": {
            "name": "1. Seed Keywords",
            "description": "เริ่มจาก keywords กว้างๆ ที่เกี่ยวกับธุรกิจ",
            "example": "SEO, การตลาดออนไลน์, digital marketing",
        },
        "expand": {
            "name": "2. Expand Keywords",
            "description": "ใช้ tools ขยาย seed keywords เป็น long-tail keywords",
            "tools": "Google Autocomplete, People Also Ask, Ahrefs Keywords Explorer",
        },
        "analyze": {
            "name": "3. Analyze Metrics",
            "description": "วิเคราะห์ search volume, keyword difficulty, CPC",
            "metrics": "Volume > 100/month, KD < 30 (เริ่มต้น), CPC > 0 (commercial intent)",
        },
        "intent": {
            "name": "4. Search Intent",
            "description": "เข้าใจ intent ของ keyword — Informational, Commercial, Transactional, Navigational",
            "mapping": "Informational → blog, Commercial → comparison, Transactional → product page",
        },
        "prioritize": {
            "name": "5. Prioritize",
            "description": "เลือก keywords ที่มีโอกาสติดอันดับ + ตรง business goal",
            "formula": "Priority = (Volume × CTR potential) / Difficulty",
        },
    }

    def show_process(self):
        print("=== Keyword Research Process ===\n")
        for key, step in self.PROCESS.items():
            print(f"[{step['name']}]")
            print(f"  {step['description']}")
            print()

    def keyword_example(self):
        print("=== Keyword Analysis Example ===")
        keywords = [
            {"keyword": "seo analysis คือ", "volume": random.randint(500, 2000), "kd": random.randint(10, 30), "intent": "Informational"},
            {"keyword": "seo analysis tool", "volume": random.randint(1000, 5000), "kd": random.randint(20, 50), "intent": "Commercial"},
            {"keyword": "seo audit free", "volume": random.randint(500, 3000), "kd": random.randint(15, 40), "intent": "Transactional"},
            {"keyword": "วิเคราะห์ seo เว็บไซต์", "volume": random.randint(200, 1000), "kd": random.randint(5, 20), "intent": "Informational"},
        ]
        print(f"  {'Keyword':<30} {'Volume':>8} {'KD':>5} {'Intent':<15}")
        print(f"  {'-'*60}")
        for kw in keywords:
            print(f"  {kw['keyword']:<30} {kw['volume']:>8} {kw['kd']:>5} {kw['intent']:<15}")

kr = KeywordResearch()
kr.show_process()
kr.keyword_example()

SEO Audit Checklist

# audit_checklist.py — SEO audit checklist
import json

class SEOAuditChecklist:
    CHECKLIST = {
        "technical": [
            "HTTPS enabled (SSL certificate)",
            "Mobile-friendly (responsive design)",
            "Site speed < 3 seconds (LCP < 2.5s)",
            "XML sitemap submitted to GSC",
            "robots.txt ไม่ block important pages",
            "No broken links (404 errors)",
            "Canonical tags ถูกต้อง",
            "Schema markup (Organization, Article, FAQ)",
            "Hreflang tags (ถ้ามีหลายภาษา)",
        ],
        "onpage": [
            "Title tags unique ทุกหน้า (50-60 chars)",
            "Meta descriptions unique (150-160 chars)",
            "H1 tag มี 1 อัน per page",
            "H2-H6 structure ถูกต้อง",
            "Images มี alt text",
            "Internal links เชื่อมหน้าสำคัญ",
            "URL สั้น มี keyword",
            "Content > 1,000 words (สำหรับ blog)",
        ],
        "offpage": [
            "Backlinks จาก high-authority sites",
            "Anchor text หลากหลาย (branded + keyword + generic)",
            "No toxic/spam backlinks",
            "Google Business Profile (ถ้ามี local business)",
            "Social media profiles active",
        ],
        "content": [
            "Target keyword ใน title, H1, first paragraph",
            "Content ตอบ search intent",
            "No duplicate content",
            "Content updated ภายใน 6 เดือน",
            "FAQ section (ช่วยได้ featured snippets)",
        ],
    }

    def show_checklist(self):
        print("=== SEO Audit Checklist ===\n")
        for category, items in self.CHECKLIST.items():
            print(f"[{category.upper()}]")
            for item in items[:5]:
                print(f"  □ {item}")
            print()

    def scoring(self):
        print("=== SEO Score Guide ===")
        scores = [
            {"range": "90-100", "grade": "A", "status": "ดีมาก — maintain + optimize"},
            {"range": "70-89", "grade": "B", "status": "ดี — fix medium issues"},
            {"range": "50-69", "grade": "C", "status": "ปานกลาง — fix critical + medium"},
            {"range": "30-49", "grade": "D", "status": "ต้องปรับปรุงมาก"},
            {"range": "0-29", "grade": "F", "status": "ต้อง overhaul ทั้งระบบ"},
        ]
        for s in scores:
            print(f"  [{s['grade']}] {s['range']:>6} — {s['status']}")

audit = SEOAuditChecklist()
audit.show_checklist()
audit.scoring()

FAQ - คำถามที่พบบ่อย

Q: SEO Analysis ต้องทำบ่อยแค่ไหน?

A: Technical audit: ทุกเดือน (automated) หรือทุกไตรมาส (manual) Keyword tracking: ทุกสัปดาห์ Content audit: ทุก 3-6 เดือน Backlink monitoring: ทุกเดือน Competitor analysis: ทุกไตรมาส ใช้ tools อย่าง Google Search Console ดูข้อมูลทุกสัปดาห์

Q: เริ่มทำ SEO Analysis อย่างไร?

A: Step 1: Setup Google Search Console + Google Analytics (ฟรี) Step 2: Crawl เว็บด้วย Screaming Frog (ฟรี 500 URLs) Step 3: ตรวจ Core Web Vitals (PageSpeed Insights) Step 4: วิเคราะห์ keywords ที่ติดอันดับ (GSC) Step 5: ดู backlinks (Ahrefs free backlink checker) Step 6: แก้ไข critical issues ก่อน → medium → low

Q: Core Web Vitals สำคัญแค่ไหน?

A: Google ใช้เป็น ranking factor ตั้งแต่ 2021 LCP (Largest Contentful Paint): < 2.5s = ดี FID (First Input Delay): < 100ms = ดี (เปลี่ยนเป็น INP แล้ว) CLS (Cumulative Layout Shift): < 0.1 = ดี ส่งผลต่อ ranking โดยเฉพาะ mobile — ต้อง optimize

Q: Tool ไหนดีที่สุดสำหรับ SEO Analysis?

A: ฟรี: Google Search Console + Google Analytics + Screaming Frog Budget: Ubersuggest ($29/month) หรือ SE Ranking Professional: Ahrefs ($99/month) หรือ SEMrush ($119/month) Enterprise: SEMrush Enterprise หรือ BrightEdge เริ่มจาก: GSC + GA ฟรี → เพิ่ม Ahrefs/SEMrush เมื่อ serious