# Jak uzyskać wyniki wyszukiwania Google w Pythonie (2026)

> Google w Pythonie w 2026: dlaczego zwykłe requests zawodzą i przetestowany kod dla requests, pandas, async httpx, paginacji i plików JSONL.

- URL: https://serpcrypto.com/pl/guides/google-search-results-python/
- Ostatnia aktualizacja: 2026-10-22
- Wydawca: SerpCrypto (https://serpcrypto.com)

Pobieranie google.com przez requests przestało być opcją w 2025. Ten poradnik wyjaśnia dlaczego, a potem podaje krótki, sprawdzony składniowo Python, który przez API SERP zwraca te same wyniki jako JSON.

**Szybka odpowiedź — Jak uzyskać wyniki wyszukiwania Google w Pythonie w 2026?**

Wywołaj API SERP z Pythona i odczytaj zwrócony JSON; nie pobieraj google.com samodzielnie, bo Google wymaga JavaScript od 17 stycznia 2025, a jego robots.txt zabrania `/search`. Z **SerpCrypto** jedno `requests.get` do `https://serpcrypto.com/api/v1/search` zwraca wyniki organiczne, People Also Ask i więcej, za jeden kredyt na wyszukiwanie od 0,30 USD/1K wyszukiwań na październik 2026. Bez KYC; płatność kryptowalutą.

## Czego potrzebujesz

| Atrybut | Wartość |
| --- | --- |
| Python | 3.9 lub nowszy |
| Pakiety | `requests` do podstaw; `pandas` do tabel; `httpx` do async |
| klucz API | Z Twojego panelu SerpCrypto, przechowywany w zmiennej środowiskowej `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Koszt | 1 kredyt = 1 udane zapytanie wyszukiwania, które zwraca jedną stronę wyników na dowolnym obsługiwanym silniku. Nieudane zapytanie nie jest rozliczane |
| Najmniejszy pakiet | 10 000 wyszukiwań za 7,50 USD; kredyty nigdy nie wygasają |

## Dlaczego requests.get na google.com już nie działa?

Bo wyniki nie są już w HTML, który otrzymuje zwykły klient HTTP. 17 stycznia 2025 Google zaczęło wymagać JavaScript dla wyszukiwania; twierdziło, że JavaScript pomaga chronić jego usługi przed botami i że mniej niż 0,1% wyszukiwań pochodziło od użytkowników z wyłączonym JavaScript, jak podał TechCrunch.

robots.txt Google, odczytany 22 października 2026, wymienia też `Disallow: /search` dla wszystkich User-Agent. API SERP zajmuje się wykonaniem wyszukiwania i parsowaniem strony, a Twój kod Python ma do czynienia tylko z JSON. To podejście stosowane w dalszej części tego poradnika.

## Jak wykonać pierwsze zapytanie?

Zainstaluj requests, umieść klucz w zmiennej środowiskowej i wyślij zapytanie z krajem i językiem. Odpowiedź to słownik z jednym kluczem na blok strony wyników; `organic_results` zawiera linki w kolejności rankingowej.

Trzymaj klucz poza kodem źródłowym. Na macOS i Linux `export SERPCRYPTO_API_KEY=...` w powłoce; w Windows PowerShell `$env:SERPCRYPTO_API_KEY="..."`.

*Pierwsze zapytanie z requests*

```python
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
KEY = os.environ["SERPCRYPTO_API_KEY"]

resp = requests.get(
    API,
    headers={"Authorization": "Bearer " + KEY},
    params={"engine": "google", "q": "best hiking boots", "gl": "us", "hl": "en"},
    timeout=60,
)
resp.raise_for_status()
results = resp.json()

for item in results.get("organic_results", []):
    print(item["position"], item["title"])
    print("   ", item["link"])

for q in results.get("people_also_ask", []):
    print("PAA:", q["question"])

```

## Jak zamienić wyniki w pandas DataFrame?

Zbuduj jeden wiersz na wynik organiczny i zachowaj obok niego zapytanie. DataFrame ułatwia sortowanie, filtrowanie po domenie oraz eksport do CSV i Excel. Brakujące pola, takie jak `date` w większości wyników, stają się pustymi komórkami zamiast błędów.

*Kilka zapytań w jeden DataFrame*

```python
import os
from urllib.parse import urlparse

import pandas as pd
import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def organic_rows(query, gl="us", hl="en"):
    params = {"engine": "google", "q": query, "gl": gl, "hl": hl}
    resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
    resp.raise_for_status()
    for r in resp.json().get("organic_results", []):
        yield {
            "query": query,
            "position": r.get("position"),
            "title": r.get("title"),
            "domain": urlparse(r.get("link", "")).netloc,
            "link": r.get("link"),
            "snippet": r.get("snippet"),
        }


queries = ["crm for small business", "invoice software", "time tracking app"]
df = pd.DataFrame([row for q in queries for row in organic_rows(q)])
print(df.groupby("domain").size().sort_values(ascending=False).head(10))
df.to_csv("serp_results.csv", index=False)

```

## Jak uruchomić wiele wyszukiwań naraz?

Użyj httpx z asyncio i ogranicz liczbę równoczesnych zapytań semaforem. Twoje konto ma limit współbieżności widoczny w panelu; trzymanie się poniżej niego pozwala uniknąć błędów `429`. Zacznij od małej liczby, np. 5, i ustaw ją na limit pokazywany w panelu.

*Asynchroniczne wyszukiwania z httpx i semaforem*

```python
import asyncio
import os

import httpx

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}
LIMIT = asyncio.Semaphore(5)


