Verifique tarefas do X (Twitter) no Galxe, Zealy e TaskOn

#Como Galxe, Zealy e TaskOn verificam tarefas do X

As três plataformas verificam tarefas do X pela conta do X que o participante conecta, e cada uma raciona essas verificações do seu jeito: o Galxe com créditos de verificação, o Zealy com planos pagos e créditos de claim, o TaskOn com um conjunto fixo de tipos de tarefa.

Antes de uma quest entrar no ar, o Verificador de follow do Twitter gratuito mostra se uma conta segue outra, nos dois sentidos, para você testar sua tarefa de follow à mão. A tabela compara o que cada plataforma faz por conta própria.

• Tarefas nativas do X

  Galxe

  Follow, retweet, quote, post com palavras-chave

  Zealy

  Follow, post, resposta, retweet, curtida, quote, Space

  TaskOn

  Follow, retweet, curtida, quote com hashtag ou menções, post

• A ação é confirmada?

  Galxe

  Só com a Authentic Verification ligada; por padrão, um clique conta

  Zealy

  Sim, pela conta conectada

  TaskOn

  Sim, pela conta conectada

• Quanto custam as verificações do X

  Galxe

  10 créditos por verificação, a partir do Rewards Hub Nível 2 ou do Business+

  Zealy

  1 a 3 créditos de claim por ação, só em planos pagos

  TaskOn

  Incluídas no plano Quest

• Rota própria para o seu servidor

  Galxe

  Credencial REST

  Zealy

  API task

  TaskOn

  Completion-Based API Task

No Galxe, uma tarefa do X não é confirmada por padrão. Toda credencial do X começa com a Authentic Verification desligada e usa o método "Page Visit", que registra que o participante abriu o link, não que seguiu ou repostou (Galxe: Create Quest, Tasks Settings (abre em uma nova aba)). Com a Authentic Verification ligada, cada verificação de follow, retweet ou quote gasta 10 créditos: o Rewards Hub Nível 2 recebe 10 mil créditos, o Nível 3 recebe 40 mil e o Nível 4 recebe 80 mil, e o Galxe desliga a verificação quando eles acabam (Galxe: X Authentic Verification Credits (abre em uma nova aba)). Curtidas não podem ser habilitadas para verificação.

A tarefa do X do Zealy verifica cinco ações a partir da conta conectada do participante, e cada ação soma créditos de claim ao 1 crédito que cada claim custa: um follow, post, quote ou resposta soma 1, um retweet soma 2 e uma curtida soma 3 (Zealy: Twitter task (abre em uma nova aba)). As tarefas do X vêm só nos planos pagos, a partir de US$ 149 por mês cobrados anualmente, e créditos além da franquia mensal de um plano custam US$ 15 por 1.000 no Standard (preços do Zealy (abre em uma nova aba)).

O TaskOn tem sete tipos de tarefa do X dentro do plano Quest, US$ 199 por mês cobrados a cada seis meses. Ele não tem verificação de resposta nem de Community, e a ajuda para participantes pede a quem falha na verificação do X que espere 15 minutos e verifique uma tarefa por vez.

#Verifique tarefas do X no seu próprio servidor com a Sorsa API

Para confirmar tarefas do X no Galxe, Zealy ou TaskOn sem gastar os créditos deles, aponte a API task personalizada da plataforma para um pequeno servidor seu e deixe que ele consulte a Sorsa API, uma API e scraper do Twitter (X): cada tarefa é uma requisição que responde verdadeiro ou falso, a partir de US$ 0,0014, com uma chave de API e 20 requisições por segundo em todos os planos.

O login continua com a plataforma. O Zealy e o TaskOn fazem o participante conectar a conta do X antes da verificação rodar, então o handle que seu servidor recebe pertence a quem está fazendo o claim. Seu servidor responde a cada plataforma no formato dela, mantém a chave da Sorsa API longe da plataforma e roda as verificações que uma plataforma não tem, como uma resposta ou a entrada em uma Community.

Cinco tarefas de quest correspondem a cinco verificações da Sorsa API, e cada verificação passa por um campo da resposta.

• Seguir uma conta

  Requisição da Sorsa API

  POST /check-follow (abre em uma nova aba)

  Passa quando

  follow é true

• Retweetar um post

  Requisição da Sorsa API

  POST /check-retweet (abre em uma nova aba)

  Passa quando

  retweet é true

