Twitter unfollow API: unfollow one X user by ID

{
  "object": "x_write_action",
  "id": "12345",
  "writeActionId": "12345",
  "action": "unfollow",
  "status": "success",
  "terminal": true,
  "retryable": false,
  "safeToRetry": false,
  "statusUrl": "/api/v1/x/write-actions/12345",
  "pollAfterMs": null
}

{
  "object": "x_write_action",
  "id": "12346",
  "writeActionId": "12346",
  "action": "unfollow",
  "status": "dispatching",
  "terminal": false,
  "retryable": false,
  "safeToRetry": false,
  "statusUrl": "/api/v1/x/write-actions/12346",
  "pollAfterMs": 2000
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check request fields.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": false,
  "safeToRetry": true
}

{
  "error": "unauthenticated",
  "message": "Authentication required. Provide a valid API key or bearer token."
}

{
  "error": "insufficient_credits",
  "message": "Insufficient credits. Top up or subscribe to continue."
}

{
  "error": "account_needs_reauth",
  "message": "X account needs re-authentication. Re-add the account."
}

{
  "error": "idempotency_conflict",
  "message": "Idempotency-Key was already used with a different request.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": false,
  "safeToRetry": true
}

{
  "error": "x_rejected",
  "message": "X rejected this request. Wait a few minutes and try again."
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Try again later.",
  "retryAfter": 60
}

{
  "error": "x_write_failed",
  "message": "Write action failed unexpectedly. Contact support if this persists."
}

{
  "error": "write_tracking_unavailable",
  "message": "Write tracking unavailable. Try again.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": true,
  "safeToRetry": true
}

DELETE

users

{id}

Twitter unfollow API: unfollow one X user by ID

curl --request DELETE \
  --url https://xquik.com/api/v1/x/users/{id}/follow \
  --header 'Content-Type: <content-type>' \
  --header 'Idempotency-Key: <idempotency-key>' \
  --data '
{
  "account": "<string>"
}
'

import requests

url = "https://xquik.com/api/v1/x/users/{id}/follow"

payload = { "account": "<string>" }
headers = {
    "Idempotency-Key": "<idempotency-key>",
    "Content-Type": "<content-type>"
}

response = requests.delete(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'DELETE',
  headers: {'Idempotency-Key': '<idempotency-key>', 'Content-Type': '<content-type>'},
  body: JSON.stringify({account: '<string>'})
};

fetch('https://xquik.com/api/v1/x/users/{id}/follow', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://xquik.com/api/v1/x/users/{id}/follow"

	payload := strings.NewReader("{\n  \"account\": \"<string>\"\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("Idempotency-Key", "<idempotency-key>")
	req.Header.Add("Content-Type", "<content-type>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

Unfollow one Twitter user by ID

Use this Twitter unfollow API endpoint for 1 target user ID. Each Twitter API unfollow request names 1 connected X account. Verify the target user ID and acting account before approval. Compare X’s separate Unfollow User endpoint.

10 credits per call · All plans from $0.00012/credit

Action-specific rate limit. Unfollow shares the follow-action limits: 20 requests per minute and 400 per day. The DELETE tier also applies. A breached limit returns 429 Too Many Requests.

curl -X DELETE https://xquik.com/api/v1/x/users/44196397/follow \
  -H "x-api-key: xq_YOUR_KEY_HERE" \
  -H "Idempotency-Key: unfollow-44196397-1895432178065391234" \
  -H "Content-Type: application/json" \
  -d '{
    "account": "myxaccount"
  }' | jq

const response = await fetch("https://xquik.com/api/v1/x/users/44196397/follow", {
  method: "DELETE",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
    "Idempotency-Key": "unfollow-44196397-1895432178065391234",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    account: "myxaccount",
  }),
});
const unfollowReceipt = await response.json();
if (!response.ok) {
  throw new Error(JSON.stringify(unfollowReceipt));
}

import requests

response = requests.delete(
    "https://xquik.com/api/v1/x/users/44196397/follow",
    headers={
        "x-api-key": "xq_YOUR_KEY_HERE",
        "Idempotency-Key": "unfollow-44196397-1895432178065391234",
    },
    json={
        "account": "myxaccount",
    },
)
unfollow_receipt = response.json()
response.raise_for_status()

package main

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

func main() {
    body, _ := json.Marshal(map[string]interface{}{
        "account": "myxaccount",
    })

    req, err := http.NewRequest("DELETE", "https://xquik.com/api/v1/x/users/44196397/follow", bytes.NewReader(body))
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")
    req.Header.Set("Idempotency-Key", "unfollow-44196397-1895432178065391234")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    var unfollowReceipt map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&unfollowReceipt); err != nil {
        panic(err)
    }
    fmt.Println(unfollowReceipt)
}

Authenticate and select the relationship

