Verifica tareas de X (Twitter) en Galxe, Zealy y TaskOn

#Cómo Galxe, Zealy y TaskOn verifican las tareas de X

Las tres plataformas comprueban las tareas de X mediante la cuenta de X que conecta el participante, y cada una raciona esas comprobaciones a su manera: Galxe con créditos de verificación, Zealy con planes de pago y créditos de reclamo, TaskOn con un conjunto fijo de tipos de tarea.

Antes de lanzar una quest, el verificador de follows de Twitter gratuito muestra si una cuenta sigue a otra, en ambas direcciones, para que pruebes tu propia tarea de follow a mano. La tabla compara lo que hace cada plataforma por su cuenta.

• Tareas nativas de X

  Galxe

  Follow, retweet, cita, post con palabras clave

  Zealy

  Follow, post, respuesta, retweet, like, cita, Space

  TaskOn

  Follow, retweet, like, cita con un hashtag o etiquetas, post

• ¿Se confirma la acción?

  Galxe

  Solo con Authentic Verification activado; por defecto cuenta un clic

  Zealy

  Sí, desde la cuenta conectada

  TaskOn

  Sí, desde la cuenta conectada

• Lo que cuestan las comprobaciones de X

  Galxe

  10 créditos por comprobación, desde el Nivel 2 de Rewards Hub o Business+

  Zealy

  De 1 a 3 créditos de reclamo por acción, solo en planes de pago

  TaskOn

  Incluido en el plan Quest

• Vía personalizada para tu servidor

  Galxe

  Credencial REST

  Zealy

  Tarea de API

  TaskOn

  Completion-Based API Task

En Galxe, una tarea de X no se confirma por defecto. Toda credencial de X empieza con Authentic Verification desactivado y usa el método "Page Visit", que registra que un participante abrió el enlace, no que siguió o reposteó (Galxe: Create Quest, Tasks Settings (se abre en una pestaña nueva)). Con Authentic Verification activado, cada comprobación de follow, retweet o cita gasta 10 créditos: el Nivel 2 de Rewards Hub recibe 10K créditos, el Nivel 3 40K y el Nivel 4 80K, y Galxe desactiva la comprobación cuando se agotan (Galxe: X Authentic Verification Credits (se abre en una pestaña nueva)). Los likes no se pueden habilitar para verificación.

La tarea de X de Zealy comprueba cinco acciones desde la cuenta conectada del participante, y cada acción suma créditos de reclamo al 1 crédito que cuesta cada reclamo: un follow, un post, una cita o una respuesta suma 1, un retweet 2 y un like 3 (Zealy: Twitter task (se abre en una pestaña nueva)). Las tareas de X vienen solo con los planes de pago, desde $149 al mes facturados anualmente, y los créditos que superan la asignación mensual de un plan cuestan $15 por 1,000 en Standard (precios de Zealy (se abre en una pestaña nueva)).

TaskOn tiene siete tipos de tarea de X dentro de su plan Quest, $199 al mes facturados cada seis meses. No tiene comprobación de respuestas ni de Comunidades, y su ayuda para participantes pide a quien falle una comprobación de X que espere 15 minutos y verifique una tarea a la vez.

#Verifica las tareas de X en tu propio servidor con Sorsa API

Para confirmar tareas de X en Galxe, Zealy o TaskOn sin gastar sus créditos, apunta la tarea de API personalizada de la plataforma a un pequeño servidor tuyo y deja que consulte a Sorsa API, una API y scraper de Twitter (X): cada tarea es una solicitud que responde verdadero o falso, desde $0.0014, con una clave API y 20 solicitudes por segundo en todos los planes.

La plataforma sigue encargándose del inicio de sesión. Zealy y TaskOn hacen que los participantes conecten su cuenta de X antes de ejecutar la comprobación, así que el handle que recibe tu servidor pertenece a quien reclama. Tu servidor responde a cada plataforma en su propio formato, mantiene la clave de Sorsa API lejos de la plataforma y ejecuta las comprobaciones que una plataforma no tiene, como una respuesta o el ingreso a una Comunidad.

Cinco tareas de quest corresponden a cinco comprobaciones de Sorsa API, y cada comprobación se aprueba con un campo de su respuesta.

• Seguir una cuenta

  Solicitud a Sorsa API

  POST /check-follow (se abre en una pestaña nueva)

  Se aprueba cuando

  follow es true

