> ## Documentation Index
> Fetch the complete documentation index at: https://docs.xquik.com/llms.txt
> Use this file to discover all available pages before exploring further.

# How do you remove a Twitter follower? Xquik API

> Remove one unwanted Twitter follower by X user ID. Approve the connected account, poll the write action, verify the inbound relationship, and handle errors.

<Panel>
  <Tabs defaultTabIndex={0} sync={false}>
    <Tab title="200" id="response-x-write-remove-follower-200">
      ```json theme={null}
      {
        "object": "x_write_action",
        "id": "12345",
        "writeActionId": "12345",
        "action": "remove_follower",
        "status": "success",
        "terminal": true,
        "retryable": false,
        "safeToRetry": false,
        "statusUrl": "/api/v1/x/write-actions/12345",
        "pollAfterMs": null
      }
      ```
    </Tab>

    <Tab title="202" id="response-x-write-remove-follower-202">
      ```json theme={null}
      {
        "object": "x_write_action",
        "id": "12346",
        "writeActionId": "12346",
        "action": "remove_follower",
        "status": "dispatching",
        "terminal": false,
        "retryable": false,
        "safeToRetry": false,
        "statusUrl": "/api/v1/x/write-actions/12346",
        "pollAfterMs": 2000
      }
      ```
    </Tab>

    <Tab title="400" id="response-x-write-remove-follower-400">
      ```json theme={null}
      {
        "error": "missing_idempotency_key",
        "message": "Idempotency-Key is required. Generate one unique key for this write.",
        "charged": false,
        "chargedCredits": "0",
        "retryable": false,
        "safeToRetry": true
      }
      ```
    </Tab>

    <Tab title="401" id="response-x-write-remove-follower-401">
      ```json theme={null}
      {
        "error": "unauthenticated",
        "message": "Authentication required. Provide a valid API key or bearer token."
      }
      ```
    </Tab>

    <Tab title="402" id="response-x-write-remove-follower-402">
      ```json theme={null}
      {
        "error": "insufficient_credits",
        "message": "Insufficient credits. Top up or subscribe to continue."
      }
      ```
    </Tab>

    <Tab title="403" id="response-x-write-remove-follower-403">
      ```json theme={null}
      {
        "error": "account_needs_reauth",
        "message": "X account needs re-authentication. Re-add the account."
      }
      ```
    </Tab>

    <Tab title="404" id="response-x-write-remove-follower-404">
      ```json theme={null}
      {
        "error": "account_not_found",
        "message": "X account not found. Connect it first at /dashboard/account?tab=x-accounts."
      }
      ```
    </Tab>

    <Tab title="409" id="response-x-write-remove-follower-409">
      ```json theme={null}
      {
        "error": "idempotency_conflict",
        "message": "Idempotency-Key was already used with a different request.",
        "charged": false,
        "chargedCredits": "0",
        "retryable": false,
        "safeToRetry": true
      }
      ```
    </Tab>

    <Tab title="422" id="response-x-write-remove-follower-422">
      ```json theme={null}
      {
        "error": "x_rejected",
        "message": "X rejected this request. Check what you sent & the account on x.com before you try again."
      }
      ```
    </Tab>

    <Tab title="429" id="response-x-write-remove-follower-429">
      ```json theme={null}
      {
        "error": "rate_limit_exceeded",
        "message": "Too many requests. Try again later.",
        "retryAfter": 60
      }
      ```
    </Tab>

    <Tab title="500" id="response-x-write-remove-follower-500">
      ```json theme={null}
      {
        "error": "x_write_failed",
        "message": "Write action failed unexpectedly. Contact support if this persists."
      }
      ```
    </Tab>

    <Tab title="503" id="response-x-write-remove-follower-503">
      ```json theme={null}
      {
        "error": "write_tracking_unavailable",
        "message": "Write tracking unavailable. Try again.",
        "charged": false,
        "chargedCredits": "0",
        "retryable": true,
        "safeToRetry": true
      }
      ```
    </Tab>
  </Tabs>
</Panel>

<blockquote className="agent-llms-directive">
  For the complete documentation index, see <a href="/llms.txt">llms.txt</a>.