Send an Xquik API key or OAuth 2.1 bearer token. Never send an X password or session cookie. The path ID names the profile that the acting account follows. The body names the connected account that will stop following it. Use the stable numeric user ID as the relationship key. Keep the username and profile name as review labels. Show both profiles before a user approves the write action. The profile page and unfollow button are manual X controls. This endpoint supports an approved Twitter management workflow.

Unfollow Twitter accounts safely

Create a new idempotency key whenever the relationship changes. Never reuse the key from an earlier follow action. Reuse the unfollow key only after an interrupted network request. Store the returned action ID, request hash, and statusUrl immediately. Poll the same action while terminal remains false. Never submit a second write just because the first action is active. The endpoint accepts 1 target user ID per request. It exposes no mass unfollow body or bulk unfollow feature. Queue approved targets separately when you unfollow Twitter accounts in bulk. Each row needs its own target, reason, approval, and idempotency key. Separate rows isolate failures across multiple Twitter accounts. A failed row must not erase successful unfollow actions. Batch queues save time while preserving individual approvals. Review unfollowing accounts before sending any write. A social media team can stage approved rows for later processing. For accounts on Twitter, store each acting account and target ID separately. Respect X’s terms of service and every returned rate limit. Unfollow people only after a clear user or workflow decision.

Select inactive users before unfollowing

This write endpoint does not discover inactive users or non-followers. Read Following before selecting cleanup targets. Define inactivity from an approved timestamp or business rule. Never infer inactivity from a missing profile or stale export. Store the selection rule with the target user ID. Review the acting account and target as separate fields. Then send 1 approved unfollow action for each relationship.

Verify the Twitter unfollow API result

Poll statusUrl until the durable action becomes terminal. Store the final status, billing fields, and request identifiers. Use Check Follower when current proof matters. Check Following to confirm the target disappeared from the outbound list. No response field says whether X sent a notification. Do not claim whether X notified the target account. Verify the relationship instead of inferring client behavior.

Choose unfollow or remove follower

Unfollow stops the connected account from following the target profile. Remove Follower ends one inbound relationship. Use Remove Follower when someone should stop following the connected account. Unretweet removes one repost but preserves every follow relationship. Delete Tweet removes one post but preserves follower relationships. Don’t mix these write actions in one management tool flow.

Handle Twitter API unfollow errors

Fix the target user ID or acting account after 400. Replace Xquik authentication after 401; reconnect after 403. Add credits after 402; review rejected input after 422. Keep the original action after an idempotency conflict at 409. Honor Retry-After after 429. After 500 or 503, check safeToRetry before retrying.

Twitter unfollow API questions

How do I unfollow someone on Twitter with an API?

Approve the target user ID and connected account. Send this DELETE request, then poll the returned action until terminal.

Can I mass unfollow or schedule unfollow actions?

Use your scheduler to queue 1 approved target per request. Throttle the queue to both documented limits above.

Can I unfollow someone without them knowing?

Xquik cannot confirm whether X sends a notification. Confirm only the outbound relationship change.

Do I need unfollow tools or browser extensions?

No. Use any HTTP client or the cURL, Node.js, Python, and Go examples. A third-party service still needs an approved connected account. Some HTTP clients offer free plans, but Xquik credits still apply.

How do I manage several connected accounts?

Repeat approval for each acting account. Never reuse one action ID across accounts.

How do I get an API key?

Create an Xquik API key in the dashboard. You can also send an OAuth 2.1 bearer token.

Headers

string

Send your Xquik API key. Generate one from the dashboard.

string

Send Bearer <token> instead of x-api-key when using OAuth 2.1.

string

required

Unique key for this intended write. Reuse it only for an exact network replay.

string

required

Must be application/json.

Path parameters

string

required

The X user ID of the account to unfollow.

Body

string

required

X username or account ID of your connected account to act as.

Response

Durable write recovery

Send one unique Idempotency-Key per intended write. Reuse it only for the same account, target, payload, and media.

Store id, the nested hash in request, billing, and statusUrl.
Poll after Retry-After or pollAfterMs when terminal is false.
Trust safeToRetry and nextAction before any new write.

200 Terminal or 202 active

Store terminal results. Poll active actions without creating another write.

After HTTP 200, store the result and settled billing.
After HTTP 202, poll the same action. Never submit another write.
After HTTP 400, fix the named field. Use a new idempotency key.
After HTTP 401, fix authentication. Do not retry unchanged.
After HTTP 402, fund the account before another write.
After HTTP 403, reconnect the account.
After HTTP 409, keep the original action. Use a new key for new input.
After HTTP 422, fix the rejected request before retrying.
After HTTP 429, wait for Retry-After. Preserve the same key.
After HTTP 500, retry only when safeToRetry is true.
After HTTP 503, poll while terminal is false.

See Get Write Action Status for every lifecycle field, terminal state, billing field, and retry rule.

