API de IA sem censura para codificação: configuração, custo e limites
Pensando em usar a API DeepSeek para codificação com um endpoint que não recusa perguntas de segurança ou scraping? Este serviço não é a API oficial da DeepSeek, mas é um endpoint compatível com OpenAI para um único modelo de pesos abertos sem censura, e ele lida com tarefas de código através das mesmas chamadas de chat.
Atualizado
Pontos principais
- O ID do modelo é
uncensored, a base URL é https://api.getdeepseekapi.com/v1, e qualquer SDK OpenAI funciona. - Recusas são mais importantes para testes de segurança, engenharia reversa, scraping e análise de malware, tudo para uso legal.
- Uma revisão de base de código de 50.000 tokens custa menos de um centavo na entrada; uma execução de agente com 30 etapas custa cerca de 19 centavos.
- Chamada de funções, modo JSON e streaming são suportados, com uma janela de contexto de 100.000 tokens.

O que este endpoint é, e o que não é
A consulta menciona o DeepSeek, então um rápido esclarecimento. Este serviço não é a API oficial do DeepSeek e não encaminha para o DeepSeek ou qualquer outro fornecedor. Ele executa um único modelo de pesos abertos por meio de um provedor independente, ajustado para responder sem recusas de conteúdo para uso adulto lícito. Você o chama como o modelo uncensored em https://api.getdeepseekapi.com/v1, usando o mesmo formato de solicitação das SDKs da OpenAI. Se você veio pelos próprios modelos do DeepSeek, use o DeepSeek diretamente e consulte a documentação deles.
Por que usar um modelo sem filtros para código? A maioria das perguntas de programação nunca aciona uma recusa em qualquer modelo. Mas algumas tarefas legais são bloqueadas ou suavizadas por filtros: escrever um scanner de portas para sua própria rede, analisar uma amostra de binário suspeita, fazer fuzzing na sua própria API, construir um scraper, explicar como uma classe de exploit funciona para que você possa corrigi-la. Um modelo ajustado para responder diretamente a isso economiza o tempo que você gastaria reformulando. Isso não melhora o código, e não remove sua responsabilidade de usá-lo legalmente. Limite rígido: nada envolvendo conteúdo sexual com menores de idade, nunca.
Configuração em dois minutos
Crie uma conta (Google, ou email e senha) e acesse a página da chave de API. Novos usuários podem reivindicar $0,50 de crédito de teste com um clique. É válido por 7 dias, não precisa de cartão e é um por pessoa. Depois, instale o SDK e faça uma primeira chamada.
pip install openai
export UNCENSORED_API_KEY="paste-your-key-here"
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.getdeepseekapi.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
temperature=0.2,
messages=[
{"role": "system", "content": "You are a senior engineer. Answer with code first, then a short explanation."},
{"role": "user", "content": "Write a Python function that scans TCP ports 1-1024 on a host I own, using asyncio."},
],
)
print(resp.choices[0].message.content)
Uma temperatura baixa, entre 0,0 e 0,3, é adequada para código. Defina uma temperatura mais alta apenas quando quiser alternativas variadas para brainstorming.
Revisão de código em um arquivo inteiro ou repositório pequeno
Alguns hábitos de prompt tornam as respostas de código melhores em qualquer modelo. Nomeie a linguagem e a versão, cole o texto exato do erro em vez de descrevê-lo, e diga o que você já tentou. Peça um diff ou uma única função em vez de uma reescrita do arquivo inteiro, porque respostas curtas são mais baratas e mais fáceis de revisar. Quando a tarefa é grande, divida-a: uma requisição para planejar, uma segunda para escrever cada parte. Isso também mantém cada prompt bem dentro da janela e permite que você execute partes independentes em paralelo, até o limite de concorrência.
A janela de 100.000 tokens (prompt mais conclusão) permite colar muito código-fonte em uma única requisição. Aproximadamente, 1.000 linhas de código típico são de 10.000 a 15.000 tokens, mas meça com o campo de uso em vez de confiar em uma regra.
O modo JSON torna a saída da revisão legível por máquina. Peça uma forma fixa e analise-a.
import json, pathlib
source = pathlib.Path("app.py").read_text()
r = client.chat.completions.create(
model="uncensored",
temperature=0.1,
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Review code. Return JSON: {\"issues\": [{\"line\": int, \"severity\": \"low|medium|high\", \"problem\": str, \"fix\": str}]}"},
{"role": "user", "content": source},
],
)
for issue in json.loads(r.choices[0].message.content)["issues"]:
print(issue["severity"], issue["line"], issue["problem"])
print(r.usage)
O modo JSON garante sintaxe válida, não suas chaves exatas, então verifique se os campos existem antes de usá-los. Os custos são pequenos. Enviar uma base de código de 50.000 tokens e receber 2.000 tokens de volta custa 50.000 x 0,15 / 1.000.000 = $0,0075 para entrada mais 2.000 x 0,50 / 1.000.000 = $0,001 para saída, totalizando $0,0085.
Onde as recusas realmente aparecem no trabalho de codificação
É útil ser concreto, porque um modelo filtrado que recusa algo inofensivo não é o mesmo que um que recusa algo perigoso. Estas são tarefas legais que os desenvolvedores relatam encontrar atrito em outros lugares, então teste-as em qualquer modelo que você use:
- Testes de segurança de sistemas que você possui ou tem permissão para testar: scanners, fuzzers, código de prova de conceito para confirmar se um patch funciona.
- Engenharia reversa e análise de malware: explicando o que uma rotina descompilada faz.
- Scraping e automação: lidando com logins, limites de taxa e comportamento anti-bot em suas próprias contas.
- Escrever regras de detecção, o que significa entender como o ataque funciona primeiro.
- Modificação de jogos e ferramentas de emulação que tocam proteção de cópia de maneiras incomuns.
A responsabilidade não muda. Se você usar a saída contra sistemas para os quais não tem permissão para testar, isso é com você. O ponto de um modelo sem filtros é que ele trata você como um adulto que tem um motivo para perguntar, não que torna qualquer uso aceitável.
Chamada de funções para um pequeno agente de codificação
A chamada de funções permite que o modelo solicite ações como executar testes. Você define funções em tools, lê tool_calls da resposta, as executa você mesmo e envia os resultados de volta com role: "tool". Aqui está um loop compacto que pode executar um comando de teste e ler a saída.
import json, subprocess
tools = [{
"type": "function",
"function": {
"name": "run_tests",
"description": "Run the project's test suite and return the output",
"parameters": {"type": "object", "properties": {}, "required": []},
},
}]
messages = [
{"role": "system", "content": "Fix failing tests. Call run_tests, then explain the cause."},
{"role": "user", "content": "The tests in this repo fail. Find out why."},
]
for step in range(6):
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, temperature=0.2)
msg = r.choices[0].message
messages.append(msg)
if not msg.tool_calls:
print(msg.content)
break
for call in msg.tool_calls:
out = subprocess.run(["pytest", "-x", "-q"], capture_output=True, text=True, timeout=120)
messages.append({"role": "tool", "tool_call_id": call.id, "content": (out.stdout + out.stderr)[-4000:]})
Limitar a saída da ferramenta aos últimos 4.000 caracteres mantém o contexto e o custo sob controle. Sempre defina um limite rígido para as etapas do loop e execute comandos do shell apenas dentro de um sandbox ou de um diretório que você possa perder. Para ferramentas prontas para editor e terminal, muitas aceitam uma URL base compatível com OpenAI; a documentação de integração lista os parâmetros suportados.
Quanto custa uma sessão de agente
Agentes são precificados por repetição. Cada etapa reenvia o contexto, então os tokens de entrada dominam. As taxas são $0,15 por 1M tokens de entrada e $0,50 por 1M tokens de saída.
Suponha que uma sessão execute 30 etapas, enviando cerca de 40.000 tokens de contexto e retornando cerca de 500 tokens.
- Entrada: 30 x 40.000 = 1.200.000 tokens, então 1,2 x $0,15 = $0,18
- Saída: 30 x 500 = 15.000 tokens, então 0,015 x $0,50 = $0,0075
- Total: $0,1875
A essa taxa, $20 de crédito cobrem mais de 100 dessas sessões. O crédito é pré-pago, nunca expira e não há assinatura. Recarregue com qualquer valor inteiro de $20 a $500 por cripto (USDT na TRC20, USDC na Base), com bônus de +5% a partir de $50, +10% a partir de $100 e +15% a partir de $200. Requisições falhas ou recusadas não são cobradas. Os detalhes estão na página de preços.
Limites e ressalvas honestas
Uma chave completa permite 8 requisições simultâneas e 300 por minuto; uma chave de teste permite 2 e 60. Executando testes em paralelo em vários arquivos? Limite seu pool de workers a 8. Acima do limite, a API retorna 429: rate_limited para requisições por minuto e concurrency para muitos ao mesmo tempo. Uma sobrecarga temporária retorna 429 com Retry-After: 5. Uma requisição streaming ocupa sua vaga até o fim do streaming, então feche os streams que você não precisa mais.
Agora as ressalvas. Não publicamos benchmarks, e você não deve assumir que este modelo supera qualquer outro em qualidade de codificação. É um modelo de pesos abertos geral ajustado para não recusar, não um modelo de código especializado. Teste-o em uma amostra das suas próprias tarefas e compare com o que você usa agora. É apenas texto e o limite do corpo é 8 MB, então você não pode enviar binários grandes. Prompts não são usados para treinamento, o que importa quando o código é privado. Se você quiser o contexto mais amplo deste serviço, a visão geral da alternativa DeepSeek explica como ela difere das APIs de fornecedores.
Mais guias
Perguntas e respostas
Esta é a API oficial do DeepSeek?
Não. É um serviço separado que executa um único modelo de pesos abertos independente, ID uncensored, por trás de uma API compatível com OpenAI.
Ele suporta chamada de funções para agentes de codificação?
Sim. Use tools e tool_choice, processe tool_calls na resposta e retorne os resultados como mensagens de role tool. Chamadas de funções em streaming também funcionam.
Qual o tamanho máximo de um codebase que posso enviar?
A janela de contexto é de 100.000 tokens para prompt mais conclusão, e o corpo da requisição pode ter até 8 MB. Verifique o uso de tokens na resposta.
Quanto custa uma revisão de código?
Uma entrada de 50.000 tokens com 2.000 tokens de saída custa $0,0085, a uma taxa de $0,15 e $0,50 por 1 milhão de tokens.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.