• Hacer retweet de un post

  Solicitud a Sorsa API

  POST /check-retweet (se abre en una pestaña nueva)

  Se aprueba cuando

  retweet es true

• Citar un post

  Solicitud a Sorsa API

  POST /check-quoted (se abre en una pestaña nueva)

  Se aprueba cuando

  status es quoted

• Responder a un post

  Solicitud a Sorsa API

  GET /check-comment (se abre en una pestaña nueva)

  Se aprueba cuando

  commented es true

• Unirse a una Comunidad de X

  Solicitud a Sorsa API

  POST /check-community-member (se abre en una pestaña nueva)

  Se aprueba cuando

  is_member es true

La API oficial de X no tiene ninguna solicitud que responda por un solo participante. Su vía lee listas completas: los seguidores de tu cuenta, 1,000 por página, a $0.001 por seguidor, y los retweeters de un post a $0.010 por cuenta, con 75 solicitudes de retweeters cada 15 minutos (precios de la API de X (se abre en una pestaña nueva), límites de tasa de la API de X (se abre en una pestaña nueva)). Las listas no caben en una respuesta de 5 segundos, así que esa vía necesita un trabajo de sincronización, una cuenta de desarrollador y OAuth además del servidor.

#Qué envía cada tarea de API a tu servidor

Cada plataforma envía al participante con una forma distinta y lee una respuesta distinta, así que el servidor necesita una pequeña ruta por plataforma.

• Solicitud

  Credencial REST de Galxe

  GET o POST a tu URL

  Tarea de API de Zealy

  POST con un cuerpo JSON

  Completion-Based API Task de TaskOn

  GET con ?address=

• El usuario de X llega como

  Credencial REST de Galxe

  $socialId, colocado en tu URL

  Tarea de API de Zealy

  accounts.twitter.id y .username

  Completion-Based API Task de TaskOn

  el handle, nunca un ID numérico

• Tu secreto

  Credencial REST de Galxe

  un encabezado que tú agregas

  Tarea de API de Zealy

  el encabezado X-Api-Key

  Completion-Based API Task de TaskOn

  Authorization: Bearer

• Aprobado

  Credencial REST de Galxe

  tu expresión devuelve 1

  Tarea de API de Zealy

  HTTP 200

  Completion-Based API Task de TaskOn

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

• Fallido

  Credencial REST de Galxe

  tu expresión devuelve 0

  Tarea de API de Zealy

  HTTP 400 con un message

  Completion-Based API Task de TaskOn

  isValid: false, aún con HTTP 200

• Límite de tiempo

  Credencial REST de Galxe

  5 segundos

  Tarea de API de Zealy

  10 segundos

  Completion-Based API Task de TaskOn

  10 segundos, sin reintento

La documentación de Galxe no aclara si $socialId trae un handle de X o un ID numérico, así que el servidor de abajo acepta ambos: los dígitos van a Sorsa API como user_id y cualquier otra cosa como username.

#Crea el servidor de verificación en cuatro pasos

El servidor de abajo responde a las tres plataformas desde un solo archivo de Node.js, con una ruta por plataforma y una función compartida que ejecuta en paralelo las comprobaciones de una quest en Sorsa API.

1. Obtén una clave. Regístrate y copia tu clave API desde el panel. Las primeras 100 solicitudes son gratis y no piden tarjeta.

2. Prueba una comprobación. Pregunta si un participante sigue a tu proyecto: username_1 es tu cuenta y username_2 el 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. Describe cada quest. En QUESTS, asigna a cada quest un nombre y sus tareas de X: follow recibe tu handle, retweet, quote y reply reciben el enlace del post, y community recibe el ID de la Comunidad.

4. Ejecuta el servidor. Guarda el archivo, define SORSA_API_KEY y un RELAY_SECRET aleatorio y largo, e inícialo con node verify-server.mjs detrás de HTTPS en los puertos 443 u 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);
   

Una quest cuesta una solicitud por tarea por reclamo, y las comprobaciones de un mismo reclamo se ejecutan al mismo tiempo, así que cinco tareas tardan en responder casi lo mismo que una. Cada llamada a Sorsa API se corta a los 4 segundos, dentro de la ventana de 5 segundos de Galxe.

El servidor mantiene separadas dos respuestas. Una comprobación que devuelve false hace fallar el reclamo y nombra la tarea que falta. Un tiempo de espera agotado, un 429 o un 403 de Sorsa API significa que el servidor no pudo comprobar, y al participante se le pide que lo intente de nuevo en lugar de decirle que falló: un 403 significa que falta la clave o que se agotaron las solicitudes, un 429 significa que llegaron más de 20 solicitudes en un segundo. Las solicitudes fallidas nunca se cobran.

