Set a Twitter handle for Xquik tweet style analysis

{
  "success": true,
  "xUsername": "elonmusk"
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check the request body."
}

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

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

PUT

account

x-identity

Set a Twitter handle for Xquik tweet style analysis

curl --request PUT \
  --url https://xquik.com/api/v1/account/x-identity \
  --header 'Content-Type: <content-type>' \
  --data '
{
  "username": "<string>"
}
'

import requests

url = "https://xquik.com/api/v1/account/x-identity"

payload = { "username": "<string>" }
headers = {"Content-Type": "<content-type>"}

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

print(response.text)

const options = {
  method: 'PUT',
  headers: {'Content-Type': '<content-type>'},
  body: JSON.stringify({username: '<string>'})
};

fetch('https://xquik.com/api/v1/account/x-identity', 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/account/x-identity"

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

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

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

}

{
  "success": true,
  "xUsername": "<string>"
}

Store your X or Twitter handle

Store one X username on your authenticated Xquik account. Send the handle without its leading @. Xquik validates the syntax and stores lowercase text. This identity helps Analyze Style recognize when the requested username matches your stored account username. That match supports own-account tweet style analysis. This route does not look up an X profile. It does not verify username availability, account existence, or ownership. It also does not connect an X account or authorize tweet, reply, like, follow, or Direct Message actions.

Free - does not consume credits

curl --fail-with-body \
  --request PUT https://xquik.com/api/v1/account/x-identity \
  --header "x-api-key: xq_YOUR_KEY_HERE" \
  --header "Content-Type: application/json" \
  --data '{"username":"elonmusk"}' | jq

const response = await fetch("https://xquik.com/api/v1/account/x-identity", {
  method: "PUT",
  headers: {
    "x-api-key": "xq_YOUR_KEY_HERE",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ username: "elonmusk" }),
});
const result = await response.json();
if (!response.ok) {
  throw new Error(`${response.status} ${result.error}: ${result.message}`);
}

console.log(result.xUsername);

import requests

response = requests.put(
    "https://xquik.com/api/v1/account/x-identity",
    headers={"x-api-key": "xq_YOUR_KEY_HERE"},
    json={"username": "elonmusk"},
)
result = response.json()
if response.status_code != 200:
    raise RuntimeError(
        f'{response.status_code} {result["error"]}: {result["message"]}'
    )

print(result["xUsername"])

package main

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

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

    req, err := http.NewRequest("PUT", "https://xquik.com/api/v1/account/x-identity", bytes.NewReader(body))
    if err != nil {
        panic(err)
    }
    req.Header.Set("x-api-key", "xq_YOUR_KEY_HERE")
    req.Header.Set("Content-Type", "application/json")

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

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        panic(err)
    }
    if resp.StatusCode != http.StatusOK {
        panic(fmt.Sprintf("%d %v: %v", resp.StatusCode, result["error"], result["message"]))
    }

    fmt.Println(result["xUsername"])
}

Format the X username correctly

Send one username string. Remove the @ prefix first. The Xquik route accepts 1 to 15 characters. Every character must be a letter, number, or underscore. Spaces, periods, hyphens, emoji, and @ are rejected.

Input	Result	Reason
`XDevelopers`	Stored as `xdevelopers`	Uppercase letters are normalized.
`xquik_api`	Stored as `xquik_api`	Letters and underscores are accepted.
`@xquik`	`400 invalid_username`	Remove the leading `@`.
`xquik-api`	`400 invalid_username`	Hyphens are not accepted.
`xquik api`	`400 invalid_username`	Spaces are not accepted.
Empty string	`400 invalid_input`	A username is required.

Xquik does not trim whitespace. Remove surrounding spaces before sending the body. Store the lowercase response value as your canonical Xquik copy. X’s username guidance describes a handle as the unique name shown after @. Native X rules and availability checks can be stricter than this route’s syntax validation. Passing the Xquik pattern does not prove that X currently allows the handle. It also does not prove that the handle belongs to you.

Understand handle, display name, and user ID

An X username is also called a Twitter handle or X handle. It appears after @ and inside the profile URL. This endpoint stores that username only.

Identifier	Example	Stored here?	Can it change?
X or Twitter handle	`@xquik`	Yes, without `@`	Yes, the X account can rename it.
Display name	`Xquik`	No	Yes
Numeric X user ID	`123456789`	No	Normally treated as the stable profile ID.

Do not send a numeric Twitter user ID unless it is actually the account’s username text. This route does not convert a Twitter ID to a username. Use Twitter Profile Lookup when you need profile fields from a known username or user ID. Use Search Users when you need username search.

Apply the identity to tweet style analysis

Set the handle before analyzing your own posting style. The style route compares its requested username with this stored lowercase value. Use this workflow:

Find the exact current X username.
Remove the leading @ symbol.
Send the username through this route.
Save the returned lowercase xUsername.
Call Analyze Style for that same username.
Review the style result for the intended account.
Update this identity after an X username change.

Case does not affect the stored match. XDevelopers becomes xdevelopers. Sending the same normalized username again keeps the same stored value. Sending another valid username replaces the previous one. The response returns the new stored value. No username history appears in this response. This route provides no delete or clear operation. Replace the value with another valid username when your account identity changes.

Keep identity storage separate from X connection