• Fazer quote de um post

  Requisição da Sorsa API

  POST /check-quoted (abre em uma nova aba)

  Passa quando

  status é quoted

• Responder a um post

  Requisição da Sorsa API

  GET /check-comment (abre em uma nova aba)

  Passa quando

  commented é true

• Entrar em uma Community do X

  Requisição da Sorsa API

  POST /check-community-member (abre em uma nova aba)

  Passa quando

  is_member é true

A API oficial do X não tem uma requisição que responda por um participante. A rota dela lê listas inteiras: os seguidores da sua conta, 1.000 por página, a US$ 0,001 por seguidor, e os retweeters de um post a US$ 0,010 por conta, com 75 requisições de retweeters por 15 minutos (preços da API do X (abre em uma nova aba), rate limits da API do X (abre em uma nova aba)). Listas não cabem em uma resposta de 5 segundos, então essa rota exige um job de sincronização, uma conta de desenvolvedor e OAuth além do servidor.

#O que cada API task envia ao seu servidor

Cada plataforma envia o participante em um formato diferente e lê uma resposta diferente, então o servidor precisa de uma pequena rota por plataforma.

• Requisição

  Credencial REST do Galxe

  GET ou POST para a sua URL

  API task do Zealy

  POST com um corpo JSON

  Completion-Based API Task do TaskOn

  GET com ?address=

• O usuário do X chega como

  Credencial REST do Galxe

  $socialId, colocado na sua URL

  API task do Zealy

  accounts.twitter.id e .username

  Completion-Based API Task do TaskOn

  o handle, nunca um ID numérico

• Seu segredo

  Credencial REST do Galxe

  um header que você adiciona

  API task do Zealy

  o header X-Api-Key

  Completion-Based API Task do TaskOn

  Authorization: Bearer

• Passa

  Credencial REST do Galxe

  sua expressão retorna 1

  API task do Zealy

  HTTP 200

  Completion-Based API Task do TaskOn

  {"result": {"isValid": true}}

• Falha

  Credencial REST do Galxe

  sua expressão retorna 0

  API task do Zealy

  HTTP 400 com uma message

  Completion-Based API Task do TaskOn

  isValid: false, ainda com HTTP 200

• Limite de tempo

  Credencial REST do Galxe

  5 segundos

  API task do Zealy

  10 segundos

  Completion-Based API Task do TaskOn

  10 segundos, sem nova tentativa

A documentação do Galxe não diz se $socialId traz um handle do X ou um ID numérico, então o servidor abaixo aceita os dois: dígitos vão para a Sorsa API como user_id, qualquer outra coisa como username.

#Monte o servidor de verificação em quatro passos

O servidor abaixo responde às três plataformas a partir de um único arquivo Node.js, com uma rota por plataforma e uma função compartilhada que roda lado a lado as verificações de uma quest na Sorsa API.

1. Pegue uma chave. Cadastre-se e copie sua chave de API no painel. As primeiras 100 requisições são grátis e não pedem cartão.

2. Teste uma verificação. Pergunte se um participante segue o seu projeto: username_1 é a sua conta, username_2 o participante.

   curl -X POST "https://api.sorsa.io/v3/check-follow" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"username_1": "tidewell_protocol",
          "username_2": "nova_quest_hunter"}'
   

   {
     "follow": true,
     "user_protected": false
   }
   

3. Descreva cada quest. Em QUESTS, dê a cada quest um nome e as tarefas dela no X: follow recebe o seu handle, retweet, quote e reply recebem o link do post, e community recebe o ID da Community.

