Google: guida agli operatori di ricerca avanzata

1

"frase esatta da cercare"

1

termine1 OR termine2

1

termine1 AND termine2

1

termine -esclusione

1

"inizio * fine"

1

termine 2020..2024

1

termine1 AROUND(n) termine2

1

site:dominio.com

1

related:dominio.com

1

cache:url-completo

1

filetype:estensione termine

1

ext:estensione termine

1

termine daterange:data1-data2

1
2

termine after:2024-01-01
termine before:2024-12-31

1

inurl:parola

1

allinurl:parola1 parola2

1

intitle:parola

1

allintitle:parola1 parola2

1

intext:parola

1

allintext:parola1 parola2 parola3

1

site:competitor1.com -site:miosito.com "keyword target"

1

link:competitor.com -site:competitor.com

1

"write for us" OR "guest post" OR "submit article" site:settore.com

1

site:dominio.com

1

"nome cognome" "città" "professione"

1

filetype:pdf "confidential" OR "riservato" site:azienda.com

1

"email@domain.com" OR "username" OR "numero telefono"

1

intitle:"index of" password

1

filetype:pdf "abstract" "introduction" "methodology" "conclusion"

1

"nome autore" "titolo paper" filetype:pdf

1

filetype:csv OR filetype:json "dataset" argomento

1

site:github.com "linguaggio" stars:>100

1

"case study" OR "success story" settore 2024

1

"press release" OR "comunicato stampa" azienda data

1

site:linkedin.com "job title" "location" "experience"

1

(terme1 OR terme2) AND (terme3 OR terme4) -terme5

1

termine "città" OR "regione" OR "paese"

1

"pattern*iniziale" OR "*pattern*centrale" OR "*pattern finale"

1

site:target.com filetype:txt OR filetype:log OR filetype:bak

1

site:*.target.com -www

1

site:target.com "powered by" OR "built with" OR "framework"

1

site:target.com "error" OR "exception" OR "stack trace"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import requests
import json

def google_custom_search(query, api_key, cx, **kwargs):
    """
    Esegue ricerca Google tramite Custom Search API
    """
    base_url = "https://www.googleapis.com/customsearch/v1"

    params = {
        'key': api_key,
        'cx': cx,
        'q': query,
    }

    # Parametri aggiuntivi
    params.update(kwargs)

    response = requests.get(base_url, params=params)
    return response.json()

# Esempio di utilizzo
api_key = "YOUR_API_KEY"
cx = "YOUR_SEARCH_ENGINE_ID"

# Ricerca base
results = google_custom_search("python tutorial", api_key, cx)

# Ricerca avanzata con filtri
advanced_results = google_custom_search(
    "machine learning",
    api_key, cx,
    siteSearch="github.com",
    fileType="pdf",
    dateRestrict="m1"  # Ultimo mese
)

# Elaborazione risultati
for item in results.get('items', []):
    print(f"Titolo: {item['title']}")
    print(f"URL: {item['link']}")
    print(f"Snippet: {item['snippet']}")
    print("---")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

import requests
from bs4 import BeautifulSoup
import time
import csv
from datetime import datetime

class GoogleSERPMonitor:
    """Monitora posizionamenti SERP per keyword specifiche"""

    def __init__(self):
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }

    def search_google(self, query, num_results=100):
        """Esegue ricerca Google e estrae risultati"""
        url = f"https://www.google.com/search?q={query}&num={num_results}"

        try:
            response = requests.get(url, headers=self.headers)
            soup = BeautifulSoup(response.content, 'html.parser')

            results = []
            for i, result in enumerate(soup.find_all('div', class_='g'), 1):
                title_elem = result.find('h3')
                link_elem = result.find('a')

                if title_elem and link_elem:
                    title = title_elem.get_text()
                    link = link_elem['href']

                    results.append({
                        'position': i,
                        'title': title,
                        'url': link,
                        'timestamp': datetime.now().isoformat()
                    })

            return results

        except Exception as e:
            print(f"Errore durante la ricerca: {e}")
            return []

    def monitor_keywords(self, keywords, domain_to_monitor):
        """Monitora posizionamento di un dominio per liste di keyword"""
        results = []

        for keyword in keywords:
            print(f"Monitoraggio keyword: {keyword}")

            serp_results = self.search_google(keyword)

            # Cerca il dominio nei risultati
            domain_position = None
            for result in serp_results:
                if domain_to_monitor in result['url']:
                    domain_position = result['position']
                    break

            results.append({
                'keyword': keyword,
                'domain': domain_to_monitor,
                'position': domain_position,
                'timestamp': datetime.now().isoformat()
            })

            # Pausa per evitare rate limiting
            time.sleep(2)

        return results

    def export_to_csv(self, data, filename):
        """Esporta risultati in CSV"""
        if not data:
            return

        fieldnames = data[0].keys()

        with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(data)

# Esempio di utilizzo
monitor = GoogleSERPMonitor()

keywords_to_monitor = [
    "python tutorial",
    "machine learning course",
    "data science bootcamp"
]

domain_to_track = "example.com"

# Esegui monitoraggio
monitoring_results = monitor.monitor_keywords(keywords_to_monitor, domain_to_track)

