Metodología de acceso a contenido
Enfoques éticos y legales para acceder a contenido web restringido para periodismo e investigación.
Jerarquía de acceso (de más a menos preferido)
┌─────────────────────────────────────────────────────────────────┐
│ JERARQUÍA DE DECISIÓN DE ACCESO A CONTENIDO │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. COMPLETAMENTE LEGAL (Probar siempre primero) │
│ ├─ Bases de datos de bibliotecas (PressReader, ProQuest, JSTOR)│
│ ├─ Herramientas de acceso abierto (Unpaywall, CORE, PubMed Central)│
│ ├─ Contacto directo con el autor │
│ └─ Préstamo interbibliotecario │
│ │
│ 2. LEGAL (Funcionalidades del navegador) │
│ ├─ Modo lectura (Safari, Firefox, Edge) │
│ ├─ Archivos de Wayback Machine │
│ └─ Google Scholar "Todas las versiones" │
│ │
│ 3. ÁREA GRIS (Usar con precaución) │
│ ├─ Archive.is para artículos individuales │
│ ├─ Deshabilitar JavaScript (rompe funcionalidad) │
│ └─ VPNs para contenido con bloqueo geográfico │
│ │
│ 4. NO RECOMENDADO │
│ ├─ Compartir credenciales │
│ ├─ Scraping sistemático │
│ └─ Uso comercial de contenido evadido │
│ │
└─────────────────────────────────────────────────────────────────┘
Herramientas de acceso abierto para artículos académicos
Extensión de navegador Unpaywall
Unpaywall encuentra copias gratuitas y legales de más de 20 millones de artículos académicos.
# API de Unpaywall (gratuita, requiere correo electrónico para identificación)
import requests
def find_open_access(doi: str, email: str) -> dict:
"""Encuentra la versión de acceso abierto de un artículo usando la API de Unpaywall.
Args:
doi: Identificador de Objeto Digital (ej., "10.1038/nature12373")
email: Tu correo electrónico para identificación de la API
Returns:
Dict con la mejor URL de acceso abierto si está disponible
"""
url = f"https://api.unpaywall.org/v2/{doi}?email={email}"
response = requests.get(url, timeout=30)
if response.status_code != 200:
return {'error': f'Estado {response.status_code}'}
data = response.json()
if data.get('is_oa'):
best_location = data.get('best_oa_location', {})
return {
'is_open_access': True,
'oa_url': best_location.get('url_for_pdf') or best_location.get('url'),
'oa_status': data.get('oa_status'), # gold, green, bronze, hybrid
'host_type': best_location.get('host_type'), # publisher, repository
'version': best_location.get('version') # publishedVersion, acceptedVersion
}
return {
'is_open_access': False,
'title': data.get('title'),
'journal': data.get('journal_name')
}
# Uso
result = find_open_access("10.1038/nature12373", "[email protected]")
if result.get('is_open_access'):
print(f"PDF gratuito en: {result['oa_url']}")
API de CORE (295 millones de artículos)
# API de CORE - requiere clave API gratuita de https://core.ac.uk/
import requests
class CORESearch:
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.core.ac.uk/v3"
def search(self, query: str, limit: int = 10) -> list:
"""Busca en la base de datos de CORE artículos de acceso abierto."""
headers = {'Authorization': f'Bearer {self.api_key}'}
params = {
'q': query,
'limit': limit
}
response = requests.get(
f"{self.base_url}/search/works",
headers=headers,
params=params,
timeout=30
)
if response.status_code != 200:
return []
data = response.json()
results = []
for item in data.get('results', []):
results.append({
'title': item.get('title'),
'authors': [a.get('name') for a in item.get('authors', [])],
'year': item.get('yearPublished'),
'doi': item.get('doi'),
'download_url': item.get('downloadUrl'),
'abstract': item.get('abstract', '')[:500]
})
return results
def get_by_doi(self, doi: str) -> dict:
"""Obtiene un artículo por DOI."""
headers = {'Authorization': f'Bearer {self.api_key}'}
response = requests.get(
f"{self.base_url}/works/{doi}",
headers=headers,
timeout=30
)
return response.json() if response.status_code == 200 else {}
API de Semantic Scholar (214 millones de artículos)
# API de Semantic Scholar - gratuita, no requiere clave para uso básico
import requests
def search_semantic_scholar(query: str, limit: int = 10) -> list:
"""Busca en Semantic Scholar artículos con enlaces de acceso abierto."""
url = "https://api.semanticscholar.org/graph/v1/paper/search"
params = {
'query': query,
'limit': limit,
'fields': 'title,authors,year,abstract,openAccessPdf,citationCount'
}
response = requests.get(url, params=params, timeout=30)
if response.status_code != 200:
return []
results = []
for paper in response.json().get('data', []):
oa_pdf = paper.get('openAccessPdf', {})
results.append({
'title': paper.get('title'),
'authors': [a.get('name') for a in paper.get('authors', [])],
'year': paper.get('year'),
'citations': paper.get('citationCount', 0),
'open_access_url': oa_pdf.get('url') if oa_pdf else None,
'abstract': paper.get('abstract', '')[:500] if paper.get('abstract') else ''
})
return results
def get_paper_by_doi(doi: str) -> dict:
"""Obtiene detalles de un artículo por DOI."""
url = f"https://api.semanticscholar.org/graph/v1/paper/DOI:{doi}"
params = {
'fields': 'title,authors,year,abstract,openAccessPdf,references,citations'
}
response = requests.get(url, params=params, timeout=30)
return response.json() if response.status_code == 200 else {}
Modo lectura del navegador para muros de pago suaves
Activación del modo lectura
// Marcador para activar el modo lectura estilo Firefox
// Funciona en algunos muros de pago suaves que cargan el contenido antes de bloquearlo
javascript:(function(){
// Intentar extraer el contenido del artículo
var article = document.querySelector('article') ||
document.querySelector('[role="main"]') ||
document.querySelector('.article-body') ||
document.querySelector('.post-content');
if (article) {
// Eliminar superposiciones de muro de pago
document.querySelectorAll('[class*="paywall"], [class*="subscribe"], [id*="paywall"]')
.forEach(el => el.remove());
// Eliminar superposiciones de posición fija
document.querySelectorAll('*').forEach(el => {
var style = getComputedStyle(el);
if (style.position === 'fixed' && style.zIndex > 100) {
el.remove();
}
});
// Reactivar el desplazamiento
document.body.style.overflow = 'auto';
document.documentElement.style.overflow = 'auto';
console.log('Superposición eliminada. El contenido puede ser visible ahora.');
}
})();
Modo lectura por navegador
| Navegador | Cómo activarlo | Efectividad |
|---|---|---|
| Safari | Haz clic en el icono de Lector en la barra de URL | Alta para muros de pago suaves |
| Firefox | Haz clic en el icono de Vista de Lector (o F9) | Alta |
| Edge | Haz clic en el icono de Lector Inmersivo | La más alta |
| Chrome | Requiere flag: chrome://flags/#enable-reader-mode | Media |
Acceso a bases de datos de bibliotecas
Verificación de acceso a bibliotecas mediante programación
# La mayoría de las bases de datos de bibliotecas requieren autenticación
# Esto muestra cómo estructurar el acceso a la API de la biblioteca
class LibraryAccess:
"""Patrón de acceso para bases de datos bibliotecarias."""
# Endpoints comunes de bases de datos bibliotecarias
DATABASES = {
'pressreader': {
'base': 'https://www.pressreader.com',
'auth': 'library_card',
'content': '7000+ periódicos/revistas'
},
'proquest': {
'base': 'https://www.proquest.com',
'auth': 'institutional',
'content': 'noticias, tesis, documentos'
},
'jstor': {
'base': 'https://www.jstor.org',
'auth': 'institutional',
'content': 'revistas académicas, libros'
},
'nexis_uni': {
'base': 'https://www.nexisuni.com',
'auth': 'institutional',
'content': 'legal, noticias, negocios'
}
}
@staticmethod
def get_pressreader_access_methods():
"""Formas de acceder a PressReader a través de bibliotecas."""
return {
'in_library': 'Conéctate al WiFi de la biblioteca, visita pressreader.com',
'remote': 'Inicia sesión con credenciales de tarjeta de biblioteca',
'app': 'Descarga la aplicación PressReader, vincula la tarjeta de biblioteca',
'note': 'El acceso típicamente dura 30-48 horas por sesión'
}
# Flujo de trabajo de Préstamo Interbibliotecario (PIB)
def request_via_ill(paper_info: dict, library_email: str) -> str:
"""Genera una solicitud de préstamo interbibliotecario.
El PIB es gratuito en la mayoría de las bibliotecas y puede conseguir casi cualquier artículo.
Tiempo de respuesta: típicamente de 3 a 7 días.
"""
request = f"""
SOLICITUD DE PRÉSTAMO INTERBIBLIOTECARIO
Título: {paper_info.get('title')}
Autor(es): {paper_info.get('authors')}
Revista: {paper_info.get('journal')}
Año: {paper_info.get('year')}
DOI: {paper_info.get('doi')}
Volumen/Número: {paper_info.get('volume')}/{paper_info.get('issue')}
Páginas: {paper_info.get('pages')}
Solicitado por: {library_email}
"""
return request.strip()
Uso de VPN para contenido con bloqueo geográfico
Cuándo son apropiadas las VPN
## Casos de uso legítimos de VPN para periodistas/investigadores
### APROPIADO:
- Acceder a fuentes de noticias específicas de una región
- Investigar cómo aparece el contenido en otros países
- Evitar la censura gubernamental (en algunos contextos)
- Proteger las comunicaciones de las fuentes
- Verificar contenido dirigido geográficamente
### INAPROPIADO:
- Eludir controles de acceso legítimos
- Acceder a contenido que tienes prohibido contractualmente ver
- Evitar prohibiciones o bloqueos en tu cuenta
Comparación de servicios VPN
| Servicio | Mejor para | Privacidad | Velocidad | Precio |
|---|---|---|---|---|
| ExpressVPN | Evasión de censura | Excelente | Rápida | $$$ |
| NordVPN | Uso general | Excelente | Rápida | $$ |
| Surfshark | Económico, dispositivos ilimitados | Buena | Buena | $ |
| ProtonVPN | Enfoque en privacidad | Excelente | Media | $$ |
| Tor Browser | Anonimato máximo | Excelente | Lenta | Gratis |
Verificación del estado de restricción geográfica
import requests
def check_geo_access(url: str, regions: list = None) -> dict:
"""Verifica si una URL es accesible desde diferentes regiones.
Nota: Esto requiere servicios VPN/proxy para pruebas reales.
Esta función muestra el concepto.
"""
regions = regions or ['US', 'UK', 'EU', 'JP', 'AU']
results = {}
# Prueba de acceso directo
try:
response = requests.get(url, timeout=10)
results['direct'] = {
'accessible': response.status_code == 200,
'status_code': response.status_code
}
except Exception as e:
results['direct'] = {'accessible': False, 'error': str(e)}
# Se necesitaría integración VPN/proxy para pruebas regionales
# results[region] = test_through_proxy(url, region)
return results
Acceso basado en archivos
Uso de Archive.today para artículos con muro de pago
import requests
from urllib.parse import quote
def get_archived_article(url: str) -> str:
"""Intenta obtener el artículo de Archive.today.
Archive.today a menudo captura el contenido completo del artículo
porque renderiza JavaScript y captura el resultado.
El estado legal varía según la jurisdicción: úsalo con fines de investigación.
"""
# Verificar si existe un archivo
search_url = f"https://archive.today/{quote(url, safe='')}"
try:
response = requests.get(search_url, timeout=30, allow_redirects=True)
if response.status_code == 200 and 'archive.today' in response.url:
return response.url
# No existe archivo - se podría solicitar uno
# Nota: Esto puede violar los Términos de Servicio, úsalo responsablemente
return None
except Exception:
return None
Wayback Machine para acceso histórico
def get_wayback_article(url: str) -> str:
"""Obtiene el artículo de Wayback Machine.
100% legal - Internet Archive es una biblioteca reconocida.
Puede tener versiones antiguas de artículos (antes de implementar el muro de pago).
"""
# Verificar disponibilidad
api_url = f"http://archive.org/wayback/available?url={url}"
try:
response = requests.get(api_url, timeout=10)
data = response.json()
snapshot = data.get('archived_snapshots', {}).get('closest', {})
if snapshot.get('available'):
return snapshot['url']
return None
except Exception:
return None
Estrategias de Google Scholar
Encontrar versiones gratuitas
def find_free_via_scholar(title: str) -> list:
"""Estrategias de búsqueda para encontrar versiones gratuitas de artículos.
Google Scholar a menudo enlaza a:
- Copias en sitios web personales de autores
- Versiones en repositorios institucionales
- ResearchGate/Academia
...