4. Rode o servidor. Salve o arquivo, defina SORSA_API_KEY e um RELAY_SECRET longo e aleatório, e inicie com node verify-server.mjs atrás de HTTPS nas portas 443 ou 80.

   // verify-server.mjs: Node.js 18+, after `npm install express`
   import express from "express";
   
   const SORSA = "https://api.sorsa.io/v3";
   const KEY = process.env.SORSA_API_KEY || "YOUR_API_KEY";
   const SECRET = process.env.RELAY_SECRET; // the same value on each platform
   
   // The X tasks each quest requires; the URL path names the quest
   const QUESTS = {
     "launch-week": {
       follow: "tidewell_protocol",
       retweet: "https://x.com/tidewell_protocol/status/2116180244581376001",
     },
   };
   
   async function sorsa(method, path, data) {
     const url = new URL(SORSA + path);
     const init = { method, headers: { ApiKey: KEY },
       signal: AbortSignal.timeout(4000) };
     if (method === "GET") {
       url.search = new URLSearchParams(data);
     } else {
       init.headers["Content-Type"] = "application/json";
       init.body = JSON.stringify(data);
     }
     const res = await fetch(url, init);
     if (!res.ok) throw new Error(`Sorsa API ${res.status}`);
     return res.json();
   }
   
   // One check per task type, each resolving to true or false
   const CHECKS = {
     follow: async (account, u) => (await sorsa("POST", "/check-follow", {
       username_1: account,
       ...(u.user_id ? { user_id_2: u.user_id } : { username_2: u.username }),
     })).follow,
     retweet: async (post, u) => (await sorsa("POST", "/check-retweet",
       { tweet_link: post, ...u })).retweet,
     quote: async (post, u) => (await sorsa("POST", "/check-quoted",
       { tweet_link: post, ...u })).status === "quoted",
     reply: async (post, u) => (await sorsa("GET", "/check-comment",
       { tweet_link: post, ...u })).commented,
     community: async (id, u) => (await sorsa("POST",
       "/check-community-member", { community_id: id, ...u })).is_member,
   };
   
   // The tasks still missing; throws when a check couldn't run
   async function missing(questId, x) {
     const quest = QUESTS[questId];
     if (!quest || !x) throw new Error("unknown quest or user");
     const u = /^\d+$/.test(x) ? { user_id: x }
       : { username: x.replace(/^@/, "") };
     const tasks = Object.entries(quest);
     const done = await Promise.all(tasks.map(([t, v]) => CHECKS[t](v, u)));
     return tasks.filter((_, i) => !done[i]).map(([t]) => t);
   }
   
   const app = express();
   app.use(express.json());
   
   // Galxe REST credential: GET /galxe/<quest>?user=$socialId
   const GALXE = {
     "Access-Control-Allow-Origin": "https://dashboard.galxe.com",
     "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
     "Access-Control-Allow-Headers": "Content-Type, X-Relay-Secret",
   };
   app.options("/galxe/:quest", (req, res) => res.set(GALXE).sendStatus(204));
   app.get("/galxe/:quest", async (req, res) => {
     res.set(GALXE);
     if (req.get("X-Relay-Secret") !== SECRET) return res.status(401).end();
     try {
       const left = await missing(req.params.quest, String(req.query.user));
       res.json({ eligible: left.length ? 0 : 1, missing: left });
     } catch {
       res.json({ eligible: 0, missing: ["not checked, try again"] });
     }
   });
   
   // Zealy API task: POST /zealy/<quest>, the secret arrives as X-Api-Key
   app.post("/zealy/:quest", async (req, res) => {
     if (req.get("X-Api-Key") !== SECRET) {
       return res.status(400).json({ message: "Invalid API key" });
     }
     const x = req.body.accounts?.twitter;
     try {
       const left = await missing(req.params.quest, x?.id || x?.username);
       if (!left.length) return res.json({ message: "X tasks verified" });
       res.status(400).json({ message: `Not done yet: ${left.join(", ")}` });
     } catch {
       res.status(400).json({ message: "Couldn't check now, retry in a minute" });
     }
   });
   
   // TaskOn Completion-Based API Task: GET /taskon/<quest>?address=<handle>
   app.get("/taskon/:quest", async (req, res) => {
     if (req.get("Authorization") !== `Bearer ${SECRET}`) {
       return res.status(401).json({ result: { isValid: false } });
     }
     let isValid = false;
     try {
       const left = await missing(req.params.quest, String(req.query.address));
       isValid = left.length === 0;
     } catch {} // TaskOn reads anything but HTTP 200 as a broken endpoint
     res.json({ result: { isValid } });
   });
   
   app.listen(process.env.PORT || 3000);
   

Uma quest custa uma requisição por tarefa por claim, e as verificações de um claim rodam ao mesmo tempo, então cinco tarefas levam mais ou menos o mesmo tempo para responder que uma. Cada chamada à Sorsa API é interrompida após 4 segundos, dentro da janela de 5 segundos do Galxe.

O servidor mantém duas respostas separadas. Uma verificação que volta false reprova o claim e nomeia a tarefa que falta. Um timeout, um 429 ou um 403 da Sorsa API significa que o servidor não conseguiu verificar, e o participante é convidado a tentar de novo em vez de ser informado de que falhou: um 403 significa que a chave está ausente ou sem requisições, e um 429 significa que mais de 20 requisições caíram no mesmo segundo. Requisições com falha nunca são cobradas.

