Baixar imagem da internet para o seu app: o que você pode usar e como guardar a prova

O catálogo do app de receitas precisava de fotos, e alguém escreveu um job em Java que buscava "bolo de cenoura" num site, baixava a primeira imagem e salvava em /var/app/imagens. Funcionou perfeitamente. Três meses depois chegou um e-mail de uma fotógrafa com o print da foto dela no app, o link do portfólio e um valor de licenciamento retroativo. A resposta curta: imagem acessível na internet não é imagem livre. Para hospedar no seu servidor, você precisa ter feito a imagem, ter licença para ela ou usá-la nos termos que o dono oferece. Se não tem, use a incorporação ou API oficial do dono, ou só faça um link. E guarde a origem e a licença junto do arquivo no dia do download.

O código que baixa é a parte fácil. A parte que dá problema é o que acontece depois que o arquivo chega ao seu disco.

Por que "estava público" não resolve

No Brasil, foto, ilustração e desenho são obras protegidas pela Lei de Direitos Autorais (Lei 9.610/1998) desde a criação, sem precisar de registro. Publicar na internet não abre mão desse direito. Copiar para o seu servidor e servir para os seus usuários é reprodução e distribuição, e isso depende de autorização.

Quando a foto mostra uma pessoa, entra uma segunda camada: o direito de imagem de quem aparece, protegido pela Constituição e pelo Código Civil. E rosto identificável é dado pessoal na LGPD. Um job que raspa fotos de perfil para "ilustrar" depoimentos junta os três problemas de uma vez.

Há ainda o problema prático. O arquivo pode carregar metadados EXIF com localização, modelo do celular e data, coisa que o autor talvez nem saiba que publicou (veja foto do celular com endereço). E sem registro de origem, ninguém no time consegue responder, um ano depois, de onde veio cada imagem.

Quatro caminhos, do mais seguro ao mais arriscado

1. A imagem é sua

Foto tirada pelo time, ilustração encomendada com contrato que cede os direitos de uso, foto de produto feita pelo fornecedor com autorização expressa. Hospede à vontade e registre a autoria.

2. A imagem tem licença que permite o seu uso

Banco de imagens pago, licença Creative Commons compatível com o uso, acervo em domínio público. Leia a licença: algumas exigem crédito, outras proíbem uso comercial ou modificação. Guarde a página da licença e a data, porque termos mudam.

3. O dono oferece incorporação ou API

Muitas plataformas oferecem código de incorporação ou API com termos próprios. A imagem continua servida pelo dono, que mantém controle e crédito. Siga os termos da API, inclusive limites e exigências de atribuição, e lembre que incorporar conteúdo de terceiro faz o navegador do visitante falar com esse terceiro.

4. Nenhum dos anteriores

Não baixe. Escreva sobre o conteúdo e faça um link para a página original. É menos bonito e é o que você tem direito de fazer.

Como baixar de fonte autorizada guardando a prova

No app de receitas, a solução foi contratar um banco de imagens e baixar só do domínio dele, gravando um arquivo de licença ao lado de cada imagem. O job em Java usa o HttpClient do JDK, recusa hosts fora da lista, confere status e tipo, e só mantém o arquivo se tudo estiver certo:

import java.io.IOException;
import java.io.Writer;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.time.Instant;
import java.util.Properties;
import java.util.Set;

public final class BaixarImagemLicenciada {
    private static final Set<String> HOSTS_PERMITIDOS = Set.of("img.banco-exemplo.com");

    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NEVER)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

    public static Path baixar(String url, Path pasta, String nome, String licenca, String autor)
            throws IOException, InterruptedException {
        URI uri = URI.create(url);
        if (!"https".equals(uri.getScheme()) || !HOSTS_PERMITIDOS.contains(uri.getHost())) {
            throw new IllegalArgumentException("Origem não autorizada: " + uri.getHost());
        }

        Path destino = pasta.resolve(nome + ".jpg");
        Path temporario = Files.createTempFile(pasta, "download-", ".tmp");
        try {
            HttpRequest req = HttpRequest.newBuilder(uri)
                    .timeout(Duration.ofSeconds(30))
                    .GET()
                    .build();
            HttpResponse<Path> resp = CLIENT.send(req, HttpResponse.BodyHandlers.ofFile(temporario));

            String tipo = resp.headers().firstValue("Content-Type").orElse("");
            if (resp.statusCode() != 200 || !tipo.startsWith("image/jpeg")) {
                throw new IOException("Resposta inesperada: " + resp.statusCode() + " " + tipo);
            }
            Files.move(temporario, destino);
        } finally {
            Files.deleteIfExists(temporario);
        }

        Properties p = new Properties();
        p.setProperty("origem", url);
        p.setProperty("autor", autor);
        p.setProperty("licenca", licenca);
        p.setProperty("baixado_em", Instant.now().toString());
        try (Writer w = Files.newBufferedWriter(pasta.resolve(nome + ".licenca.properties"))) {
            p.store(w, "Licença da imagem " + nome);
        }
        return destino;
    }
}

Algumas decisões aqui são de propósito. Redirecionamento desligado e lista de hosts impedem que uma URL "do banco" leve o job a baixar de outro lugar. O arquivo temporário evita deixar meia imagem na pasta se a conexão cair. E o .licenca.properties ao lado do arquivo responde ao e-mail da fotógrafa em segundos: origem, autor, licença e data. A ideia de manter a licença na mesma pasta é detalhada em guarde a licença da imagem na mesma pasta; para os detalhes de download robusto em Java (threads, tamanho máximo, URL não confiável), veja baixar uma imagem em Java.

Se você processar a imagem depois (redimensionar, converter), remova os metadados EXIF de localização, mas mantenha o crédito do autor no seu registro. Apagar metadado para fingir que a origem sumiu não muda de quem é a obra.

Erros comuns

• "Estava no Google Imagens". O buscador mostra a imagem, não concede licença. Você responde pela cópia no seu servidor.
• Raspar fotos de pessoas. Junta direito autoral, direito de imagem e dado pessoal num só problema.
• Licença guardada na memória de alguém. Quando a pessoa sai do time, ninguém prova que a imagem foi comprada.
• Ignorar a exigência de crédito. Muitas licenças livres só valem com atribuição; sem crédito, o uso deixa de estar coberto.
• Seguir redirecionamento para qualquer host. O job baixa conteúdo de origem desconhecida e você nem sabe de onde veio.
• Remover metadados de autoria. Além de não resolver a questão de direito, apaga a pista que ajudaria a regularizar.

Checklist

• Cada imagem do app tem origem identificada: própria, licenciada, incorporada ou nenhuma.
• Imagens licenciadas têm arquivo de licença com origem, autor, licença e data.
• O job de download aceita só hosts de fontes autorizadas.
• Fotos com pessoas identificáveis têm autorização de uso de imagem.
• Créditos exigidos pelas licenças aparecem no app.
• Metadados de localização são removidos no processamento.
• Existe um caminho para responder a uma reclamação de autoria.

Este texto explica o mecanismo e não substitui a orientação de um advogado para o seu caso concreto.

Escolha cinco imagens ao acaso na pasta de uploads do seu app: para cada uma, você consegue mostrar agora de onde ela veio e qual licença permite usá-la?