{
  "object": "x_write_action",
  "id": "12345",
  "writeActionId": "12345",
  "action": "unfollow",
  "status": "success",
  "terminal": true,
  "retryable": false,
  "safeToRetry": false,
  "statusUrl": "/api/v1/x/write-actions/12345",
  "pollAfterMs": null
}

{
  "object": "x_write_action",
  "id": "12346",
  "writeActionId": "12346",
  "action": "unfollow",
  "status": "dispatching",
  "terminal": false,
  "retryable": false,
  "safeToRetry": false,
  "statusUrl": "/api/v1/x/write-actions/12346",
  "pollAfterMs": 2000
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check request fields.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": false,
  "safeToRetry": true
}

{
  "error": "unauthenticated",
  "message": "Authentication required. Provide a valid API key or bearer token."
}

{
  "error": "insufficient_credits",
  "message": "Insufficient credits. Top up or subscribe to continue."
}

{
  "error": "account_needs_reauth",
  "message": "X account needs re-authentication. Re-add the account."
}

{
  "error": "idempotency_conflict",
  "message": "Idempotency-Key was already used with a different request.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": false,
  "safeToRetry": true
}

{
  "error": "x_rejected",
  "message": "X rejected this request. Wait a few minutes and try again."
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Try again later.",
  "retryAfter": 60
}

{
  "error": "x_write_failed",
  "message": "Write action failed unexpectedly. Contact support if this persists."
}

{
  "error": "write_tracking_unavailable",
  "message": "Write tracking unavailable. Try again.",
  "charged": false,
  "chargedCredits": "0",
  "retryable": true,
  "safeToRetry": true
}

Twitter unfollow API: unfollow one X user by ID

curl --request DELETE \
  --url https://xquik.com/api/v1/x/users/{id}/follow \
  --header 'Content-Type: <content-type>' \
  --header 'Idempotency-Key: <idempotency-key>' \
  --data '
{
  "account": "<string>"
}
'

import requests

url = "https://xquik.com/api/v1/x/users/{id}/follow"

payload = { "account": "<string>" }
headers = {
    "Idempotency-Key": "<idempotency-key>",
    "Content-Type": "<content-type>"
}

response = requests.delete(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'DELETE',
  headers: {'Idempotency-Key': '<idempotency-key>', 'Content-Type': '<content-type>'},
  body: JSON.stringify({account: '<string>'})
};

fetch('https://xquik.com/api/v1/x/users/{id}/follow', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://xquik.com/api/v1/x/users/{id}/follow"

	payload := strings.NewReader("{\n  \"account\": \"<string>\"\n}")

	req, _ := http.NewRequest("DELETE", url, payload)

	req.Header.Add("Idempotency-Key", "<idempotency-key>")
	req.Header.Add("Content-Type", "<content-type>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

Overview

X API

X write

Trends

Radar

Account

API keys

Guest wallets

Credits

X accounts

Monitors

Events

Webhooks

Draws

Extractions

Compose

Drafts

Styles

Support

Twitter unfollow API: unfollow one X user by ID

Unfollow one Twitter user by ID

Authenticate and select the relationship

Unfollow Twitter accounts safely

Select inactive users before unfollowing

Verify the Twitter unfollow API result

Choose unfollow or remove follower

Handle Twitter API unfollow errors

Twitter unfollow API questions

How do I unfollow someone on Twitter with an API?

Can I mass unfollow or schedule unfollow actions?

Can I unfollow someone without them knowing?

Do I need unfollow tools or browser extensions?

How do I manage several connected accounts?

How do I get an API key?

Headers

Path parameters

Body

Response

Durable write recovery

200 Terminal or 202 active

​Unfollow one Twitter user by ID

​Authenticate and select the relationship

​Unfollow Twitter accounts safely

​Select inactive users before unfollowing

​Verify the Twitter unfollow API result

​Choose unfollow or remove follower

​Handle Twitter API unfollow errors

​Twitter unfollow API questions

​How do I unfollow someone on Twitter with an API?

​Can I mass unfollow or schedule unfollow actions?

​Can I unfollow someone without them knowing?

​Do I need unfollow tools or browser extensions?

​How do I manage several connected accounts?

​How do I get an API key?

​Headers

​Path parameters

​Body

​Response

​Durable write recovery

​200 Terminal or 202 active

Unfollow one Twitter user by ID

Authenticate and select the relationship

Unfollow Twitter accounts safely

Select inactive users before unfollowing

Verify the Twitter unfollow API result

Choose unfollow or remove follower

Handle Twitter API unfollow errors

Twitter unfollow API questions

How do I unfollow someone on Twitter with an API?

Can I mass unfollow or schedule unfollow actions?

Can I unfollow someone without them knowing?

Do I need unfollow tools or browser extensions?

How do I manage several connected accounts?

How do I get an API key?

Headers

Path parameters

Body

Response

Durable write recovery

200 Terminal or 202 active