Bom saber

O POST /check-retweet varre os 100 retweets mais recentes de um post por requisição. Um participante que aperta Verificar logo depois de retweetar está nessa janela; em um post com milhares de retweets, quem retweetou dias antes não está. Peça aos participantes que verifiquem logo depois de retweetar, ou siga o next_cursor em um job em segundo plano, como mostra o guia da API de verificação do Twitter.

#Conecte o Galxe com uma credencial REST

No Galxe, o servidor entra como uma credencial REST: o Galxe chama a sua URL quando um participante aperta Verificar, roda a sua expressão sobre o JSON que volta e marca a tarefa como concluída quando a expressão retorna 1.

1. Abra a credencial. Nas Task Settings da quest, escolha Import Your Own Data, depois REST, o método GET e Single Dimension.

2. Escolha o tipo de ID. Escolha a conta do X do participante, para o Galxe preencher $socialId com ela.

3. Informe o endpoint. Use https://verify.example.com/galxe/launch-week?user=$socialId e adicione o header X-Relay-Secret com o seu segredo; o Galxe mostra os headers só aos admins do Space.

4. Cole a expressão. Ela precisa retornar o número 1 ou 0, nunca true ou false.

   function(resp) {
     return resp && resp.eligible === 1 ? 1 : 0;
   }
   

5. Teste e salve. Envie uma conta que fez as tarefas e outra que não fez, e confira as duas respostas.

O Galxe cancela qualquer requisição que leve mais de 5 segundos, aceita só as portas 443 e 80 e envia um preflight de CORS quando você salva a credencial, que a rota OPTIONS do servidor responde. As requisições vêm dos servidores do Galxe em 35.185.209.0 e 35.203.155.18, então libere esses dois endereços se houver um firewall na frente do servidor (Galxe Docs: REST credential (abre em uma nova aba)). A expressão em si é pública, então não ponha segredos nela.

#Conecte o Zealy com uma API task

No Zealy, o servidor vira uma API task: o Zealy envia um POST com o ID e o username do participante no X, uma resposta 200 conclui o claim, e uma resposta 400 mostra a sua mensagem ao participante.

1. Adicione a tarefa. No editor da quest, escolha Add task, depois Api.

2. Defina o endpoint e a chave. Informe https://verify.example.com/zealy/launch-week e o seu segredo como chave de API; o Zealy o envia no header X-Api-Key.

3. Escolha Twitter para identificar os usuários. O Zealy passa a colocar accounts.twitter.id e accounts.twitter.username em toda requisição.

4. Salve. O Zealy testa o endpoint primeiro: ele precisa responder em até 10 segundos, só com HTTP 200 ou 400.

Para ver o que o Zealy vai ver, envie você mesmo a mesma requisição com uma conta de teste:

curl -X POST "https://verify.example.com/zealy/launch-week" \
  -H "X-Api-Key: YOUR_RELAY_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"requestId": "test-1", "accounts": {"twitter":
       {"id": "1849021166738190336", "username": "nova_quest_hunter"}}}'

{
  "message": "Not done yet: retweet"
}

O Zealy mostra essa mensagem ao participante junto com o requestId do claim, então ele descobre qual tarefa falta e você encontra o claim nos seus logs (Zealy: API task (abre em uma nova aba)). Uma API task não é uma das tarefas do X do Zealy, então não soma créditos do X: uma quest montada assim gasta o 1 crédito base de claim por claim, onde um follow e um retweet nativos gastam 4.

#Conecte a Completion-Based API Task do TaskOn

No TaskOn, o servidor é uma Completion-Based API Task: o TaskOn envia um GET com o handle do participante no X em address, e o servidor sempre responde HTTP 200 com isValid em true ou false.

1. Adicione a tarefa. Na campanha ou quest, adicione uma tarefa, abra a aba Custom API e escolha Completion-Based API Task.

2. Defina a URL da API. Clique em Set API URL, escolha Social Media Account e depois X handle, e informe https://verify.example.com/taskon/launch-week.

3. Restrinja ao TaskOn. Ative Restrict API access exclusively to TaskOn e informe o seu segredo como Bearer token.

4. Teste e confirme. Informe uma conta que concluiu as tarefas e outra que não concluiu, clique em Verify em cada uma e em Confirm quando as duas respostas estiverem certas.