Para tener en cuenta

POST /check-retweet revisa los 100 retweets más recientes de un post por solicitud. Un participante que presiona Verify justo después de hacer retweet está dentro de esa ventana; en un post con miles de retweets, quien hizo retweet días antes no lo está. Pide a los participantes que verifiquen justo después de hacer retweet, o sigue el next_cursor en un trabajo en segundo plano, como muestra la guía de la API de verificación de Twitter.

#Conecta Galxe con una credencial REST

En Galxe, el servidor entra como una credencial REST: Galxe llama a tu URL cuando un participante presiona Verify, ejecuta tu expresión sobre el JSON que regresa y marca la tarea como hecha cuando la expresión devuelve 1.

1. Abre la credencial. En Task Settings de la quest, elige Import Your Own Data, luego REST, el método GET y Single Dimension.

2. Elige el tipo de ID. Elige la cuenta de X del participante, para que Galxe llene $socialId con ella.

3. Ingresa el endpoint. Usa https://verify.example.com/galxe/launch-week?user=$socialId y agrega el encabezado X-Relay-Secret con tu secreto; Galxe muestra los encabezados solo a los administradores del Space.

4. Pega la expresión. Debe devolver el número 1 o 0, nunca true o false.

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

5. Prueba y guarda. Envía una cuenta que hizo las tareas y otra que no, y revisa ambas respuestas.

Galxe cancela cualquier solicitud que tarde más de 5 segundos, acepta solo los puertos 443 y 80 y envía un preflight de CORS cuando guardas la credencial, que la ruta OPTIONS del servidor responde. Las solicitudes vienen de los servidores de Galxe en 35.185.209.0 y 35.203.155.18, así que permite esas dos direcciones si hay un firewall delante del servidor (Galxe Docs: REST credential (se abre en una pestaña nueva)). La expresión en sí es pública, así que no pongas secretos en ella.

#Conecta Zealy con una tarea de API

En Zealy, el servidor se convierte en una tarea de API: Zealy envía un POST con el ID y el nombre de usuario de X del participante, una respuesta 200 completa el reclamo y una respuesta 400 muestra tu mensaje al participante.

1. Agrega la tarea. En el editor de la quest, elige Add task y luego Api.

2. Define el endpoint y la clave. Ingresa https://verify.example.com/zealy/launch-week y tu secreto como clave API; Zealy lo envía en el encabezado X-Api-Key.

3. Elige Twitter para identificar usuarios. Zealy entonces pone accounts.twitter.id y accounts.twitter.username en cada solicitud.

4. Guarda. Zealy prueba primero el endpoint: debe responder en 10 segundos, solo con HTTP 200 o 400.

Para ver lo que verá Zealy, envía tú mismo la misma solicitud con una cuenta de prueba:

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"
}

Zealy muestra ese mensaje al participante junto con el requestId del reclamo, así que sabe qué tarea falta y tú puedes encontrar el reclamo en tus registros (Zealy: API task (se abre en una pestaña nueva)). Una tarea de API no es una de las tareas de X de Zealy, así que no suma créditos de X: una quest creada así gasta el crédito base de 1 por reclamo, donde un follow y un retweet nativos gastan 4.

#Conecta la Completion-Based API Task de TaskOn

En TaskOn, el servidor es una Completion-Based API Task: TaskOn envía un GET con el handle de X del participante en address, y el servidor siempre responde HTTP 200 con isValid en true o false.

1. Agrega la tarea. En la campaña o quest, agrega una tarea, abre la pestaña Custom API y elige Completion-Based API Task.

2. Define la URL de la API. Haz clic en Set API URL, elige Social Media Account y luego X handle, e ingresa https://verify.example.com/taskon/launch-week.

3. Bloquéala para TaskOn. Activa Restrict API access exclusively to TaskOn e ingresa tu secreto como Bearer token.

4. Prueba y confirma. Ingresa una cuenta que completó las tareas y otra que no, haz clic en Verify en cada una y en Confirm cuando ambas respuestas sean correctas.

TaskOn hace un solo intento por clic y nunca reintenta, y trata cualquier estado distinto de 200, o un result ausente, como un endpoint roto (TaskOn: Completion-Based API Task (se abre en una pestaña nueva)). Por eso el servidor responde isValid: false cuando no se pudo llegar a Sorsa API: el participante vuelve a presionar Verify un minuto después y la siguiente comprobación se ejecuta desde cero.