This endpoint changes one Xquik account field. It does not create an authenticated connection to X.

Action	Performed here?	Correct workflow
Store a username for style matching	Yes	Call this route.
Verify that an X profile exists	No	Call Twitter Profile Lookup.
Search for a Twitter username	No	Call Search Users.
Connect an X account for write actions	No	Use the X account connection flow.
Rename the account on X	No	Change the username through X.
Convert a Twitter user ID to username	No	Use a profile lookup endpoint.
Read followers, replies, or tweets	No	Use the matching X read endpoint.

Use List Connected X Accounts to inspect login-backed X connections. A stored style identity and a connected X account serve different purposes.

Recover from X identity errors

Status	Error	Cause	Fix
`200`	Success object	Xquik stored the lowercase username	Save `xUsername`.
`400`	`invalid_input`	The body is non-object or `username` is missing, empty, or non-string	Send a non-empty string.
`400`	`invalid_username`	The string breaks the 1-to-15-character pattern	Remove `@`, spaces, and unsupported symbols.
`401`	`unauthenticated`	The credential is missing or invalid	Replace the API key or bearer token.
`429`	`rate_limit_exceeded`	Too many requests reached the route	Wait for `Retry-After`, then retry once.

Never retry either 400 response without changing the body. Never retry 401 without replacing the credential. After 429, keep the exact intended handle. Retry after the server’s delay, then confirm the stored value through Get Account.

Answer X username questions

What is a Twitter handle?

A Twitter handle is the unique username displayed after @. X now calls it an X username or handle. It differs from the display name.

How can I find my Twitter username?

Open your X profile or account settings. Copy the handle shown after @, then send it here without that symbol.

Does this endpoint perform a Twitter username lookup?

No. It stores supplied text after syntax validation. It does not fetch profile details or confirm that the username exists.

Does it verify that I own the X account?

No. The route does not perform an ownership challenge. Use the separate X account connection workflow for authenticated actions.

Is a Twitter user ID the same as a username?

No. A username is the changeable handle. A user ID identifies the profile with a separate numeric value.

What happens if my X handle changes?

Call this route again with the new handle. The valid lowercase username replaces the previous value.

Does setting an X identity consume credits?

No. This authenticated account update is free.

Headers

string

Your Xquik API key. Generate one from the dashboard.

string

An OAuth bearer token formatted as Bearer YOUR_TOKEN. Send this header or x-api-key, not both.

string

required

Must be application/json.

Body

string

required

X username without @. Send 1 to 15 letters, numbers, or underscores. The stored value becomes lowercase.

Response

200 OK

boolean

Always true after a successful update.

string

Stored lowercase X username without @.

{
  "success": true,
  "xUsername": "elonmusk"
}

400 Invalid input

{ "error": "invalid_input", "message": "Invalid input. Check the request body." }

The body lacks a non-empty string username.

{ "error": "invalid_username", "message": "Invalid username format." }

The username breaks the 1-to-15-character letter, number, and underscore pattern.

401 Unauthenticated

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

Authentication is missing or invalid. Replace the credential before retrying.

429 Rate limited

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

Too many requests reached the route. Wait for Retry-After before retrying.

Related. Get Account to confirm the stored handle, Analyze Style to process tweet style, or List Connected X Accounts to inspect authenticated X connections.

{
  "success": true,
  "xUsername": "elonmusk"
}

{
  "error": "invalid_input",
  "message": "Invalid input. Check the request body."
}

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

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

Set a Twitter handle for Xquik tweet style analysis

curl --request PUT \
  --url https://xquik.com/api/v1/account/x-identity \
  --header 'Content-Type: <content-type>' \
  --data '
{
  "username": "<string>"
}
'

import requests

url = "https://xquik.com/api/v1/account/x-identity"

payload = { "username": "<string>" }
headers = {"Content-Type": "<content-type>"}

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

print(response.text)

const options = {
  method: 'PUT',
  headers: {'Content-Type': '<content-type>'},
  body: JSON.stringify({username: '<string>'})
};

fetch('https://xquik.com/api/v1/account/x-identity', 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/account/x-identity"

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

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

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

}

{
  "success": true,
  "xUsername": "<string>"
}

​Store your X or Twitter handle

​Format the X username correctly

​Understand handle, display name, and user ID

​Apply the identity to tweet style analysis

​Keep identity storage separate from X connection

​Recover from X identity errors

​Answer X username questions

​What is a Twitter handle?

​How can I find my Twitter username?

​Does this endpoint perform a Twitter username lookup?

​Does it verify that I own the X account?

​Is a Twitter user ID the same as a username?

​What happens if my X handle changes?

​Does setting an X identity consume credits?

​Headers

​Body

​Response

​200 OK

​400 Invalid input

​401 Unauthenticated

​429 Rate limited

Store your X or Twitter handle

Format the X username correctly

Understand handle, display name, and user ID

Apply the identity to tweet style analysis

Keep identity storage separate from X connection

Recover from X identity errors

Answer X username questions

What is a Twitter handle?

How can I find my Twitter username?

Does this endpoint perform a Twitter username lookup?

Does it verify that I own the X account?

Is a Twitter user ID the same as a username?

What happens if my X handle changes?

Does setting an X identity consume credits?

Headers

Body

Response

200 OK

400 Invalid input

401 Unauthenticated

429 Rate limited