Twitter like API: like a tweet by ID with status

curl -X POST https://xquik.com/api/v1/x/tweets/1895432178065391234/like \
  -H "x-api-key: xq_YOUR_KEY_HERE" \
  -H "Idempotency-Key: like-1895432178065391234" \
  -H "Content-Type: application/json" \
  -d '{
    "account": "elonmusk"
  }' | jq '{
    status,
    terminal,
    safe_to_retry: .safeToRetry,
    write_action_id: .id,
    request_hash: .request.hash,
    requested_tweet_id: "1895432178065391234",
    confirmed_tweet_id: (.result.id // .tweetId // .targetId),
    charged_credits: .billing.chargedCredits,
    poll_path: (if .terminal then null else .statusUrl end)
  }'

const tweetId = "1895432178065391234";
const response = await fetch(`https://xquik.com/api/v1/x/tweets/${tweetId}/like`, {
  method: "POST",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
    "Idempotency-Key": "like-1895432178065391234",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    account: "elonmusk",
  }),
});
const result = await response.json();
if (!response.ok) {
  throw new Error(JSON.stringify(result));
}
const likeRecord = {
  status: result.status,
  terminal: result.terminal,
  safe_to_retry: result.safeToRetry,
  write_action_id: result.id,
  request_hash: result.request.hash,
  requested_tweet_id: tweetId,
  confirmed_tweet_id:
    result.result?.id ?? result.tweetId ?? result.targetId ?? null,
  account: result.account,
  charged_credits: result.billing.chargedCredits,
  poll_path: result.terminal ? null : result.statusUrl,
};
process.stdout.write(`${JSON.stringify(likeRecord)}\n`);

import json
import requests

tweet_id = "1895432178065391234"
response = requests.post(
    f"https://xquik.com/api/v1/x/tweets/{tweet_id}/like",
    headers={
        "x-api-key": "xq_YOUR_KEY_HERE",
        "Idempotency-Key": "like-1895432178065391234",
    },
    json={
        "account": "elonmusk",
    },
)
result = response.json()
response.raise_for_status()
like_record = {
    "status": result["status"],
    "terminal": result["terminal"],
    "safe_to_retry": result["safeToRetry"],
    "write_action_id": result["id"],
    "request_hash": result["request"]["hash"],
    "requested_tweet_id": tweet_id,
    "confirmed_tweet_id": (
        (result.get("result") or {}).get("id")
        or result.get("tweetId")
        or result.get("targetId")
    ),
    "account": result["account"],
    "charged_credits": result["billing"]["chargedCredits"],
    "poll_path": None if result["terminal"] else result["statusUrl"],
}
print(json.dumps(like_record))

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type LikeTweetResponse struct {
    ID string `json:"id"`
    Status string `json:"status"`
    Terminal bool `json:"terminal"`
    SafeToRetry bool `json:"safeToRetry"`
    StatusURL string `json:"statusUrl"`
    TargetID *string `json:"targetId"`
    TweetID *string `json:"tweetId"`
    Request struct {
        Hash string `json:"hash"`
    } `json:"request"`
    Account map[string]any `json:"account"`
    Billing struct {
        ChargedCredits string `json:"chargedCredits"`
    } `json:"billing"`
    Result *struct {
        ID string `json:"id"`
    } `json:"result"`
}

func main() {
    tweetID := "1895432178065391234"
    body, err := json.Marshal(map[string]string{
        "account": "elonmusk",
    })
    if err != nil {
        panic(err)
    }

    req, err := http.NewRequest(
        "POST",
        "https://xquik.com/api/v1/x/tweets/"+tweetID+"/like",
        bytes.NewReader(body),
    )
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")
    req.Header.Set("Idempotency-Key", "like-1895432178065391234")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    if resp.StatusCode >= 400 {
        responseBody, _ := io.ReadAll(resp.Body)
        panic(string(responseBody))
    }

    var result LikeTweetResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        panic(err)
    }
    var confirmedTweetID any
    if result.Result != nil && result.Result.ID != "" {
        confirmedTweetID = result.Result.ID
    } else if result.TweetID != nil {
        confirmedTweetID = *result.TweetID
    } else if result.TargetID != nil {
        confirmedTweetID = *result.TargetID
    }
    var pollPath any
    if !result.Terminal {
        pollPath = result.StatusURL
    }
    likeRecord := map[string]any{
        "status": result.Status,
        "terminal": result.Terminal,
        "safe_to_retry": result.SafeToRetry,
        "write_action_id": result.ID,
        "request_hash": result.Request.Hash,
        "requested_tweet_id": tweetID,
        "confirmed_tweet_id": confirmedTweetID,
        "account": result.Account,
        "charged_credits": result.Billing.ChargedCredits,
        "poll_path": pollPath,
    }
    encoded, err := json.Marshal(likeRecord)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(encoded))
}