</blockquote>

## How do you remove a Twitter follower?

Use this endpoint to remove 1 follower from a connected X account.
Put the follower's numeric X user ID in the path.
Name the connected account in the JSON body.
Then approve, poll, and verify the inbound relationship change.

X also documents [manual follower removal](https://help.x.com/en/using-x/following-faqs).
Its help page explains that a removed account may follow again.

<Callout icon="coins" color="#5c3327">
  **10 credits per call** · [All plans](https://xquik.com/#pricing) from \$0.00012/credit
</Callout>

<Warning>
  **Action-specific rate limit.** Remove Follower shares 20 requests per minute and 400 per day with follow actions. The POST tier also allows 120 requests per minute. A breached limit returns `429 Too Many Requests`. `Retry-After` is the wait until the limit frees, up to 24 hours after the daily limit.
</Warning>

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://xquik.com/api/v1/x/users/44196397/remove-follower \
    -H "x-api-key: xq_YOUR_KEY_HERE" \
    -H "Idempotency-Key: remove-follower-myxaccount-44196397-1895432178065391234" \
    -H "Content-Type: application/json" \
    -d '{
      "account": "myxaccount"
    }' | jq
  ```

  ```javascript Node.js theme={null}
  const response = await fetch("https://xquik.com/api/v1/x/users/44196397/remove-follower", {
    method: "POST",
    headers: {
      "x-api-key": "xq_YOUR_KEY_HERE",
      "Idempotency-Key": "remove-follower-myxaccount-44196397-1895432178065391234",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      account: "myxaccount",
    }),
  });
  const removalReceipt = await response.json();
  if (!response.ok) {
    throw new Error(JSON.stringify(removalReceipt));
  }
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://xquik.com/api/v1/x/users/44196397/remove-follower",
      headers={
          "x-api-key": "xq_YOUR_KEY_HERE",
          "Idempotency-Key": "remove-follower-myxaccount-44196397-1895432178065391234",
      },
      json={
          "account": "myxaccount",
      },
  )
  removal_receipt = response.json()
  response.raise_for_status()
  ```

  ```go Go theme={null}
  package main

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

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

      req, err := http.NewRequest("POST", "https://xquik.com/api/v1/x/users/44196397/remove-follower", bytes.NewReader(body))
      if err != nil {
          panic(err)
      }
      req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")
      req.Header.Set("Idempotency-Key", "remove-follower-myxaccount-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 removalReceipt map[string]interface{}
      if err := json.NewDecoder(resp.Body).Decode(&removalReceipt); err != nil {
          panic(err)
      }
      fmt.Println(removalReceipt)
  }
  ```
</CodeGroup>

## Resolve the follower and connected account

Read [Followers](/api-reference/x/followers) before choosing a target.
Resolve the current username to a stable numeric X user ID.
Usernames and profile names can change.
The numeric ID keeps the moderation record tied to one account.

Show the follower ID, username, profile name, and acting account.
Also show the moderation reason before approval.
The path `{id}` identifies the follower you will remove.
The body field `account` identifies whose follower list will change.

Never infer spam from a username, avatar, or missing profile field.
Choose the unwanted follower with your approved moderation rule.
Store the reviewer, reason, and evidence outside this public request.

## Remove followers one request at a time

Create 1 idempotency key for each intended removal.
Reuse that key only after an interrupted network request.
Never reuse it for another follower or connected account.

This route accepts 1 follower ID per request.
It provides no bulk body for mass follower removal.
Queue approved follower IDs as separate write actions.
Each row needs its own reason, approval, and idempotency key.

A team can review the queue before dispatch.
A temporary failure must not erase the record of successful removals.
Store each returned action ID beside its target follower ID.

## Poll and verify the removal

Store `id`, `request.hash`, `billing`, and `statusUrl` from the response.
An HTTP `200` response represents a terminal write action.
An HTTP `202` response represents an active write action.
Poll the same `statusUrl` while `terminal` remains `false`.

Never submit another removal while the first action is active.
A second request could add a duplicate job.
Keep the original idempotency key for an exact network replay.

Read [Followers](/api-reference/x/followers) after the action becomes terminal.
You can also call [Check Follower](/api-reference/x/check-follower).
Set the removed account as the source relationship participant.
Set the connected account as the target participant.
Confirm the inbound follower relationship is absent.

## Choose remove follower, unfollow, or block

Remove Follower ends one inbound relationship.
The selected account stops following your connected X account.
It does not make your connected account unfollow the selected account.

Use [Unfollow](/api-reference/x-write/unfollow) for that outbound relationship.
Keep both actions separate in every moderation workflow.
The accounts do not need a mutual follow relationship.

Follower removal is also different from blocking.
A removed follower can follow your public account again.
They can ask to follow your protected account again.
Block the account through X when it must not follow again.
This endpoint lets you remove a follower without blocking them.

## Review bots, private accounts, and bulk queues

This endpoint does not detect bots, spam, or inactive accounts.
Check profiles and follower relationships before you approve a removal.
Never treat a protected profile as proof of abusive behavior.

Private and public accounts use the same Xquik request shape.
X controls whether the removed account can follow again.

This write does not block the account.
Store the terminal result, then verify the live follower relationship.
For multiple targets, process one approved queue row at a time.
Throttle the queue to every documented rate limit.

## Handle remove follower API errors

Fix the follower ID or connected account after `400`.
Replace Xquik authentication after `401`.
Add credits after `402`. Reconnect the account after `403`.
Keep the original action after an idempotency conflict at `409`.
Fix rejected input after `422`.
Honor `Retry-After` after `429`.
After `500` or `503`, inspect `safeToRetry` before retrying.

## Twitter follower removal questions

### How to remove followers on Twitter with an API?

Resolve each follower to a numeric ID.
Send one approved request per follower, then poll every action.

### How do you remove a follower from Twitter without blocking?

Call this endpoint for the inbound relationship.
The removed account may still follow the connected account again.

### Can I remove all followers or bot followers at once?

No batch body is available.
Review suspected bots first, then queue one approved target per request.

### Does X notify a removed follower?

No response field tells you whether X sent a notification.
Your final check should cover only the follower relationship.

### Can I unfollow accounts with this endpoint?

No. Use Unfollow when the connected account follows another account.
Use Remove Follower when someone follows you.

### Does this work for mobile, desktop, or private accounts?

The REST request works from any HTTP client.
It does not depend on X's mobile or desktop interface.

### 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

<ParamField header="x-api-key" type="string">
  Send your Xquik API key. Generate one from the [dashboard](https://xquik.com/dashboard).
</ParamField>

<ParamField header="Authorization" type="string">
  Send `Bearer <token>` instead of `x-api-key` when using OAuth 2.1.
</ParamField>

<ParamField header="Idempotency-Key" type="string" required>
  Unique key for this intended write. Reuse it only for an exact network replay.
</ParamField>

<ParamField header="Content-Type" type="string" required>
  Must be `application/json`.
</ParamField>

## Path parameters

<ParamField path="id" type="string" required>
  Follower to remove: user ID, username with or without `@`, or URL-encoded profile URL, such as `x.com/nasa`.
  An unknown username returns `422 x_target_not_found`. See [path IDs](/api-reference/overview#path-ids).
</ParamField>

## Body

<ParamField body="account" type="string" required>
  X username or account ID of your connected account whose follower list should be updated.
</ParamField>

## Response

## Durable write recovery

<Warning>
  Send one unique `Idempotency-Key` per intended write.
  Replay the same account, target, payload, and media after a lost response.
  Keep the original key for that replay.
</Warning>

1. Store `id`, the nested `hash` in `request`, `billing`, and `statusUrl`.
2. Poll after `Retry-After` or `pollAfterMs` when `terminal` is `false`.
3. Retry only when `safeToRetry` is `true`.
4. Use a new key when `nextAction.requiresNewIdempotencyKey` is `true`.

### 200 terminal or 202 active

* 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`. Follow `nextAction`.

See [Get Write Action Status](/api-reference/x-write/get-write-action-status)
for every lifecycle field, terminal state, billing field, and retry rule.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.