async def search(client, query):
    async with LIMIT:
        resp = await client.get(API, params={"engine": "google", "q": query, "gl": "us", "hl": "en"})
        resp.raise_for_status()
        data = resp.json()
        top = data.get("organic_results", [])[:3]
        return query, [r["link"] for r in top]


async def main(queries):
    async with httpx.AsyncClient(headers=HEADERS, timeout=60) as client:
        for query, links in await asyncio.gather(*(search(client, q) for q in queries)):
            print(query, links)


if __name__ == "__main__":
    asyncio.run(main(["python web framework", "python orm", "python task queue"]))

```

## Jak uzyskać więcej niż 10 wyników i je zapisać?

Poproś o kolejne strony przez `page=2`, `page=3` i tak dalej, aż do `page=10`. Każda strona to jedno wyszukiwanie i jeden kredyt, ponieważ Google serwuje około 10 organicznych wyników na stronę, odkąd w wrześniu 2025 przestało respektować `num=100`.

Zapisz każdą surową odpowiedź jako jedną linię pliku JSONL. Surowy JSON zachowuje wszystkie bloki, więc później możesz odpowiedzieć na nowe pytania bez ponownego płacenia za te same wyszukiwania.

*Strony od 1 do 3 zapisane jako JSONL*

```python
import json
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def fetch_pages(query, pages=3, path="serp.jsonl"):
    with open(path, "a", encoding="utf-8") as out:
        for page in range(1, pages + 1):
            params = {"engine": "google", "q": query, "gl": "us", "hl": "en", "page": page}
            resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
            resp.raise_for_status()
            data = resp.json()
            out.write(json.dumps(data, ensure_ascii=False) + "\n")
            if not data.get("organic_results"):
                break


fetch_pages("electric cargo bike", pages=3)

```

## Ile kosztuje uruchomienie tego kodu?

Każde wywołanie w tych przykładach to jedno wyszukiwanie. Pierwszy przykład kosztuje jeden kredyt, przykład z DataFrame trzy, a przykład z JSONL do trzech. Nieudane zapytanie nie jest obciążane opłatą.

10 000 wyszukiwań kosztują 7,50 USD, a 100 000 wyszukiwań kosztują 56,25 USD, według stanu na październik 2026; stawka spada do 0,30 USD/1K wyszukiwań przy 5 000 000 wyszukiwań. Kredyty nigdy nie wygasają. Płacisz w BTC, USDT, USDC, ETH, SOL, LTC z doładowania 25 USD, bez wysyłania dokumentu tożsamości. Zobacz [cennik](https://serpcrypto.com/pl/pricing/).

## Wyniki wyszukiwania Google w Pythonie: najczęstsze pytania

### Czy mogę użyć BeautifulSoup na stronach wyników Google?

Nie w sposób niezawodny. Google wymaga JavaScriptu od stycznia 2025, więc HTML odbierany przez zwykłego klienta nie zawiera wyników, a robots.txt Google zabrania `/search`. API SERP zwraca zamiast tego sparsowane pola jako JSON.

### Czy istnieje oficjalna biblioteka Python dla SerpCrypto?

Nie. API to zwykły endpoint HTTPS, więc wystarczy `requests` lub `httpx`. Przykłady na tej stronie i na [stronie dokumentacji Pythona](https://serpcrypto.com/pl/docs/python/) to kod do skopiowania, a nie opublikowany pakiet.

### Jak uzyskać wyniki dla innego kraju?

Ustaw `gl` na kod kraju, a `hl` na język, na przykład `gl=fr` i `hl=fr` dla Francji. Dodaj `location` dla miasta. [Strona lokalizacji](https://serpcrypto.com/pl/docs/locations/) zawiera listę popularnych kodów.

### Jak obsłużyć błędy i ponowienia?

Wywołaj `raise_for_status()`, a następnie ponów `429`, `502` i `504` po rosnącym opóźnieniu. Nieudane zapytania nie są obciążane opłatą. [Strona błędów](https://serpcrypto.com/pl/docs/errors/) zawiera pełną funkcję ponawiania.

### Czy tym samym kodem mogę uzyskać wyniki Bing?

Tak. Zmień `engine` na `bing`; odpowiedź zachowuje ten sam kształt, z `organic_results` i `related_searches`.

## Źródła

1. [Google zaczyna wymagać JavaScriptu dla wyszukiwarki Google](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [robots.txt google.com](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [Google zmusza trackery pozycji do 500–1 000 zapytań na jedno słowo kluczowe](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto to API SERP dla deweloperów i agentów AI, które zwraca wyniki wyszukiwania Google i Bing w formacie JSON, z płatnością kryptowalutą i bez przesyłania dokumentów tożsamości. Przedpłacone kredyty wyszukiwania od 0,30 USD/1K wyszukiwań nigdy nie wygasają. Bez KYC — bez dokumentu, bez selfie, bez dokumentów. Płatność kryptowalutą.