O TaskOn faz uma tentativa por clique e nunca tenta de novo, e trata qualquer status diferente de 200, ou um result ausente, como um endpoint quebrado (TaskOn: Completion-Based API Task (abre em uma nova aba)). É por isso que o servidor responde isValid: false quando não conseguiu alcançar a Sorsa API: o participante aperta Verify de novo um minuto depois, e a verificação seguinte roda do zero.

#Quanto custa um claim verificado em cada rota

Um claim que exige um follow e um retweet gasta 20 créditos do Galxe com a Authentic Verification, 4 créditos de claim do Zealy com tarefas nativas do X, ou 2 requisições da Sorsa API, a partir de US$ 0,0028, por trás de uma API task.

Só a rota da Sorsa API cresce com o seu próprio plano em vez de com a franquia de créditos da plataforma, como a tabela mostra para um claim de follow e retweet.

• Sorsa API por trás de uma API task

  Um claim de follow e retweet gasta

  2 requisições, a partir de US$ 0,0028

  O que isso permite

  tantos claims quanto as requisições do seu plano

• Zealy, tarefas nativas do X

  Um claim de follow e retweet gasta

  4 créditos de claim, US$ 0,06 a US$ 15 por 1.000

  O que isso permite

  2.500 claims com os 10 mil créditos mensais do Standard

• Zealy com uma API task

  Um claim de follow e retweet gasta

  1 crédito de claim mais as 2 requisições

  O que isso permite

  10 mil claims com os mesmos 10 mil créditos

• Galxe, Authentic Verification

  Um claim de follow e retweet gasta

  20 créditos de verificação do X

  O que isso permite

  500 claims no Nível 2, 4.000 no Nível 4

• API oficial do X por trás de uma API task

  Um claim de follow e retweet gasta

  leituras de listas: US$ 0,001 por seguidor seu, US$ 0,010 por retweeter

  O que isso permite

  uma conta de desenvolvedor, OAuth e um job de sincronização

A Sorsa API cobra requisições, não participantes, e requisições com falha nunca são cobradas. O valor por 1.000 requisições vai de US$ 4,90 no Starter a US$ 1,40 no maior plano.

#Mantenha bots e quem deixou de seguir fora da lista de recompensas

Uma tarefa verificada prova uma ação, não uma pessoa, então mais três verificações devem vir antes de pagar as recompensas: a idade da conta, uma conta pública e um follow que ainda existe.

• Idade e tamanho da conta. O GET /info (abre em uma nova aba) devolve o created_at, o followers_count e o tweets_count de um participante em uma requisição, então o servidor pode recusar contas com menos de 30 dias ou sem posts. O Galxe tem limites próprios de idade e de seguidores; no Zealy e no TaskOn o lugar para isso é o servidor.
• Contas públicas. As verificações de follow, retweet e quote devolvem user_protected: true quando a conta do participante é privada, e nenhuma verificação externa enxerga o que uma conta privada faz. Peça ao participante que a deixe pública durante a quest.
• Unfollows depois do claim. A própria ajuda do Galxe observa que alguns participantes seguem para fazer o claim e deixam de seguir depois. Rode o POST /check-follow mais uma vez na lista de recompensas antes de pagar.
• Curtidas. O X tornou as curtidas privadas em junho de 2024, então só a própria conta conectada do participante pode mostrar uma curtida, e a Sorsa API não devolve nenhuma (Engadget (abre em uma nova aba)). Peça um retweet, um quote ou uma resposta no lugar: os três continuam públicos e verificáveis.

Para pontuar uma lista inteira de participantes, detecção de bots no Twitter cobre os sinais que separam contas reais de fazendas de contas. As tarefas de Community e a lista de membros da Community estão no guia da API de Listas e Communities do X.

#Rode sua próxima quest com tarefas do X verificadas

Para verificar follows, retweets, quotes, respostas e entradas em Communities do X no Galxe, Zealy ou TaskOn, use a Sorsa API por trás da API task da plataforma: uma requisição por tarefa, a partir de US$ 0,0014 por verificação, 20 requisições por segundo em todos os planos, e nenhuma conta de desenvolvedor nem login seu do X em lugar nenhum do fluxo. Use as 100 requisições grátis, rode o servidor em uma quest de teste com duas contas, uma que fez as tarefas e outra que não fez, e passe as tarefas do X da quest para a API task antes do lançamento.

#Perguntas frequentes