# Esporta risultati
monitor.export_to_csv(monitoring_results, f"serp_monitoring_{datetime.now().strftime('%Y%m%d')}.csv")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

import concurrent.futures
import requests
from urllib.parse import quote_plus
import time

class BulkGoogleAnalyzer:
    """Analizza risultati Google per multiple query in batch"""

    def __init__(self, max_workers=5):
        self.max_workers = max_workers
        self.delay_between_requests = 1  # Secondi

    def analyze_single_query(self, query_data):
        """Analizza una singola query"""
        query, filters = query_data

        # Costruisci query completa
        full_query = query
        if filters:
            full_query += " " + " ".join(filters)

        try:
            # Simula analisi (sostituire con API reale)
            encoded_query = quote_plus(full_query)

            # Qui implementeresti la logica di analisi reale
            # Per esempio: conteggio risultati, analisi domini, ecc.

            analysis_result = {
                'query': query,
                'filters': filters,
                'full_query': full_query,
                'estimated_results': 'Simulated: 1,234,567',  # Da implementare
                'top_domains': ['example1.com', 'example2.com'],  # Da implementare
                'analysis_timestamp': time.time()
            }

            time.sleep(self.delay_between_requests)
            return analysis_result

        except Exception as e:
            return {
                'query': query,
                'error': str(e),
                'analysis_timestamp': time.time()
            }

    def bulk_analyze(self, queries_with_filters):
        """Analizza multiple query in parallelo"""
        results = []

        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            future_to_query = {
                executor.submit(self.analyze_single_query, query_data): query_data
                for query_data in queries_with_filters
            }

            for future in concurrent.futures.as_completed(future_to_query):
                query_data = future_to_query[future]
                try:
                    result = future.result()
                    results.append(result)
                    print(f"Completata analisi per: {query_data[0]}")
                except Exception as e:
                    print(f"Errore nell'analisi di {query_data[0]}: {e}")

        return results

# Esempio di utilizzo
analyzer = BulkGoogleAnalyzer(max_workers=3)

# Lista di query con relativi filtri
queries_to_analyze = [
    ("python tutorial", ["site:youtube.com", "after:2024-01-01"]),
    ("machine learning", ["filetype:pdf", "2024"]),
    ("data science jobs", ["site:linkedin.com", "remote"]),
    ("web development", ["intitle:course", "beginner"]),
]

# Esegui analisi in batch
bulk_results = analyzer.bulk_analyze(queries_to_analyze)

# Stampa risultati
for result in bulk_results:
    if 'error' in result:
        print(f"ERRORE - {result['query']}: {result['error']}")
    else:
        print(f"Query: {result['query']}")
        print(f"Risultati stimati: {result['estimated_results']}")
        print(f"Top domini: {', '.join(result['top_domains'])}")
        print("---")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

def content_research_queries(topic, competitors):
    """Genera query per ricerca contenuti marketing"""

    queries = []

    # Gap analysis
    for competitor in competitors:
        queries.append(f'site:{competitor} "{topic}" -site:miosito.com')

    # Trending content
    queries.extend([
        f'"{topic}" intitle:"2024" OR intitle:"latest"',
        f'"{topic}" "case study" OR "success story"',
        f'"{topic}" "statistics" OR "report" filetype:pdf'
    ])

    # Guest post opportunities
    queries.extend([
        f'"write for us" "{topic}"',
        f'"guest post" "{topic}" guidelines',
        f'"submit article" "{topic}"'
    ])

    return queries

