majiayu000/claude-skill-registry

Metodologia de acesso a conteúdo

Abordagens éticas e legais para acessar conteúdo web restrito para jornalismo e pesquisa.

Hierarquia de acesso (do mais para o menos preferido)

┌─────────────────────────────────────────────────────────────────┐
│              HIERARQUIA DE DECISÃO DE ACESSO A CONTEÚDO         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. TOTALMENTE LEGAL (Sempre tentar primeiro)                  │
│     ├─ Bancos de dados de bibliotecas (PressReader, ProQuest, JSTOR)
│     ├─ Ferramentas de acesso aberto (Unpaywall, CORE, PubMed Central)│
│     ├─ Contato direto com o autor                                │
│     └─ Empréstimo entre bibliotecas                              │
│                                                                  │
│  2. LEGAL (Funcionalidades do navegador)                        │
│     ├─ Modo Leitor (Safari, Firefox, Edge)                      │
│     ├─ Arquivos da Wayback Machine                               │
│     └─ Google Scholar "Todas as versões"                         │
│                                                                  │
│  3. ÁREA CINZENTA (Usar com cautela)                            │
│     ├─ Archive.is para artigos individuais                      │
│     ├─ Desativar JavaScript (quebra funcionalidades)            │
│     └─ VPNs para conteúdo com bloqueio geográfico              │
│                                                                  │
│  4. NÃO RECOMENDADO                                             │
│     ├─ Compartilhamento de credenciais                          │
│     ├─ Raspagem sistemática                                     │
│     └─ Uso comercial de conteúdo contornado                     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Ferramentas de acesso aberto para artigos acadêmicos

Extensão de navegador Unpaywall

Unpaywall encontra cópias gratuitas e legais de mais de 20 milhões de artigos acadêmicos.

# API Unpaywall (gratuita, requer email para identificação)
import requests