#Cuánto cuesta un reclamo verificado en cada vía

Un reclamo que requiere un follow y un retweet gasta 20 créditos de Galxe con Authentic Verification, 4 créditos de reclamo de Zealy con tareas nativas de X, o 2 solicitudes a Sorsa API, desde $0.0028, detrás de una tarea de API.

Solo la vía de Sorsa API crece con tu propio plan en lugar de con la asignación de créditos de la plataforma, como muestra la tabla para un reclamo de follow y retweet.

• Sorsa API detrás de una tarea de API

  Lo que gasta un reclamo de follow y retweet

  2 solicitudes, desde $0.0028

  Lo que permite

  tantos reclamos como solicitudes tenga tu plan

• Zealy, tareas nativas de X

  Lo que gasta un reclamo de follow y retweet

  4 créditos de reclamo, $0.06 a $15 por 1,000

  Lo que permite

  2,500 reclamos con los 10K créditos mensuales de Standard

• Zealy con una tarea de API

  Lo que gasta un reclamo de follow y retweet

  1 crédito de reclamo más las 2 solicitudes

  Lo que permite

  10K reclamos con los mismos 10K créditos

• Galxe, Authentic Verification

  Lo que gasta un reclamo de follow y retweet

  20 créditos de verificación de X

  Lo que permite

  500 reclamos en el Nivel 2, 4,000 en el Nivel 4

• API oficial de X detrás de una tarea de API

  Lo que gasta un reclamo de follow y retweet

  lecturas de listas: $0.001 por seguidor tuyo, $0.010 por retweeter

  Lo que permite

  una cuenta de desarrollador, OAuth y un trabajo de sincronización

Sorsa API cobra solicitudes, no participantes, y las solicitudes fallidas nunca se cobran. La tarifa por 1,000 solicitudes va de $4.90 en Starter a $1.40 en el plan más grande.

#Deja fuera de la lista de recompensas a los bots y a quienes dejan de seguir

Una tarea verificada demuestra una acción, no una persona, así que antes de entregar recompensas conviene hacer tres comprobaciones más: la antigüedad de la cuenta, que sea pública y que el follow siga ahí.

• Antigüedad y tamaño de la cuenta. GET /info (se abre en una pestaña nueva) devuelve el created_at, el followers_count y el tweets_count de un participante en una solicitud, así que el servidor puede rechazar cuentas de menos de 30 días o sin posts. Galxe tiene sus propios límites de antigüedad y de seguidores; en Zealy y TaskOn, el lugar para ellos es el servidor.
• Cuentas públicas. Las comprobaciones de follow, retweet y cita devuelven user_protected: true cuando la cuenta de un participante es privada, y ninguna comprobación externa puede ver lo que hace una cuenta privada. Pide al participante que la haga pública durante la quest.
• Unfollows después del reclamo. La propia ayuda de Galxe señala que algunos participantes siguen para reclamar y luego dejan de seguir. Ejecuta POST /check-follow una vez más sobre la lista de recompensas antes de pagar.
• Likes. X hizo privados los likes en junio de 2024, así que solo la cuenta conectada del propio participante puede mostrar un like, y Sorsa API no devuelve ninguno (Engadget (se abre en una pestaña nueva)). Pide en su lugar un retweet, una cita o una respuesta: las tres siguen siendo públicas y comprobables.

Para puntuar toda una lista de participantes, detección de bots en Twitter explica las señales que separan las cuentas reales de las granjas. Las tareas de Comunidades y la lista de miembros de la Comunidad se tratan en la guía de la API de Listas y Comunidades de X.

#Lanza tu próxima quest con tareas de X verificadas

Para verificar follows, retweets, citas, respuestas e ingresos a Comunidades de X en Galxe, Zealy o TaskOn, usa Sorsa API detrás de la tarea de API de la plataforma: una solicitud por tarea, desde $0.0014 por comprobación, 20 solicitudes por segundo en todos los planes y sin ninguna cuenta de desarrollador ni inicio de sesión de X tuyos en el flujo. Aprovecha las 100 solicitudes gratis, ejecuta el servidor con una quest de prueba y dos cuentas, una que hizo las tareas y otra que no, y pasa las tareas de X de la quest a la tarea de API antes del lanzamiento.

#Preguntas frecuentes