En los rastreadores de Python 3, usar un proxy es un método común para evitar que la IP sea bloqueada o para aumentar la velocidad de rastreo. Se utiliza principalmente para simular acceso desde múltiples direcciones IP. Los proxies se pueden dividir en proxies gratuitos y de pago; los gratuitos son inestables, mientras que los de pago son relativamente más estables y fiables.
A continuación se muestran los escenarios de uso y aplicaciones de los proxies para crawlers en Python3:
Evitar que la IP sea bloqueada: algunos sitios web establecen límites de frecuencia de acceso por IP. Si el número de accesos supera el límite, esa IP quedará prohibida para acceder al sitio; usar un proxy puede evitar que esto ocurra.
Mejorar la velocidad de rastreo: usar un proxy permite establecer varias conexiones al mismo tiempo, logrando así recopilar rápidamente los datos objetivo.
Omitir restricciones geográficas: algunos sitios web ofrecen servicios distintos según la región. Si necesitas acceder a sitios que solo están abiertos para zonas concretas, usar un proxy puede sortear esta limitación y permitirte obtener los datos que necesitas.
En resumen, la IP proxy desempeña un papel muy importante en el scraping con Python 3. Debido a que el uso de proxies también puede introducir algunos problemas de seguridad, al usarlos es necesario prestar atención a elegir un proveedor de proxies adecuado y cumplir estrictamente las normas de ciberseguridad.
Preparación
Primero necesitamos obtener un proxy disponible; un proxy es la combinación de una dirección IP y un puerto, es decir, ip:puerto Este formato. Si el proxy requiere autenticación de acceso, también se necesitarán dos datos adicionales: nombre de usuario y contraseña.
Aquí tengo instalado en mi equipo un software proxy, que crea un servicio proxy HTTP en el puerto local 7890, es decir, el proxy es 127.0.0.1:7890. Además, ese software también crea un servicio proxy SOCKS en el puerto 7891, es decir, el proxy es 127.0.0.1:7891; por lo tanto, mientras configures este proxy, podrás cambiar con éxito la IP de este equipo a la IP del servidor al que se conecta el software proxy.
En los ejemplos de este capítulo, usaré el proxy anterior para mostrar cómo se configura; también puedes sustituirlo por tu propio proxy disponible.
Después de configurar el proxy, el sitio que se prueba es http://httpbin.org/get Al acceder a este enlace podemos obtener la información relacionada con la solicitud; entre los resultados devueltos, el campo `origin` es la IP del cliente. Podemos usarlo para determinar si el proxy se configuró correctamente, es decir, si la IP se ha falsificado con éxito.
Bien, a continuación veremos los métodos de configuración de proxy para cada biblioteca de solicitudes.
Obtener un proxy para scraping en Python3
Algunos sitios web detectan el acceso frecuente a sus datos y toman medidas para bloquearlo. Usar un servidor proxy puede distribuir el origen de los accesos, reducir la probabilidad de detección y, con ello, aumentar la tasa de éxito del scraping.
Mejores IP proxy estáticas de EE. UU.
IPRoyal es un proveedor de servicios de proxy extremadamente amigable con la región de China; su solución de proxies residenciales es muy atractiva
Ver IPRoyal
El proxy estático más barato
Proxy-seller es un proveedor de proxies de centros de datos, muy popular entre muchos pequeños profesionales del marketing por Internet.
Ver Proxy-seller
El proxy estático más asequible
Shifter.io es un conocido proveedor de servicios de proxy, diseñado para ofrecer a los usuarios protección de la privacidad y una mejor experiencia de Internet.
Ver Shifter.io
2. urllib
Primero tomamos como ejemplo el `urllib` más básico para ver el método de configuración del proxy; el código es el siguiente:
from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener
proxy = '127.0.0.1:7890'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'http://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('https://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)
Los resultados de ejecución son los siguientes:
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Host": "httpbin.org",
"User-Agent": "Python-urllib/3.7",
"X-Amzn-Trace-Id": "Root=1-60e9a1b6-0a20b8a678844a0b2ab4e889"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
Aquí necesitamos usar `ProxyHandler` para configurar el proxy. El parámetro es de tipo diccionario, la clave es el tipo de protocolo y el valor es el proxy. Ten en cuenta que aquí, delante del proxy, hay que añadir el protocolo, es decir, http:// o https://, cuando el enlace solicitado sea del protocolo HTTP, se usará el proxy correspondiente a la clave http; cuando el enlace solicitado sea del protocolo HTTPS, se usará el proxy correspondiente a la clave https. Sin embargo, aquí hemos configurado el proxy en sí como protocolo HTTP, es decir, el prefijo se ha unificado en
http://Por eso, tanto si accedemos a enlaces con protocolo HTTP como HTTPS, las solicitudes se harán usando el proxy HTTP que hemos configurado.
Después de crear el objeto ProxyHandler, necesitamos usar el método build_opener para pasarle ese objeto y crear un Opener; así, ese Opener ya tendrá el proxy configurado. A continuación, basta con llamar directamente al método open del objeto Opener para acceder al enlace que queremos.
El resultado de la ejecución es un JSON con un campo origin, que indica la IP del cliente. Compruébalo: aquí la IP efectivamente es la IP del proxy, no la IP real. Así hemos configurado correctamente el proxy y podemos ocultar la IP real.
Si nos encontramos con un proxy que requiere autenticación, podemos configurarlo de la siguiente manera:
from urllib.error import URLError
from urllib.request import ProxyHandler, build_opener
proxy = 'username:password@127.0.0.1:7890'
proxy_handler = ProxyHandler({
'http': 'http://' + proxy,
'https': 'http://' + proxy
})
opener = build_opener(proxy_handler)
try:
response = opener.open('https://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)
Aquí lo único que cambia es la variable proxy; solo hay que añadir delante del proxy el usuario y la contraseña de autenticación. Aquí username es el nombre de usuario y password es la contraseña. Por ejemplo, si username es foo y la contraseña es bar, entonces el proxy es foo:bar@127.0.0.1:7890。
Si el proxy es de tipo SOCKS5, se puede configurar de la siguiente manera:
import socks
import socket
from urllib import request
from urllib.error import URLError
socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 7891)
socket.socket = socks.socksocket
try:
response = request.urlopen('https://httpbin.org/get')
print(response.read().decode('utf-8'))
except URLError as e:
print(e.reason)
Aquí se necesita un módulo socks, que se puede instalar con el siguiente comando:
pip3 install PySocks
Aquí necesitamos ejecutar localmente un proxy SOCKS5, en el puerto 7891. Después de iniciarse correctamente, el resultado de salida es el mismo que el del proxy HTTP anterior:
{
"args": {},
"headers": {
"Accept-Encoding": "identity",
"Host": "httpbin.org",
"User-Agent": "Python-urllib/3.7",
"X-Amzn-Trace-Id": "Root=1-60e9a1b6-0a20b8a678844a0b2ab4e889"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
El campo origin del resultado también es la IP del proxy; la configuración del proxy se realizó correctamente.
3. Configuración de proxy de requests
Para requests, la configuración del proxy es muy sencilla; solo necesitamos pasar proxies el parámetro.
Tomemos como ejemplo el proxy de mi máquina local para ver la configuración del proxy HTTP en `requests`; el código es el siguiente:
import requests
proxy = '127.0.0.1:7890'
proxies = {
'http': 'http://' + proxy,
'https': 'http://' + proxy,
}
try:
response = requests.get('https://httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)
Los resultados de ejecución son los siguientes:
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5e8f358d-87913f68a192fb9f87aa0323"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
Igual que en urllib, cuando el enlace solicitado usa el protocolo HTTP, se emplea el proxy correspondiente a la clave http; cuando el enlace solicitado usa el protocolo HTTPS, se emplea el proxy correspondiente a la clave https. Sin embargo, aquí se usa de forma unificada el proxy del protocolo HTTP.
en los resultados de ejecución origin Si la IP es la del servidor proxy, significa que el proxy se ha configurado correctamente.
Si el proxy requiere autenticación, basta con añadir el nombre de usuario y la contraseña delante del proxy, y la sintaxis queda así:
proxy = 'username:password@127.0.0.1:7890'
Aquí solo necesitas cambiar username y password Reemplazarlo basta.
Si necesitas usar un proxy SOCKS, puedes configurarlo de la siguiente manera:
import requests
proxy = '127.0.0.1:7891'
proxies = {
'http': 'socks5://' + proxy,
'https': 'socks5://' + proxy
}
try:
response = requests.get('https://httpbin.org/get', proxies=proxies)
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)
Aquí necesitamos instalar un paquete adicional requests[socks]y los comandos relacionados son los siguientes:
pip3 install "requests[socks]"
El resultado de la ejecución es exactamente el mismo:
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5e8f364a-589d3cf2500fafd47b5560f2"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
Además, hay otra forma de configuración: usar el módulo `socks`; también es necesario instalar la biblioteca `socks` como se indica arriba. Este método de configuración es el siguiente:
import requests
import socks
import socket
socks.set_default_proxy(socks.SOCKS5, '127.0.0.1', 7891)
socket.socket = socks.socksocket
try:
response = requests.get('https://httpbin.org/get')
print(response.text)
except requests.exceptions.ConnectionError as e:
print('Error', e.args)
Usar este método también permite configurar un proxy SOCKS, y el resultado es exactamente el mismo. En comparación con el primer método, este es una configuración global. Podemos elegir distintos métodos según cada situación.
4. Configuración de proxy de httpx
El uso de httpx en sí es muy similar al de requests, así que también se configura el proxy mediante el parámetro proxies; pero, a diferencia de requests, la clave del parámetro proxies ya no puede ser http o https, y debe cambiarse a http:// o https://; las demás configuraciones son iguales.
Para un proxy HTTP, el método de configuración es el siguiente:
import httpx
proxy = '127.0.0.1:7890'
proxies = {
'http://': 'http://' + proxy,
'https://': 'http://' + proxy,
}
with httpx.Client(proxies=proxies) as client:
response = client.get('https://httpbin.org/get')
print(response.text)
Para proxies que requieren autenticación, basta con cambiar el valor de proxy:
proxy = 'username:password@127.0.0.1:7890'
Aquí solo necesitas cambiar username y password Reemplazarlo basta.
El resultado de ejecución es similar al de usar requests; el resultado es el siguiente:
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-httpx/0.18.1",
"X-Amzn-Trace-Id": "Root=1-60e9a3ef-5527ff6320484f8e46d39834"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
Para proxies SOCKS, necesitamos instalar la biblioteca `httpx-socks`; el método de instalación es el siguiente:
pip3 install "httpx-socks[asyncio]"
Así se instalará a la vez el soporte para los modos síncrono y asíncrono.
Para el modo síncrono, el método de configuración es el siguiente:
import httpx
from httpx_socks import SyncProxyTransport
transport = SyncProxyTransport.from_url(
'socks5://127.0.0.1:7891')
with httpx.Client(transport=transport) as client:
response = client.get('https://httpbin.org/get')
print(response.text)
Aquí necesitamos configurar un objeto transport y definir la dirección del proxy SOCKS; luego, al declarar el objeto Client de httpx, basta con pasar el parámetro transport. El resultado de ejecución es el mismo que antes.
Para el modo asíncrono, el método de configuración es el siguiente:
import httpx
import asyncio
from httpx_socks import AsyncProxyTransport
transport = AsyncProxyTransport.from_url(
'socks5://127.0.0.1:7891')
async def main():
async with httpx.AsyncClient(transport=transport) as client:
response = await client.get('https://httpbin.org/get')
print(response.text)
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())
A diferencia del modo síncrono, aquí usamos el objeto transport AsyncProxyTransport en lugar de SyncProxyTransport, y además debemos cambiar el objeto Client por AsyncClient; lo demás no cambia, y el resultado de ejecución es el mismo.
5. Configuración de proxy de Selenium
Selenium también puede configurar un proxy; aquí tomamos Chrome como ejemplo para explicar el método de configuración.
Para un proxy sin autenticación, el método de configuración es el siguiente:
from selenium import webdriver
proxy = '127.0.0.1:7890'
options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=http://' + proxy)
browser = webdriver.Chrome(options=options)
browser.get('https://httpbin.org/get')
print(browser.page_source)
browser.close()
Los resultados de ejecución son los siguientes:
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "httpbin.org",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-5e8f39cd-60930018205fd154a9af39cc"
},
"origin": "210.173.1.204",
"url": "http://httpbin.org/get"
}
La configuración del proxy se completó correctamente,origin También es una dirección de IP proxy.
Si el proxy requiere autenticación, el método de configuración es relativamente más engorroso, como se muestra a continuación:
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import zipfile
ip = '127.0.0.1'
port = 7890
username = 'foo'
password = 'bar'
manifest_json = """{"version":"1.0.0","manifest_version": 2,"name":"Chrome Proxy","permissions": ["proxy","tabs","unlimitedStorage","storage","<all_urls>","webRequest","webRequestBlocking"],"background": {"scripts": ["background.js"]
}
}
"""
background_js = """
var config = {
mode: "fixed_servers",
rules: {
singleProxy: {
scheme: "http",
host: "%(ip) s",
port: %(port) s
}
}
}
chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});
function callbackFn(details) {
return {
authCredentials: {username: "%(username) s",
password: "%(password) s"
}
}
}
chrome.webRequest.onAuthRequired.addListener(
callbackFn,
{urls: ["<all_urls>"]},
['blocking']
)
""" % {'ip': ip, 'port': port, 'username': username, 'password': password}
plugin_file = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_file, 'w') as zp:
zp.writestr("manifest.json", manifest_json)
zp.writestr("background.js", background_js)
options = Options()
options.add_argument("--start-maximized")
options.add_extension(plugin_file)
browser = webdriver.Chrome(options=options)
browser.get('https://httpbin.org/get')
print(browser.page_source)
browser.close()
Aquí hay que crear localmente un archivo de configuración manifest.json y un script background.js para configurar el proxy con autenticación. Después de ejecutar el código, se generará localmente un archivo proxy_auth_plugin.zip para guardar la configuración actual.
El resultado de ejecución es coherente con el ejemplo anterior,origin También es una IP de proxy.
La configuración de un proxy SOCKS también es bastante sencilla; basta con cambiar el protocolo correspondiente a socks5 y listo; el método de configuración de un proxy sin autenticación de contraseña es:
from selenium import webdriver
proxy = '127.0.0.1:7891'
options = webdriver.ChromeOptions()
options.add_argument('--proxy-server=socks5://' + proxy)
browser = webdriver.Chrome(options=options)
browser.get('https://httpbin.org/get')
print(browser.page_source)
browser.close()
El resultado de ejecución es el mismo.
6. Configuración de proxy de aiohttp
Para aiohttp, podemos hacerlo mediante proxy y configurar directamente el parámetro. La configuración del proxy HTTP es la siguiente:
import asyncio
import aiohttp
proxy = 'http://127.0.0.1:7890'
async def main():
async with aiohttp.ClientSession() as session:
async with session.get('https://httpbin.org/get', proxy=proxy) as response:
print(await response.text())
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())
Si el proxy tiene nombre de usuario y contraseña, igual que con requests, coloca proxy Modifícalo al siguiente contenido:
proxy = 'http://username:password@127.0.0.1:7890'
Aquí solo necesitas cambiar username y password Reemplazarlo basta.
Para un proxy SOCKS, necesitamos instalar una biblioteca de soporte, `aiohttp-socks`; el comando de instalación es el siguiente:
pip3 install aiohttp-socks
Podemos apoyarnos en `ProxyConnector` de esta biblioteca para configurar el proxy SOCKS; el código es el siguiente:
import asyncio
import aiohttp
from aiohttp_socks import ProxyConnector
connector = ProxyConnector.from_url('socks5://127.0.0.1:7891')
async def main():
async with aiohttp.ClientSession(connector=connector) as session:
async with session.get('https://httpbin.org/get') as response:
print(await response.text())
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())
El resultado de ejecución es el mismo.
Además, esta biblioteca también admite configurar SOCKS4, proxy HTTP y la autenticación correspondiente; puedes consultar su presentación oficial.
7. Configuración de proxy de Pyppeteer
Para Pyppeteer, dado que por defecto utiliza el navegador Chromium, similar a Chrome, su método de configuración es el mismo que el de Chrome en Selenium; por ejemplo, el método de configuración de proxy HTTP sin autenticación se hace mediante args Se configura así; la implementación es la siguiente:
import asyncio
from pyppeteer import launch
proxy = '127.0.0.1:7890'
async def main():
browser = await launch({'args': ['--proxy-server=http://' + proxy], 'headless': False})
page = await browser.newPage()
await page.goto('https://httpbin.org/get')
print(await page.content())
await browser.close()
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())
Los resultados de ejecución son los siguientes:
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate, br",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "httpbin.org",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3494.0 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-5e8f442c-12b1ed7865b049007267a66c"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
También se puede ver que la configuración se realizó correctamente.
Con un proxy SOCKS es igual; solo hay que cambiar el protocolo a socks5 Basta con eso; el código se implementa así:
import asyncio
from pyppeteer import launch
proxy = '127.0.0.1:7891'
async def main():
browser = await launch({'args': ['--proxy-server=socks5://' + proxy], 'headless': False})
page = await browser.newPage()
await page.goto('https://httpbin.org/get')
print(await page.content())
await browser.close()
if __name__ == '__main__':
asyncio.get_event_loop().run_until_complete(main())
El resultado de ejecución también es el mismo.
8. Configuración de proxy de Playwright
En comparación con Selenium y Pyppeteer, la configuración de proxy de Playwright es más cómoda; reserva un parámetro proxy, que se puede configurar al iniciar Playwright.
Para un proxy HTTP, se puede configurar así:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': 'http://127.0.0.1:7890'
})
page = browser.new_page()
page.goto('https://httpbin.org/get')
print(page.content())
browser.close()
Al llamar al método launch, podemos pasar un parámetro proxy, que es un diccionario. El diccionario tiene un campo obligatorio llamado server; aquí basta con rellenar directamente la dirección del proxy HTTP.
Los resultados de ejecución son los siguientes:
{
"args": {},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Accept-Language": "zh-CN,zh;q=0.9",
"Host": "httpbin.org",
"Sec-Ch-Ua": "\" Not A;Brand\";v=\"99\", \"Chromium\";v=\"92\"",
"Sec-Ch-Ua-Mobile": "?0",
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "none",
"Sec-Fetch-User": "?1",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4498.0 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-60e99eef-4fa746a01a38abd469ecb467"
},
"origin": "210.173.1.204",
"url": "https://httpbin.org/get"
}
Para un proxy SOCKS, el método de configuración es exactamente el mismo; solo necesitamos cambiar el valor del campo `server` por la dirección del proxy SOCKS:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': 'socks5://127.0.0.1:7891'
})
page = browser.new_page()
page.goto('https://httpbin.org/get')
print(page.content())
browser.close()
El resultado de ejecución es exactamente el mismo que antes.
Para los proxies con nombre de usuario y contraseña, la configuración de Playwright también es muy sencilla: solo necesitamos añadir los campos username y password en el parámetro proxy. Si el nombre de usuario y la contraseña son foo y bar respectivamente, la configuración es la siguiente:
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={
'server': 'http://127.0.0.1:7890',
'username': 'foo',
'password': 'bar'
})
page = browser.new_page()
page.goto('https://httpbin.org/get')
print(page.content())
browser.close()
Así podemos configurar de forma muy cómoda un proxy autenticado para Playwright.
9. Resumen
Arriba hemos resumido los métodos de uso de proxy en distintas bibliotecas de solicitudes; los métodos de configuración de cada biblioteca son bastante similares. Una vez que domines estos métodos, si más adelante te encuentras con un bloqueo por IP, podrás resolverlo fácilmente añadiendo un proxy.
Mediante el uso de servidores proxy ubicados en distintas posiciones geográficas, se puede simular el rastreo desde diferentes ubicaciones y obtener datos de regiones específicas. Esto es muy útil para tareas que requieren datos relacionados con la geolocalización. Al usar servidores proxy, puedes ocultar la IP real del rastreador, evitando así que los sitios web bloqueen el acceso o limiten la frecuencia. También ayuda a proteger tu privacidad y seguridad. Algunos sitios evitan el rastreo identificando y bloqueando demasiadas solicitudes desde la misma dirección IP. El uso de servidores proxy puede eludir este tipo de mecanismos anti-rastreo, permitiéndote extraer datos con mayor velocidad y una tasa de éxito más alta.