def find_open_access(doi: str, email: str) -> dict:
    """Encontra versão de acesso aberto de um artigo usando a API Unpaywall.

    Args:
        doi: Identificador de Objeto Digital (ex.: "10.1038/nature12373")
        email: Seu email para identificação na API

    Returns:
        Dicionário com melhor URL de acesso aberto, se disponível
    """
    url = f"https://api.unpaywall.org/v2/{doi}?email={email}"

    response = requests.get(url, timeout=30)

    if response.status_code != 200:
        return {'error': f'Status {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 em: {result['oa_url']}")

API CORE (295 milhões de artigos)

# API CORE - requer chave de 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:
        """Pesquisa no banco de dados CORE por artigos de acesso aberto."""

        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:
        """Obtém artigo 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 Semantic Scholar (214 milhões de artigos)

# API Semantic Scholar - gratuita, não requer chave para uso básico

import requests

def search_semantic_scholar(query: str, limit: int = 10) -> list:
    """Pesquisa no Semantic Scholar por artigos com links de acesso aberto."""

    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:
    """Obtém detalhes do artigo 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 leitor do navegador para paywalls suaves

Ativando o modo leitor

// Bookmarklet para ativar o modo leitor estilo Firefox
// Funciona em alguns paywalls suaves que carregam conteúdo antes de bloquear

javascript:(function(){
    // Tenta extrair o conteúdo do artigo
    var article = document.querySelector('article') ||
                  document.querySelector('[role="main"]') ||
                  document.querySelector('.article-body') ||
                  document.querySelector('.post-content');

    if (article) {
        // Remove sobreposições de paywall
        document.querySelectorAll('[class*="paywall"], [class*="subscribe"], [id*="paywall"]')
            .forEach(el => el.remove());

        // Remove sobreposições de posição fixa
        document.querySelectorAll('*').forEach(el => {
            var style = getComputedStyle(el);
            if (style.position === 'fixed' && style.zIndex > 100) {
                el.remove();
            }
        });

        // Reativa a rolagem
        document.body.style.overflow = 'auto';
        document.documentElement.style.overflow = 'auto';

        console.log('Sobreposição removida. O conteúdo pode agora estar visível.');
    }
})();

Modo leitor por navegador

Navegador	Como Ativar	Eficácia
Safari	Clique no ícone Leitor na barra de URL	Alta para paywalls suaves
Firefox	Clique no ícone Modo Leitor (ou F9)	Alta
Edge	Clique no ícone Leitor Imersivo	Mais alta
Chrome	Requer flag: chrome://flags/#enable-reader-mode	Média

Acesso a bancos de dados de bibliotecas

Verificando acesso à biblioteca programaticamente

# A maioria dos bancos de dados de bibliotecas requer autenticação
# Isto mostra como estruturar o acesso à API da biblioteca

class LibraryAccess:
    """Padrão de acesso para bancos de dados de bibliotecas."""

    # Endpoints comuns de bancos de dados de bibliotecas
    DATABASES = {
        'pressreader': {
            'base': 'https://www.pressreader.com',
            'auth': 'carteira_de_biblioteca',
            'content': '7000+ jornais/revistas'
        },
        'proquest': {
            'base': 'https://www.proquest.com',
            'auth': 'institucional',
            'content': 'notícias, dissertações, documentos'
        },
        'jstor': {
            'base': 'https://www.jstor.org',
            'auth': 'institucional',
            'content': 'periódicos acadêmicos, livros'
        },
        'nexis_uni': {
            'base': 'https://www.nexisuni.com',
            'auth': 'institucional',
            'content': 'conteúdo jurídico, notícias, negócios'
        }
    }

    @staticmethod
    def get_pressreader_access_methods():
        """Maneiras de acessar PressReader através de bibliotecas."""
        return {
            'in_library': 'Conecte-se ao WiFi da biblioteca, visite pressreader.com',
            'remote': 'Faça login com as credenciais da carteira de biblioteca',
            'app': 'Baixe o aplicativo PressReader, vincule a carteira de biblioteca',
            'note': 'Acesso tipicamente de 30 a 48 horas por sessão'
        }

# Fluxo de trabalho de Empréstimo Entre Bibliotecas (ILL)
def request_via_ill(paper_info: dict, library_email: str) -> str:
    """Gera solicitação de empréstimo entre bibliotecas.

    ILL é gratuito através da maioria das bibliotecas e pode obter quase qualquer artigo.
    Prazo de entrega: normalmente de 3 a 7 dias.
    """

    request = f"""
    SOLICITAÇÃO DE EMPRÉSTIMO ENTRE BIBLIOTECAS

    Título: {paper_info.get('title')}
    Autor(es): {paper_info.get('authors')}
    Periódico: {paper_info.get('journal')}
    Ano: {paper_info.get('year')}
    DOI: {paper_info.get('doi')}
    Volume/Edição: {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 conteúdo com bloqueio geográfico

Quando as VPNs são apropriadas

## Casos de uso legítimos de VPN para jornalistas/pesquisadores

### APROPRIADO:
- Acessar fontes de notícias específicas de uma região
- Pesquisar como o conteúdo aparece em outros países
- Contornar a censura governamental (em alguns contextos)
- Proteger comunicações de fontes
- Verificar conteúdo direcionado geograficamente

### INAPROPRIADO:
- Contornar controles de acesso legítimos
- Acessar conteúdo que você está contratualmente proibido de visualizar
- Evitar banimentos ou bloqueios colocados em sua conta

Comparação de serviços VPN

Serviço	Melhor Para	Privacidade	Velocidade	Preço
ExpressVPN	Contorno de censura	Excelente	Rápida	$$$
NordVPN	Uso geral	Excelente	Rápida	$$
Surfshark	Orçamento, dispositivos ilimitados	Boa	Boa	$
ProtonVPN	Foco em privacidade	Excelente	Média	$$
Tor Browser	Máximo anonimato	Excelente	Lenta	Gratuito

Verificando status de restrição geográfica

import requests

def check_geo_access(url: str, regions: list = None) -> dict:
    """Verifica se a URL está acessível de diferentes regiões.

    Nota: Isso requer serviços VPN/proxy para testes reais.
    Esta função mostra o conceito.
    """

    regions = regions or ['US', 'UK', 'EU', 'JP', 'AU']

    results = {}

    # Teste de acesso direto
    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)}

    # Seria necessária integração VPN/proxy para testes regionais
    # results[region] = test_through_proxy(url, region)

    return results

Acesso baseado em arquivo

Usando Archive.today para artigos com paywall

import requests
from urllib.parse import quote

def get_archived_article(url: str) -> str:
    """Tenta obter artigo do Archive.today.

    O Archive.today frequentemente captura o conteúdo completo do artigo
    porque renderiza JavaScript e captura o resultado.

    O status legal varia por jurisdição - use para fins de pesquisa.
    """

    # Verifica arquivo existente
    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

        # Nenhum arquivo existente - poderia solicitar um
        # Nota: Isso pode violar os Termos de Serviço, use com responsabilidade
        return None

    except Exception:
        return None

Wayback Machine para acesso histórico

def get_wayback_article(url: str) -> str:
    """Obtém artigo da Wayback Machine.

    100% legal - o Internet Archive é uma biblioteca reconhecida.
    Pode ter versões mais antigas de artigos (antes da implementação do paywall).
    """

    # Verifica disponibilidade
    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

Estratégias do Google Scholar

Encontrando versões gratuitas

def find_free_via_scholar(title: str) -> list:
    """Estratégias de pesquisa para encontrar versões gratuitas de artigos.

    O Google Scholar frequentemente vincula a:
    - Cópias em sites pessoais dos autores
    - Versões em repositórios institucionais
    - ResearchGate/Academia.edu
    """

    # Estratégia de pesquisa 1: Título + "PDF"
    queries = [
        f'{title} filetype:pdf',
        f'{title} "free access"',
        f'{title} "preprint"',
        f'{title} "author version"'