# Esempio
topic = "artificial intelligence"
competitors = ["techcrunch.com", "wired.com", "venturebeat.com"]
research_queries = content_research_queries(topic, competitors)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def security_audit_queries(target_domain):
    """Genera query per security audit base"""

    return [
        # Information disclosure
        f'site:{target_domain} filetype:txt OR filetype:log',
        f'site:{target_domain} "index of" OR "directory listing"',
        f'site:{target_domain} "error" OR "exception" OR "stack trace"',

        # Configuration files
        f'site:{target_domain} filetype:xml OR filetype:conf OR filetype:cnf',
        f'site:{target_domain} "config" OR "configuration"',

        # Database info
        f'site:{target_domain} "database" OR "db" error',
        f'site:{target_domain} "mysql" OR "postgresql" OR "oracle"',

        # Login pages
        f'site:{target_domain} inurl:login OR inurl:admin',
        f'site:{target_domain} intitle:login OR intitle:"sign in"',

        # API endpoints
        f'site:{target_domain} inurl:api OR "api key" OR "api secret"',
        f'site:{target_domain} "swagger" OR "openapi"'
    ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def academic_research_queries(research_topic, year_range="2020..2024"):
    """Genera query per ricerca accademica"""

    base_queries = [
        # Papers e pubblicazioni
        f'"{research_topic}" filetype:pdf "abstract" "references" {year_range}',
        f'"{research_topic}" "systematic review" OR "meta-analysis" {year_range}',

        # Dataset e dati
        f'"{research_topic}" dataset filetype:csv OR filetype:json',
        f'"{research_topic}" "open data" OR "public dataset"',

        # Conferenze e proceedings
        f'"{research_topic}" "proceedings" OR "conference" {year_range}',
        f'"{research_topic}" "IEEE" OR "ACM" OR "springer"',

        # Citazioni e impact
        f'"{research_topic}" "cited by" OR "citations" scholar',
        f'"{research_topic}" "h-index" OR "impact factor"'
    ]

    return base_queries

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

def brand_monitoring_setup(brand_name, competitors=None):
    """Setup query per monitoraggio brand"""

    monitoring_queries = []

    # Menzioni brand
    monitoring_queries.extend([
        f'"{brand_name}" -site:nostrosito.com',
        f'"{brand_name}" review OR opinion OR feedback',
        f'"{brand_name}" complaint OR problem OR issue',
        f'"{brand_name}" vs OR versus OR compared'
    ])

    # Confronti con competitor
    if competitors:
        for competitor in competitors:
            monitoring_queries.append(f'"{brand_name}" vs "{competitor}"')

    # News e press
    monitoring_queries.extend([
        f'"{brand_name}" "press release" OR "news"',
        f'"{brand_name}" "partnership" OR "acquisition"',
        f'"{brand_name}" "funding" OR "investment"'
    ])

    return monitoring_queries

# Implementazione alert system
class GoogleAlertSystem:
    def __init__(self, queries, check_interval_hours=24):
        self.queries = queries
        self.check_interval = check_interval_hours
        self.last_results = {}

    def check_for_new_results(self):
        """Controlla nuovi risultati per le query monitorate"""
        new_alerts = []

        for query in self.queries:
            # Esegui ricerca (implementare con API)
            current_results = self.execute_search(query)

            # Confronta con risultati precedenti
            if query in self.last_results:
                new_items = self.find_new_items(
                    current_results,
                    self.last_results[query]
                )
                if new_items:
                    new_alerts.append({
                        'query': query,
                        'new_results': new_items,
                        'timestamp': time.time()
                    })

            self.last_results[query] = current_results

        return new_alerts

    def execute_search(self, query):
        """Esegue ricerca e estrae risultati"""
        # Implementare logica di ricerca
        pass

    def find_new_items(self, current, previous):
        """Trova nuovi elementi rispetto all'ultima verifica"""
        # Implementare logica di confronto
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Configurazione CSE per ricerca sviluppo
const developerCSE = {
    sites: [
        "stackoverflow.com",
        "github.com",
        "docs.microsoft.com",
        "developer.mozilla.org",
        "w3schools.com"
    ],
    filters: [
        "programming",
        "development",
        "coding",
        "software"
    ]
}

// Configurazione CSE per ricerca accademica
const academicCSE = {
    sites: [
        "scholar.google.com",
        "arxiv.org",
        "pubmed.ncbi.nlm.nih.gov",
        "ieee.org",
        "acm.org"
    ],
    filters: [
        "research",
        "paper",
        "study",
        "analysis"
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<!-- Bookmark per ricerca competitor -->
javascript:(function(){
    var competitor = prompt("Inserisci dominio competitor:");
    var topic = prompt("Inserisci topic:");
    if(competitor && topic) {
        var query = `site:${competitor} "${topic}" -site:miodominio.com`;
        window.open(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
    }
})();

<!-- Bookmark per ricerca backlink opportunities -->
javascript:(function(){
    var keyword = prompt("Inserisci keyword:");
    if(keyword) {
        var query = `"${keyword}" "write for us" OR "guest post" OR "submit article"`;
        window.open(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
    }
})();

<!-- Bookmark per ricerca file esposti -->
javascript:(function(){
    var domain = prompt("Inserisci dominio da analizzare:");
    if(domain) {
        var query = `site:${domain} filetype:pdf OR filetype:docx OR filetype:xlsx`;
        window.open(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
    }
})();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

def build_google_search_url(query, **params):
    """Costruisce URL Google Search con parametri avanzati"""

    base_url = "https://www.google.com/search"

    # Parametri base
    url_params = {'q': query}

    # Parametri aggiuntivi supportati
    param_mapping = {
        'num': 'num',           # Numero risultati (max 100)
        'start': 'start',       # Offset risultati
        'hl': 'hl',             # Lingua interfaccia
        'lr': 'lr',             # Lingua risultati
        'cr': 'cr',             # Paese
        'safe': 'safe',         # Safe search (active/off)
        'filter': 'filter',     # Filtro duplicati (0/1)
        'pws': 'pws',           # Personalizzazione (0/1)
        'tbs': 'tbs'            # Time-based search
    }

    for key, value in params.items():
        if key in param_mapping and value is not None:
            url_params[param_mapping[key]] = value

    # Costruisci URL
    from urllib.parse import urlencode
    return f"{base_url}?{urlencode(url_params)}"

# Esempi di utilizzo
search_url = build_google_search_url(
    "python tutorial",
    num=50,
    hl='it',
    lr='lang_it',
    tbs='qdr:m',  # Ultimo mese
    safe='active'
)

print(search_url)
# Output: https://www.google.com/search?q=python+tutorial&num=50&hl=it&lr=lang_it&tbs=qdr%3Am&safe=active