For the complete documentation index, see llms.txt.## Distinct Antwork Fit Antwork centers on AI-chat publishing across 8+ social platforms. Its differentiators are brand voice, campaign generation, scheduling, analytics, and MCP. Use this page for cross-platform publishing, not X-only data collection. Use this guide to decide whether Antwork or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Compare Apify, Xquik, and Xquik's Apify Actors. Match Actor inputs, dataset rows, exports, and automation needs for one X/Twitter job.
For the complete documentation index, see llms.txt.Use this guide to decide whether Audiense or Xquik fits a specific X job: audience intelligence, influencer discovery, tweet search, follower export, account or keyword monitoring, signed webhooks, API access, and agent handoff.
For the complete documentation index, see llms.txt.Use this guide to decide whether Black Magic or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.## Distinct Brandwatch Fit Brandwatch centers on enterprise social listening and consumer intelligence across channels. Its outputs include dashboards, segments, reports, alerts, and suite exports. Use this page for broad research programs, not an X-only API. Use this guide to decide whether Brandwatch or Xquik fits the X part of a social listening, consumer intelligence, or social media management workflow: search tweets, export followers, monitor accounts or keywords, send webhooks, and hand results to apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Buffer or Xquik fits a social media scheduling workflow: plan posts, schedule threads, manage comments, analyze posts, search tweets, export followers, monitor accounts or keywords, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether ChirrApp or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Hootsuite or Xquik fits the X part of a social media management workflow: schedule posts, review inboxes, analyze campaigns, search tweets, export followers, monitor accounts or keywords, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Hypefury or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Zernio, formerly Late, or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Make, Xquik, or both fit a scenario that needs X/Twitter data, account actions, alerts, exports, webhooks, API calls, or downstream app automation.
For the complete documentation index, see llms.txt.Use this guide to decide whether Meltwater or Xquik fits the X part of a media monitoring, social listening, or social media management workflow: search tweets, export followers, monitor accounts or keywords, send webhooks, and hand records to apps, warehouses, or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether n8n, Xquik, or both fit a workflow that needs X/Twitter data, account actions, alerts, exports, webhooks, AI agents, or downstream app automation.
For the complete documentation index, see llms.txt.Use this guide to decide whether Outstand or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether PhantomBuster or Xquik fits a specific X/Twitter workflow: collect profiles, send outreach, export followers, search tweets, monitor accounts, trigger webhooks, or hand data to an app or AI agent.
For the complete documentation index, see llms.txt.Use this guide to decide whether Pipedream, Xquik, or both fit a workflow that needs X/Twitter data, account actions, alerts, exports, webhooks, API calls, or custom component code.
For the complete documentation index, see llms.txt.Use this guide to decide whether Post Bridge or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Postproxy or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Postwise or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.## Distinct SocialCrawl Fit SocialCrawl centers on normalized social data across many networks. Its envelope, computed fields, credit tiers, OpenAPI, and agent packages matter most. Use this page when multi-platform collection outranks X-specific depth. Use this guide to decide whether SocialCrawl or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Sprinklr or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Sprout Social or Xquik fits the X part of a social media management workflow: plan posts, manage a Smart Inbox, analyze reports, search tweets, export followers, monitor accounts or keywords, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Talkwalker or Xquik fits the X part of a social listening, consumer intelligence, or social media analytics workflow: search tweets, export followers, monitor accounts or keywords, send webhooks, and hand records to apps, warehouses, or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Taplio or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.## Distinct TryPost Fit TryPost centers on open-source scheduling, cloud or self-hosting, workspaces, and 10 social networks. It differs from creator-growth tools and direct official API access. Compare its calendar, hosting, REST, and MCP paths before choosing it. Use this guide to decide whether TryPost or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.## Distinct Tweet Hunter Fit Tweet Hunter centers on creator growth, AI writing, scheduling, Auto-DMs, analytics, and CRM. It differs from profile analytics, automation feeds, and real-time tweet and follower services. Choose this comparison when the output stays inside a creator workflow. Use this guide to decide whether Tweet Hunter or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether TweetDeck, now X Pro, or Xquik fits the X job: monitor live columns, search X, compose or schedule posts, export followers, run tweet search, deliver signed webhooks, or hand records to apps and agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether TweetStream or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.## Distinct Twitter API Pro Fit This page treats Twitter API Pro as a legacy comparison term. It focuses on direct official API access, credentials, pagination, and usage billing. Use the broader X API page for the current baseline. Use this guide to decide whether Twitter API Pro or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether twscrape or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Typefully or Xquik fits a creator publishing workflow: write X threads, schedule posts, cross-post content, use AI writing help, inspect analytics, search tweets, export followers, monitor accounts or keywords, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this Twitter API alternative and pricing guide to compare real X tasks: search tweets, export followers and replies, retrieve profiles and timelines, post tweets, send direct messages, monitor accounts or keywords, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Xanguard or Xquik is better for specific X tasks: search tweets, export followers, monitor accounts or keywords, publish actions, send webhooks, and connect apps or agents.
For the complete documentation index, see llms.txt.Use this guide to decide whether Zapier, Xquik, or both fit a workflow that needs X/Twitter data, account actions, alerts, exports, webhooks, API calls, or downstream app automation.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## 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](/api-reference/styles/analyze) 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.
For the complete documentation index, see llms.txt.## Choose Credential Creation Use this route only when creating a new credential. `fullKey` appears at creation, so store it immediately in a secret manager. List operations return inventory data and never replace this storage step.
For the complete documentation index, see llms.txt.## Audit Xquik API Keys Before X Automation List every Xquik key registered to the signed-in account. Review keys before running tweet searches, follower exports, webhooks, monitors, or X writes. This endpoint returns key inventory metadata. It never returns a complete API key. Use `id` for revocation and `prefix` for safe identification. The key list answers 5 operational questions: * Which named Xquik keys exist on this account? * Which keys are active or revoked? * When was each key created? * When did each key last authenticate a request? * Which key ID should a rotation workflow revoke?
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.Authenticate tweet, follower, monitor, webhook, and write requests with an Xquik API key. This REST API authentication guide also covers guest keys, OAuth 2.1, sessions, and MPP. Xquik keys authenticate Xquik endpoints only. They are not an official Twitter API key or X API token. Choose the narrowest method that covers the route. ## API Key Format Account and guest keys follow this format: ```text theme={null} xq_your_api_key_here ``` * **Prefix:** `xq_` * **Body:** 64 hexadecimal characters * **Storage:** Keep each REST API key in a secret manager. Never log or commit it. ## Using your API key Send account API requests with the `x-api-key` request header:
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Choose A Billing Checkpoint Use this route for a read-only billing checkpoint. It returns current balance, lifetime totals, and automatic top-up settings. Use purchase and status routes only after deciding to add credits. ## Check Credits Before Tweets, Followers, or Monitors Read the current balance before starting a large tweet search, follower export, reply export, active monitor, or X write. Compare the balance with the route's documented credit cost. Reduce the requested result count when the available balance cannot cover the full job. Keep `balance`, `lifetime_purchased`, and `lifetime_used` as strings. These values can exceed JavaScript's safe integer range. Convert them with a bigint library only when the client supports exact arithmetic. Review automatic top-up fields separately. `auto_topup_enabled` reports whether automatic funding is active. The threshold and dollar amount describe when and how much the account adds. This endpoint never charges a payment method. Use standard top-up for a hosted checkout. Use quick top-up only after the account has a saved payment method. Poll standard checkout status with the checkout session ID.
For the complete documentation index, see llms.txt.Add X API credits for tweet, follower, monitor, webhook, export, and write calls. Use this Twitter API billing route with an existing saved payment method. ## Add API Credits With a Saved Payment Method Use quick top-up when the account already has a reusable payment method. Send a USD amount from 10 through 500. The route funds tweet, profile, follower, monitor, webhook, export, and X write requests without creating a hosted checkout page. Read `outcome` before handling any other response field. `charged` means the credits and new balance are ready. `requires_action` means the client must complete the payment confirmation flow. Another outcome can require adding a payment method first. Never print or persist `clientSecret`. Pass it directly to the payment confirmation flow. Log only the outcome, added credits, and resulting balance after a successful charge. Quick top-up differs from standard checkout status. The status route polls a hosted checkout session by `session_id`. This route returns its own immediate payment outcome for the saved payment method.
For the complete documentation index, see llms.txt.## Choose Hosted Checkout Use this route when the buyer needs a hosted checkout. Use quick top-up for a saved payment method. Use top-up status only to poll an existing checkout session. Store the checkout reference before redirecting the user.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Save a Tweet Draft Before Publishing Create one private tweet draft inside your authenticated Xquik account. Supply the proposed text and optional composition context. The response returns a stable Xquik draft ID for review or deletion. This request does not publish a tweet. It sends nothing to followers and creates no replies, reposts, likes, impressions, or public tweet ID. Xquik drafts are separate from [X's native Unsent posts](https://help.x.com/en/using-x/how-to-post). Creating a record here does not add anything to the X compose interface.
For the complete documentation index, see llms.txt.## Delete One Saved Tweet Draft Delete one tweet draft from your Xquik account. The request removes its saved text, optional topic, optional goal, and timestamps. It does not publish the draft or call an X write route. This endpoint manages Xquik draft records only. It does not manage drafts under [X's native Unsent posts](https://help.x.com/en/using-x/how-to-post). It also does not delete published tweets, scheduled posts, or connected X accounts. Use the draft ID returned by [Create Draft](/api-reference/drafts/create) or [List Drafts](/api-reference/drafts/list). Fetch the draft before deletion when its text must receive human approval.
For the complete documentation index, see llms.txt.## Retrieve One Tweet Draft by ID Retrieve one saved tweet draft from your Xquik account. The response contains its ID, text, optional topic, optional goal, and timestamps. It does not return thread order, media attachments, reply targets, or publishing results. Use the ID returned by [Create Draft](/api-reference/drafts/create) or [List Drafts](/api-reference/drafts/list). This route reads that record without creating, changing, publishing, or deleting it. Xquik drafts are separate from [X's native Unsent posts](https://help.x.com/en/using-x/how-to-post). This endpoint cannot retrieve drafts stored inside the X compose interface.
For the complete documentation index, see llms.txt.## List Saved Tweet Drafts List tweet drafts stored in your authenticated Xquik account. Each result contains saved text, an optional topic, an optional goal, and timestamps. Use this route to build a draft inventory or review queue. It returns drafts newest first and supports cursor pagination. The route never publishes draft text or sends it to followers. Xquik drafts are separate from [X's native Unsent posts](https://help.x.com/en/using-x/how-to-post). This API cannot list drafts saved inside the X compose interface.
For the complete documentation index, see llms.txt.Use this Twitter giveaway picker API to select primary and backup winners. Filter replies by reposts, follows, keywords, hashtags, mentions, or language. Add account-age, follower-count, or unique-author rules.
For the complete documentation index, see llms.txt.Download a Twitter giveaway winner list or inspected reply entries. Choose CSV, XLSX, JSON, Markdown, PDF, or plain text. Preserve the returned filename and exact row order for every handoff. Use `type=winners` for selected primary and backup winners. Use `type=entries` for every stored reply inspected during the draw. Entry exports include passing and failing replies. ## Export Twitter Giveaway Winners or Entries Choose the export type before choosing its file format. The two export types contain different columns and answer different review questions.
For the complete documentation index, see llms.txt.Retrieve one Twitter giveaway result with its draw ID. Inspect the source tweet snapshot, candidate counts, timestamps, and ordered winner rows. Separate primary winners from backup winners before publishing results. This endpoint does not return create-time eligibility rules or exclusion reasons. Preserve the original `POST /draws` request when an audit needs those rules. ## Verify One Twitter Giveaway Draw Use this route to review one completed or pending draw. Keep its draw ID with winner announcements, support records, and exports.
For the complete documentation index, see llms.txt.List every Twitter giveaway draw owned by the authenticated Xquik account. Review source tweets, draw statuses, entry counts, and completion times. Continue through older results with an opaque cursor. This endpoint returns draw summaries. It does not return winner objects or eligibility rules. Retrieve one draw when winner verification needs those details.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.Create a prepaid read wallet without an account, email address, or dashboard. This endpoint creates a one-use hosted checkout after the user confirms a USD amount. It does not charge the user.
For the complete documentation index, see llms.txt.Poll this endpoint after the user completes hosted checkout. The guest key can authenticate this status route while the wallet is pending, but it cannot call paid read routes until payment is verified.
For the complete documentation index, see llms.txt.Add credits to an existing guest wallet. The wallet keeps the same `paid_reads` key. This endpoint creates a one-use hosted checkout only after the user confirms the amount. It does not charge the user.
For the complete documentation index, see llms.txt.Create a Twitter account monitor for one known profile. Select tweet, profile, or availability events. Store the monitor ID. Then connect signed webhooks.
For the complete documentation index, see llms.txt.Create a Twitter keyword monitor when one search query needs continuous tweet checks. Track brand mentions, handles, hashtags, products, campaigns, replies, reposts, links, or media. Store its ID, query, event types, billing time, and webhook destinations.
For the complete documentation index, see llms.txt.Delete a keyword monitor only when its tweet query should stop permanently. Pause it instead when future monitoring might resume.
For the complete documentation index, see llms.txt.This endpoint deletes one saved Xquik account monitor. It stops future tweet and profile checks. It removes stored events and linked webhook delivery records. The tracked X account and its profile remain unchanged. Its tweets, followers, and following list also remain unchanged.
For the complete documentation index, see llms.txt.## Inspect One Twitter Keyword Monitor Use this route when a workflow already stores one keyword monitor ID. It returns the exact X search query, tracked tweet events, active state, creation time, and next billing checkpoint. Use the list route when the ID is unknown. Check `query` before routing new matches. It preserves the Twitter keyword search that created the monitor. Check `eventTypes` before assuming replies, quotes, reposts, or other tweet events are enabled. | Single-monitor question | Response field | Incident decision | | ---------------------------- | ----------------------------------- | ---------------------------------------------------- | | Is this the intended search? | `id` and `query` | Stop if either value differs from the stored alert. | | Can it capture new tweets? | `isActive` | Resume only when future polling is required. | | Which tweet events qualify? | `eventTypes` | Compare the exact types with webhook subscriptions. | | When is the next charge? | `nextBillingAt` | Confirm credits before the billing checkpoint. | | Where are matching tweets? | `GET /events?keywordMonitorId={id}` | Inspect stored events separately from configuration. | Store `id`, `query`, `eventTypes`, `isActive`, and `nextBillingAt` together. Pass the same monitor ID to event filters, updates, deletion, and webhook workflows. This keeps every Twitter monitor handoff tied to one tracked search. Use this status check before pausing or editing a monitor. A successful read does not prove a matching tweet exists. Read the events endpoint for captured tweets, then open one event for its complete payload.
For the complete documentation index, see llms.txt.## Inventory Every Twitter Account Monitor Use `GET /monitors` to monitor multiple Twitter accounts. It returns one complete account-monitor inventory. The route lists every account monitor that belongs to the signed-in user. Each row identifies one tracked X profile. It also shows enabled tweet or profile events and the active state. The row includes its creation time. Check `nextBillingAt` for the next active-monitor charge. Use the single-monitor route for one known ID. Group rows by `username` or stable `xUserId`. Keep `eventTypes` with every row because two monitors can track different changes. Separate inactive monitors before calculating which profiles still produce events. Store `monitorId` before handing a row to event or webhook processing. Event queries use that ID to isolate tweets and profile changes. Webhook deliveries remain separate from monitor inventory. Review `nextBillingAt` before enabling more monitors. Listing is free, but active monitors consume credits each hour. Delete unused monitors. Do not call a monitor idle after one empty event window.
For the complete documentation index, see llms.txt.## Reconcile the Entire Keyword Monitor Portfolio Use this endpoint when the exact monitor ID is unknown. It returns up to 200 stored searches plus `total`. It does not paginate the inventory. | Portfolio check | Inventory calculation | Reconciliation decision | | ---------------------- | -------------------------------------- | -------------------------------------------------------- | | Active searches | Count `monitors[].isActive === true` | Include only active rows in current polling reviews. | | Paused searches | Count `monitors[].isActive === false` | Preserve them for history or later reactivation. | | Duplicate queries | Group by normalized `monitors[].query` | Compare `eventTypes` before treating rows as duplicates. | | Webhook gaps | Compare every `eventTypes` array | Add only missing receiver subscriptions. | | Billing order | Sort active `nextBillingAt` values | Review the nearest credit checkpoints first. | | Inventory completeness | Compare `monitors.length` with `total` | Escalate when the returned collection is incomplete. | Use the detail endpoint only after choosing one monitor ID from this inventory.
For the complete documentation index, see llms.txt.## Check One Twitter Account Activity Tracker Use this route for one Twitter account activity tracker status check. It returns the tracked X profile, selected event types, active state, and billing timing. Use update to change event filters or pause the monitor. Use list for the complete monitor inventory.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Choose Keyword Monitor Updates Use this route to change one keyword monitor's event types or active state. Use get for a read-only checkpoint. Use list for account-wide keyword monitor inventory.
For the complete documentation index, see llms.txt.Use Xquik as a Twitter API alternative for public reads and automated actions. Use it as an X API alternative across REST, SDKs, webhooks, and MCP. These Twitter API docs cover authentication, public reads, automated writes, and webhooks. Use this Twitter API documentation as a practical Twitter API for developers. It covers tweets, profiles, followers, replies, monitors, and media. Search tweets with the Twitter search API. Export user tweets, replies, followers, following, user profiles, timelines, communities, lists, and media. Post tweets and monitor accounts in real time. Deliver signed webhook events from the same API. Use the tweet scraping API to search recent and top tweets. Use the follower scraping API to export follower and following profiles. Use tweet reply scraping to retrieve conversations and authors. Use the Twitter webhook API to receive signed monitor events.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Choose A New Support Ticket Use this route to open a new conversation with support. Send JSON for text-only tickets and multipart data for attachments. Use reply only after the response provides a ticket ID.
For the complete documentation index, see llms.txt.## Choose One Ticket History Use this route when one ticket ID needs full message history. Use list for summaries across tickets. Use reply or update only when the conversation or status must change.
For the complete documentation index, see llms.txt.## List Support Tickets for Xquik Workflows List the signed-in account's Xquik support tickets. Review connection failures, tweet write errors, follower exports, monitor alerts, webhooks, or billing cases. This endpoint returns the documented ticket summary fields. Fetch [Get Ticket](/api-reference/support/get) when you need message bodies or attachment metadata.
For the complete documentation index, see llms.txt.Support attachments stay private. Every download requires authentication and access to the parent ticket.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Use the Top-Level Twitter Trends API `GET /trends` is Xquik's top-level alias for ranked WOEID topics. It returns `total`; `/x/trends` returns `count` instead. Keep one response shape throughout each client.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Choose One Account Health Check Use this route as a health gate before one connected-account write. Read health, recovery, and credential state before selecting the next action. Use list only for account-wide inventory.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## How to Create a Community on Twitter with Xquik Call `POST /x/communities` to create a community on Twitter from one connected account. This create Twitter community workflow submits a name and optional description. Xquik then tracks the write until X returns a final result. Use this route only when the account should own a new community. Use join or leave routes for an existing community. This route does not add rules, members, moderators, invitations, posts, analytics, or membership settings. Each community gives one topic a dedicated space on X. People can search for communities by name, description, or creator. They can join a community later. Each member of the community follows the chosen membership type and community rules. This X social media workflow creates the community container only.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## How to Delete a Twitter Community Through REST Call `DELETE /x/communities/{id}` for one community owned by a connected account. Send its exact `community_name` as a confirmation safeguard. This route removes the community, not the connected X account. This route explains how to delete a Twitter Community through one tracked deletion action. It also shows how to delete Twitter Community records safely. Use [Leave Community](/api-reference/x-write/leave-community) to remove one account's membership. Use [Delete Tweet](/api-reference/x-write/delete-tweet) to remove one owned Community post.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## Follow One Twitter User by ID Use this Twitter API follow endpoint for 1 target user ID. Each Twitter API follow user request names 1 connected X account. Verify the target user ID. Approve the acting account before sending the action. Compare X's separate [Follow User endpoint](https://docs.x.com/x-api/users/follow-user).
For the complete documentation index, see llms.txt.Every X write returns a durable `x_write_action` record. Store its `id` or `writeActionId`. Poll `statusUrl` whenever `terminal` is `false`. ## Handle Twitter API Errors Use this endpoint for Twitter API error handling after an Xquik write. Xquik adds a durable write record beside ordinary HTTP response codes. An error message does not prove that a write failed. A timeout can occur after dispatch. Trust `terminal`, `safeToRetry`, `sendDispatched`, and `nextAction`. Review X's [response codes and errors](https://docs.x.com/x-api/fundamentals/response-codes-and-errors). Xquik's write status record uses different fields.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## How to Leave a Community on Twitter via API Call `DELETE /x/communities/{id}/join` to remove one connected account's membership. Other members keep access to the Community. Xquik tracks the departure as a write action. This route does not delete the Community. It does not delete the connected Twitter account. It also does not remove Community posts or replies. Use [Delete Community](/api-reference/x-write/delete-community) only for an owned Community that should close. Use [Delete Tweet](/api-reference/x-write/delete-tweet) for an owned post that should disappear.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## 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.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.## 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](https://docs.x.com/x-api/users/unfollow-user).
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.Use this Twitter profile picture API to update one connected account's avatar. Choose this Twitter API profile image route for automated avatar changes. A Twitter API update profile image request accepts a JPEG or PNG file. It may also use a fetchable HTTPS image URL. The maximum image size is 700 KB. X recommends a 400 × 400 pixel profile picture. ## Update a Twitter Profile Picture Through the API Call `PATCH /x/profile/avatar` to replace the square profile image. Use [Update Banner](/api-reference/x-write/update-banner) for the header image. Use [Update Profile](/api-reference/x-write/update-profile) for names and other public text fields. This route never retrieves another user's avatar.
For the complete documentation index, see llms.txt.Use this Twitter profile banner API to update one connected account's header image. Upload a JPEG or PNG file, or provide a fetchable HTTPS image URL. The maximum file size is 2 MB. X recommends 1500 × 500 pixels for profile banners. ## Update a Twitter Profile Banner Through the API Call `PATCH /x/profile/banner` to replace the wide header image. Use [Update Avatar](/api-reference/x-write/update-avatar) for the profile picture. Use [Update Profile](/api-reference/x-write/update-profile) for names and other public text fields. This route never retrieves another user's banner.
For the complete documentation index, see llms.txt.Use this Twitter profile update API for public profile text. Change a display name, bio, location, or website in one request. Send only the fields that need new values. Omitted fields remain unchanged. The connected account receives every approved change. This route does not change a username, avatar, banner, or birth date. Use [Update Avatar](/api-reference/x-write/update-avatar) or [Update Banner](/api-reference/x-write/update-banner) for profile images. Read X's [profile customization guide](https://help.x.com/articles/166743) before updating profile text. ## Update Twitter Profile Text Call `PATCH /x/profile` to update Twitter profile fields programmatically. Provide the connected account plus at least one supported field. The `name` field changes the display name, not the `@username`. The `description` field changes the public bio. The `location` and `url` fields change their matching public labels.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.Follow Xquik documentation updates for tweet search, follower exports, monitors, webhooks, and SDKs. Track API keys and signed webhook deliveries. Search tweets and review user profile updates. Use this Xquik changelog to review REST, MCP, authentication, billing, and write changes.
For the complete documentation index, see llms.txt.[AG2](https://github.com/ag2ai/ag2) is an open-source Python framework for multi-agent systems. AG2 1.0.0 and later ship `XquikSearchToolkit` in `ag2.extensions.tools.search`, so Xquik tweet search reaches AG2 agents without a community adapter. AG2 documents the toolkit in its [Xquik Tweet Search reference](https://docs.ag2.ai/docs/user-guide/extensions/tools/search/xquik/). Preserve every tweet ID and cursor the API returns. ## Why Use AG2 With the Xquik Twitter API? AG2 binds search parameters when a tool is constructed, not when the model calls it. The agent chooses the query. You choose the window, the ordering, and the result limit. | Boundary | AG2 control | Benefit | | ----------------- | ------------------------- | ---------------------------------------------------------------------- | | Tool construction | `XquikSearchToolkit(...)` | Fix `query_type`, `limit`, and time windows outside model control | | Model surface | Single `query` argument | The model cannot widen the search window or result limit | | Runtime scope | `Variable` | Resolve per-user or per-tenant values at execution time | | Delegation | `Agent.as_tool()` | Keep the searcher's tool-call history out of the coordinator's context | | Transport | `base_url`, `timeout` | Point at a proxy or tighten deadlines per deployment | This suits research, monitoring, and reporting agents. Use direct REST for deterministic jobs that need no model decisions. ## AG2 Twitter API Prerequisites * Python 3.10 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * An LLM provider key supported by AG2 Public X reads need no X Developer credentials. Authenticate with Xquik. ## Install AG2 ```bash theme={null} python -m pip install "ag2>=1.0.0" ``` `XquikSearchToolkit` calls the Xquik REST API over `httpx`, which AG2 already depends on. No extra package is required. Install your model provider extra as well. ```bash theme={null} python -m pip install "ag2[anthropic]>=1.0.0" ``` Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE ANTHROPIC_API_KEY=YOUR_ANTHROPIC_KEY ``` ```text .gitignore theme={null} .env ``` ## Register the Xquik Tweet Search Tool Passing the toolkit to an agent registers one tool, `xquik_tweet_search`. It takes a single `query` argument holding an X search string. ```python theme={null} import asyncio import os from ag2 import Agent from ag2.config import AnthropicConfig from ag2.extensions.tools.search import XquikSearchToolkit from dotenv import load_dotenv load_dotenv() config = AnthropicConfig(model="claude-sonnet-4-6") agent = Agent( "x-researcher", prompt=( "Search X for evidence before answering. " "Quote tweet text verbatim and keep every tweet ID you receive." ), config=config, tools=[XquikSearchToolkit(api_key=os.environ["XQUIK_API_KEY"])], ) async def main() -> None: reply = await agent.ask("What are developers saying about the Xquik API this week?") print(reply.body) asyncio.run(main()) ``` `api_key` is required. The toolkit raises `ValueError` when it is empty, so a missing key fails at construction rather than on the first search. ## Bind the Search Window Outside Model Control Search defaults belong on the constructor. The model then cannot widen the window or raise the result limit. ```python theme={null} toolkit = XquikSearchToolkit( api_key=os.environ["XQUIK_API_KEY"], query_type="Latest", # "Latest" or "Top" limit=50, since_time="2026-01-01T00:00:00Z", until_time="2026-02-01T00:00:00Z", ) ``` | Parameter | Type | Purpose | | ------------ | --------------------- | ----------------------------------------------- | | `query_type` | `"Latest"` \| `"Top"` | Result ordering | | `limit` | `int` | Upper bound on returned results | | `since_time` | `str` | Start of the time window | | `until_time` | `str` | End of the time window | | `cursor` | `str` | Resume from a prior page | | `base_url` | `str` | Defaults to `https://xquik.com` | | `timeout` | `float` | Request deadline in seconds, defaults to `60.0` | The same parameters are available on the `search()` factory method when you want several differently scoped tools from one toolkit. ```python theme={null} toolkit = XquikSearchToolkit(api_key=os.environ["XQUIK_API_KEY"]) latest = toolkit.search( query_type="Latest", limit=50, name="search_latest_posts", description="Search the newest public X posts.", ) top = toolkit.search( query_type="Top", limit=20, name="search_top_posts", description="Search the highest-engagement public X posts.", ) agent = Agent("analyst", config=config, tools=[latest, top]) ``` ## Read the Structured Result `xquik_tweet_search` returns a typed response rather than a raw payload. | Field | Type | Meaning | | --------------- | ------------ | -------------------------------------------- | | `query` | `str` | The query that was searched | | `tweets` | `list[dict]` | Tweet records exactly as returned by the API | | `has_next_page` | `bool` | Whether another page exists | | `next_cursor` | `str` | Cursor for the next page, empty when absent | Tweet records pass through unmodified, so every tweet ID, profile ID, and timestamp survives the hop into the agent. Feed `next_cursor` back through the `cursor` parameter to continue pagination. ## Resolve Values at Runtime With Variables Every runtime parameter accepts an AG2 `Variable`. AG2 resolves it from the run context when the tool executes, so one tool instance serves many users or tenants. ```python theme={null} from ag2.annotations import Variable toolkit = XquikSearchToolkit( api_key=os.environ["XQUIK_API_KEY"], since_time=Variable("window_start"), until_time=Variable("window_end"), limit=Variable("page_size"), ) ``` ## Delegate Search in a Multi-Agent Team `Agent.as_tool()` exposes an agent as a tool for another agent. Each delegated task runs on its own stream with its own history. The coordinator receives the delegate's final answer, not its internal tool-call history. ```python theme={null} searcher = Agent( "searcher", prompt="Search X and return tweet text with IDs. Do not summarise.", config=config, tools=[XquikSearchToolkit(api_key=os.environ["XQUIK_API_KEY"], query_type="Latest", limit=50)], ) analyst = Agent( "analyst", prompt="Turn tweet records into a factual brief. Keep every tweet ID.", config=config, ) coordinator = Agent( "coordinator", prompt="Delegate the search, then pass the tweets to the analyst.", config=config, tools=[ searcher.as_tool(description="Search public X posts and return raw tweet records."), analyst.as_tool(description="Analyse tweet records. Pass them in the context parameter."), ], ) reply = await coordinator.ask("Brief me on this week's discussion of X API pricing.") print(reply.body) ``` ## Handle Failures The tool raises on non-success HTTP status codes through `httpx`. Read [Error Handling](/guides/error-handling) for status semantics and [Rate Limits](/guides/rate-limits) for retry guidance. Wrap the toolkit with AG2 tool middleware when you need retries, approval gates, or audit logging around every search. ## Related Guides * [AG2 Xquik Tweet Search reference](https://docs.ag2.ai/docs/user-guide/extensions/tools/search/xquik/) # Platform Architecture | X API Workflow Guide Source: https://docs.xquik.com/guides/architecture Learn how Xquik searches tweets, exports followers, monitors accounts, signs webhooks, isolates accounts, and enforces API rate limits. Follow exact steps.
For the complete documentation index, see llms.txt.Xquik is a hosted service for tweet search, follower exports, profile lookup, monitors, webhooks, and X account actions.
For the complete documentation index, see llms.txt.Compare Twitter API pricing and X API pricing with Xquik. Read the [Twitter API alternative and pricing guide](/alternatives/x-api). This page covers Xquik API pricing for tweet search and follower exports. It covers replies, profiles, timelines, monitors, webhooks, and write actions.
For the complete documentation index, see llms.txt.Use this Twitter monitoring API for support, marketing, research, or agent pipelines. It handles fresh X activity. It combines 2 Twitter monitoring tools: account monitors and keyword monitors. Choose the right Twitter monitoring tool for one profile or one search query. Monitor Twitter mentions, deliver matching events to a signed Twitter webhook, and replay stored events. Use one keyword monitor to monitor Twitter keywords and campaign phrases. Use one account monitor to monitor Twitter account activity from a known profile. Route mentions of your brand into support and community management queues. Measure engagement metrics from unique tweets and authors. Review each match before marketing teams create content or replies.
For the complete documentation index, see llms.txt.Use this workflow when a campaign needs one reviewable row per participant. Choose the narrowest check first. Use a draw when winners need selection. Campaign verification separates entry collection, rule checks, winner selection, and publication. Store one campaign ID across every stage. Keep source Tweet IDs, participant user IDs, filters, cursors, timestamps, and verification states. Running a giveaway without these checkpoints makes later review unreliable.
For the complete documentation index, see llms.txt.Migrate a Composio Twitter MCP workflow without losing tweet IDs, followers, replies, or cursors. Preserve webhooks and write confirmations. Find Xquik REST routes through `explore`. Run approved calls through `xquik`. Composio still supports MCP sessions. Choose Xquik for follower exports and monitors. ## Evaluate Composio Alternatives for Twitter MCP Composio AI connects users to pre-built tools, handles OAuth, and exposes AI tools through MCP. The question "what is Composio AI?" needs three checks: authorization, transport, and execution. This guide compares AI workflow tools, not enterprise AI automation. Platforms for building custom AI agents still need X authorization, tweet fields, and retries. AI-powered workflow builders change only orchestration. Open-source AI agent development does too. Need a Composio open source alternative? Compare broader platforms. For Twitter, Xquik is a Twitter API alternative and X API alternative. Xquik covers tweets, followers, replies, profiles, timelines, monitors, and webhooks. Compare Composio MCP alternatives and Composio dev alternatives with these checks: * **Auth:** Record OAuth ownership. Map each application user to one X profile. * **Tools and APIs:** Record tool calls, API endpoints, and side effects. Choose unified APIs or a direct REST API. * **Agent safety:** Reapprove permissions. Test developer experience through SDK typing, logs, documentation, and rollbacks. * **Workflow safety:** Validate API calls and user profile scope in every AI assisted social media workflow. * **API docs:** Can developers find the integration platform's API documentation? * **Rollback:** Can operators run production-ready rollback steps? * **Commercial fit:** Compare pricing, features, free tier, and white-label consent. Never choose an automation tool by its free tier alone. * **Freshness:** Measure real time claims. Name every data sync: tweets, profiles, followers, or events. Compare Twitter automation tools by reads, exports, monitors, webhooks, and approved writes. ## Compare Current MCP Models
| Capability | Composio session | Xquik |
|---|---|---|
| MCP endpoint | Create a user session. | Configure the Xquik API MCP server once. |
| Endpoint access | Read session.mcp.url and session.mcp.headers. |
Complete OAuth or send a supported API key. |
| X account | Scope the session to a user and connection. | Bind each credential to one application user or tenant. |
| Route discovery | Load Twitter toolkit schemas through the session. | Use explore to find current Xquik REST routes. |
| Reads and exports | Call the matching action. | Use xquik, REST, or an extraction job. |
| Account actions | Approve each action, then run it for the connected account. | Require approval and confirm the terminal result. |
For the complete documentation index, see llms.txt.Build a CrewAI MCP integration through Xquik's remote Twitter MCP server. Give CrewAI agents controlled tweet searches, profiles, follower exports, monitors, and reviewed X actions. Preserve every tweet ID, profile ID, cursor, and job ID. ## Why Use CrewAI With MCP for a Twitter API? CrewAI offers an agent framework for complex tasks. Give each agent one role. Xquik supplies Twitter API operations through `explore` and `xquik`. | Boundary | CrewAI control | Benefit | | ---------- | -------------------------- | -------------------------------------------------- | | Remote MCP | `MCPServerHTTP` | Reach tweet, profile, follower, and monitor routes | | Handoff | Pydantic `output_pydantic` | Reject malformed tweets and cursors | | Sequence | `Process.sequential` | Pass exact tweets between specialists | | Discovery | Static tool filter | Expose schemas without execution | | Review | Tool-free task | Review X actions before writes | | Failures | `has_tool_failures` | Stop incomplete research | This CrewAI multi agent pattern fits research, verification, and reporting. Use direct REST for deterministic jobs without model decisions. ## CrewAI Twitter API Prerequisites * Python 3.10 through 3.13 * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * An LLM provider key supported by CrewAI * A connected X account for private reads or X write actions Public X reads need no X Developer credentials. Authenticate with Xquik. Connect an X account only for routes that require one. ## Install CrewAI MCP Support CrewAI core includes a native MCP client. This CrewAI Python setup needs no custom adapter. ```bash theme={null} python -m pip install "crewai>=1.15,<1.16" ``` CrewAI 1.15 requires MCP 1.28. Avoid MCP 2.x with this release. Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE OPENAI_API_KEY=YOUR_OPENAI_KEY ``` ```text .gitignore theme={null} .env xquik-*-handoff.json ``` ## Build a Typed CrewAI Tweet Search Agent Start with the expected output, then build the task. CrewAI validates the final handoff against its Pydantic model. ```python theme={null} import os from pathlib import Path from typing import Literal from crewai import Agent, Crew, Process, Task from crewai.mcp import MCPServerHTTP from pydantic import BaseModel class TweetRow(BaseModel): tweet_id: str text: str author_username: str | None created: int | None url: str | None class TweetSearchHandoff(BaseModel): query: str route_used: Literal["GET /api/v1/x/tweets/search"] tweets: list[TweetRow] has_more: bool next_cursor: str | None pages_fetched: int stop_reason: Literal[ "complete", "requested_limit", "cursor_stalled", ] xquik_mcp = MCPServerHTTP( url="https://xquik.com/mcp", headers={"x-api-key": os.environ["XQUIK_API_KEY"]}, streamable=True, cache_tools_list=True, ) researcher = Agent( role="Twitter API Researcher", goal="Return exact tweet records and resumable pagination state", backstory=( "You inspect Twitter conversations through documented Xquik routes. " "You preserve source IDs and never invent missing fields." ), llm="openai/gpt-5", mcps=[xquik_mcp], allow_delegation=False, verbose=False, ) search_task = Task( description=( "Use GET /api/v1/x/tweets/search. " "Search 50 latest tweets about CrewAI Twitter MCP. " "Preserve exact tweet IDs, created timestamps, and cursors. " "Stop at the requested limit. Stop if a cursor repeats." ), expected_output="A validated tweet search handoff with pagination state.", agent=researcher, output_pydantic=TweetSearchHandoff, ) crew = Crew( agents=[researcher], tasks=[search_task], process=Process.sequential, verbose=False, ) result = crew.kickoff() if result.has_tool_failures: raise RuntimeError("Twitter MCP tool failed. Inspect result.tool_failures.") handoff = TweetSearchHandoff.model_validate(result.to_dict()) Path("xquik-crewai-handoff.json").write_text( handoff.model_dump_json(indent=2), encoding="utf-8", ) ``` `Agent.mcps` discovers CrewAI MCP tools before execution. `MCPServerHTTP` uses Streamable HTTP by default. The MCP runtime returns normalized snake\_case fields through `xquik.request()`. It maps `createdAt` to the Unix-second field `created`. Always inspect `has_tool_failures`. Never pass incomplete results into follower exports or X actions. ## Search Tweets With Focused Queries Send a precise `q`. Keep the exact query in the handoff. | Intent | Example `q` | | ------------------------ | -------------------------------------------------- | | Framework posts | `"CrewAI" MCP` | | Account timeline | `from:crewAIInc since:2026-07-01 until:2026-08-01` | | Twitter API Python posts | `"Twitter API" Python lang:en min_faves:25` | | Questions | `"multi-agent workflow" ? -filter:retweets` | Use `queryType=Latest` for real time monitoring. Use `Top` for engagement-ranked research. See the [tweet search API contract](/api-reference/x/search-tweets). Pass `next_cursor` unchanged. Stop when `has_more` is false or cursors repeat. Continue empty pages with true `has_more`. Deduplicate by `tweet_id`. ## Build a Role-Based Tweet Research Crew Give only the researcher access to Twitter MCP search tools. Feed its validated task into a tool-free analyst. ```python theme={null} class TweetAnalysis(BaseModel): query: str analyzed_tweet_ids: list[str] recurring_topics: list[str] top_author_usernames: list[str] next_cursor: str | None analyst = Agent( role="Tweet Conversation Analyst", goal="Analyze only the supplied tweet rows", backstory="You compare exact tweets without fetching extra records.", llm="openai/gpt-5", allow_delegation=False, verbose=False, ) analysis_task = Task( description=( "Analyze the supplied tweet rows. " "Keep every analyzed tweet_id. Preserve the next_cursor." ), expected_output="A typed topic analysis tied to source tweet IDs.", agent=analyst, context=[search_task], output_pydantic=TweetAnalysis, ) research_crew = Crew( agents=[researcher, analyst], tasks=[search_task, analysis_task], process=Process.sequential, verbose=False, ) ``` The `context` list passes the first result into the second. The analyst cannot fetch unrelated tweets or profiles. Choose hierarchical delegation when specialists work independently. Use sequential tasks for cursor-dependent agent collaboration. ## Apply CrewAI MCP Integration Patterns Each CrewAI agent with MCP server access gets one permission boundary. Teams of AI agents must not share write-capable keys. This CrewAI MCP integration connects external APIs through synchronized schemas. Prefer CrewAI tools before building a CrewAI custom tool. The `tools` tool list shows permitted agent actions. Review agent tools before each tool integration. `import tool` shortcuts and `def run` wrappers duplicate native MCP behavior. Avoid broad web searches when tweet IDs matter. Set `verbose=True` only while debugging complex tasks. Real world AI applications need safe multi agent systems. ## Keep Twitter Actions Outside the Research Crew The `xquik` tool runs every route allowed by its key. Never give write permissions to autonomous research crews. Use guest `paid_reads` for eligible GET routes. The [guest wallets guide](/guides/guest-wallets) documents this scope. ```python theme={null} class TweetWritePlan(BaseModel): account_id: str text: str reply_to_tweet_id: str | None media_urls: list[str] idempotency_key: str planner = Agent( role="Twitter Action Planner", goal="Prepare one reviewable X action without executing it", backstory="You preserve approved text, target IDs, and account IDs.", llm="openai/gpt-5", tools=[], allow_delegation=False, ) plan_task = Task( description="Prepare a tweet or reply plan from reviewed source tweets.", expected_output="One typed action plan. Do not execute any X request.", agent=planner, output_pydantic=TweetWritePlan, human_input=True, ) ``` `human_input=True` reviews the result, while `tools=[]` blocks execution. After approval, send one REST request. Never retry pending writes automatically. ## Expose Endpoint Discovery Only Expose only `explore` for endpoint discovery. ```python theme={null} from crewai.mcp import MCPServerHTTP from crewai.mcp.filters import create_static_tool_filter discovery_mcp = MCPServerHTTP( url="https://xquik.com/mcp", headers={"x-api-key": os.environ["XQUIK_API_KEY"]}, tool_filter=create_static_tool_filter( allowed_tool_names=["explore"], ), cache_tools_list=True, ) ``` This filter cannot execute Twitter API calls. `explore` returns methods, parameters, and response fields. Adding `xquik` enables authorized execution. ## Use One MCP Configuration Per Tenant Resolve the tenant first. Then create its `MCPServerHTTP` configuration. ```python theme={null} def build_tenant_mcp(user_api_key: str) -> MCPServerHTTP: return MCPServerHTTP( url="https://xquik.com/mcp", headers={"x-api-key": user_api_key}, streamable=True, cache_tools_list=True, ) ``` Never share agents across tenant keys. Keep keys outside prompts, output, memory, traces, and handoffs. Reuse one configuration per crew run. ## Store a Resumable CrewAI Handoff Store identifiers and checkpoints outside task prose.
For the complete documentation index, see llms.txt.Use this workflow for support, sales, community, or agent systems. Read DM history and send direct messages from a connected X account. Xquik reads participant-scoped conversations through `GET /x/dm/{userId}/history`. It sends text DMs through `POST /x/dm/{userId}`. It can attach one uploaded media item through `media_ids`.
For the complete documentation index, see llms.txt.Use each `error` code to choose recovery.
For the complete documentation index, see llms.txt.Run bulk data extractions from X in 5 stages: check credits, estimate costs, run the job, retrieve JSON pages, and export files. Use this workflow to scrape tweets, export followers, pull tweet replies, save CSV/JSON/XLSX files, or hand paginated JSON to a CRM, warehouse, queue, or AI agent. This tweet scraper runs Twitter scraping through documented extraction jobs. Use `reply_extractor` as a Twitter reply scraper for visible reply authors. Use `follower_explorer` as a Twitter follower scraper for profile rows. The follower export API returns CSV, JSON, or XLSX files. Each job returns structured data for tweets, replies, followers, and following. Other jobs cover communities, lists, likes, reposts, quotes, and media posts. Tweet search results can filter authors, dates, engagement, media, relationships, lists, and locations.
For the complete documentation index, see llms.txt.Download a Twitter follower list as CSV, XLSX, or JSON. Keep each Twitter profile ID, username, bio, verification status, image, and audience count. Import the follower rows into a CRM, spreadsheet, queue, or warehouse.
For the complete documentation index, see llms.txt.Use this X API glossary while reading Xquik API responses and guides. It defines concrete tweet, profile, follower, monitor, webhook, and billing terms. X calls its content objects posts. Xquik keeps `tweet` in public route names. This preserves familiar Twitter API terms and existing client integrations.
For the complete documentation index, see llms.txt.This Google ADK tutorial uses Xquik's remote MCP server. Build a Google ADK Twitter API agent through Xquik using this architecture. This Twitter API for Python workflow searches tweets, profiles, and followers. It also replays monitors and reviews approved X actions. The handoff must preserve tweet IDs, profile IDs, cursors, and job IDs. ## Why Use Google ADK With a Twitter API? Google's Agent Development Kit (ADK) manages Gemini calls, tools, sessions, and agent handoffs. Model Context Protocol, or MCP, defines interoperable tool schemas. Xquik exposes both `explore` and `xquik` as remote MCP tools. This Google ADK guide assigns one responsibility to each boundary. The Agent Development Kit MCP client loads Xquik route schemas during startup. | Boundary | Google ADK control | Twitter agent benefit | | ------------------ | --------------------------------------------- | -------------------------------------------------------------- | | Remote MCP | `McpToolset` | Connect Gemini to tweet, profile, follower, and monitor routes | | Final response | Pydantic `output_schema` | Reject malformed tweet rows and pagination state | | Session continuity | `InMemoryRunner` or a durable session service | Resume with the same tweet IDs and cursors | | Agent handoff | `output_key` and sub-agents | Separate research, review, and publishing | | X actions | `require_confirmation` | Pause before the `xquik` execution tool runs | | Tenant credentials | `header_provider` | Resolve one Xquik key for each tenant | Choose ADK when Gemini already powers the surrounding workflow. Choose a direct REST client for deterministic jobs without model decisions. ## Google ADK Twitter API Prerequisites * Python 3.10 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * A Google AI API key for Gemini * A connected X account for private reads or X write actions Public X reads do not require X Developer credentials. Authenticate with Xquik. Connect an X account only when the selected route requires it. ## Install Google ADK Python and MCP Support Install the current Google ADK 2.6 line with its compatible MCP client. ```bash theme={null} python -m pip install --upgrade \ "google-adk[mcp]>=2.6,<2.7" \ "pydantic>=2.12,<3" \ python-dotenv ``` Google ADK 2.6 requires MCP 1.x. Its `mcp` extra excludes MCP 2.x. Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE GOOGLE_API_KEY=YOUR_GOOGLE_AI_KEY ``` ```text .gitignore theme={null} .env xquik-*-handoff.json ``` The environment variables isolate Xquik and Google credentials from the agent implementation. Never place either key inside an agent instruction. ## Connect Google Agent Development Kit to an MCP Server This Google Agent Development Kit MCP server setup uses Xquik remotely. ADK serves as the MCP client, while Xquik hosts the remote server. `McpToolset` discovers `explore` and `xquik` through standard tool calling. These Google ADK tools cover tweets, profiles, followers, monitors, and X actions. The separation keeps agent workflows independent from route schemas. ## Build a Google ADK Python Tweet Search Agent Define the final handoff before creating the agent. ADK validates the final Gemini response while still allowing MCP tool calls. `from google.adk import Agent` imports the current agent class. This Google ADK Python example validates final responses with Pydantic. The Twitter API get tweets workflow calls the documented search route. ```python theme={null} import asyncio import os from pathlib import Path from typing import Literal from dotenv import load_dotenv from google.adk import Agent from google.adk.runners import InMemoryRunner from google.adk.tools.mcp_tool.mcp_session_manager import ( StreamableHTTPConnectionParams, ) from google.adk.tools.mcp_tool.mcp_toolset import McpToolset from google.genai import types from pydantic import BaseModel class TweetRow(BaseModel): tweet_id: str text: str author_username: str | None = None created: int | None = None url: str | None = None class TweetSearchHandoff(BaseModel): query: str route_used: str tweets: list[TweetRow] has_more: bool next_cursor: str | None = None pages_fetched: int stop_reason: Literal["complete", "requested_limit", "cursor_stalled"] async def main() -> None: load_dotenv() xquik_tools = McpToolset( connection_params=StreamableHTTPConnectionParams( url="https://xquik.com/mcp", headers={"x-api-key": os.environ["XQUIK_API_KEY"]}, timeout=15, sse_read_timeout=120, ), tool_filter=["explore", "xquik"], ) agent = Agent( model="gemini-3.5-flash", name="xquik_tweet_search_agent", instruction=( "Use Xquik for Twitter API requests. " "Use GET /api/v1/x/tweets/search. " "Preserve exact tweet IDs, created timestamps, and cursors. " "Never invent missing tweet fields. " "Stop when the requested limit is reached. " "Stop if the server repeats a cursor." ), tools=[xquik_tools], output_schema=TweetSearchHandoff, ) async with InMemoryRunner( agent=agent, app_name="xquik_adk_app", ) as runner: session = await runner.session_service.create_session( app_name="xquik_adk_app", user_id="user-1", ) final_text = "" async for event in runner.run_async( user_id="user-1", session_id=session.id, new_message=types.Content( role="user", parts=[ types.Part( text=( "Search 50 latest tweets about Google ADK MCP. " "Return compact validated JSON." ) ) ], ), ): if ( event.is_final_response() and event.content and event.content.parts ): final_text = "".join( part.text or "" for part in event.content.parts ) handoff = TweetSearchHandoff.model_validate_json(final_text) Path("xquik-adk-handoff.json").write_text( handoff.model_dump_json(indent=2), encoding="utf-8", ) asyncio.run(main()) ``` The runner closes `McpToolset` when its context exits. Reuse one runner across related turns. Repeated setup adds avoidable MCP handshakes. `xquik.request()` returns normalized snake\_case fields from the MCP runtime. It normalizes `createdAt` to the Unix-second field `created`. Align the Pydantic schema with this response format. ## Search Tweets With Useful X Operators Send the search route a focused `q`. Keep the exact query in the handoff. | Search intent | Example `q` | | ----------------------------- | ---------------------------------------------------- | | Latest topic tweets | `"Google ADK" MCP` | | One account's timeline window | `from:googlecloud since:2026-07-01 until:2026-08-01` | | Popular English posts | `"agent development kit" lang:en min_faves:25` | | Questions without reposts | `"Twitter API agent" ? -filter:retweets` | | Exact tweet | A numeric Tweet ID or X status URL | This Twitter API integration accepts standard X search operators. Use `queryType=Latest` for chronological monitoring. Use `Top` for engagement ranking. See the complete [tweet search API contract](/api-reference/x/search-tweets). The search query `twitter api get tweets` maps to this route. Pass the returned `next_cursor` unchanged. Never reconstruct a cursor. Stop when `has_more` is false, the requested limit is met, or a cursor repeats. ## Separate Tweet Research From X Actions Xquik intentionally exposes one `xquik` execution tool. MCP tool-name filters cannot distinguish GET, POST, and DELETE requests inside that tool. This Google ADK multi agent pattern separates research from publishing. Use separate credentials and confirmation rules across multi agent systems. Use separate ADK agents. Let the research agent read tweets and profiles. Make the publishing agent confirm every `xquik` execution. ```python theme={null} import os from google.adk import Agent from google.adk.tools.mcp_tool.mcp_session_manager import ( StreamableHTTPConnectionParams, ) from google.adk.tools.mcp_tool.mcp_toolset import McpToolset def connection() -> StreamableHTTPConnectionParams: return StreamableHTTPConnectionParams( url="https://xquik.com/mcp", headers={"x-api-key": os.environ["XQUIK_API_KEY"]}, ) research_tools = McpToolset( connection_params=connection(), tool_filter=["explore", "xquik"], ) approved_write_tools = McpToolset( connection_params=connection(), tool_filter=["xquik"], require_confirmation=True, ) researcher = Agent( name="tweet_researcher", model="gemini-3.5-flash", instruction=( "Search tweets and profiles. Preserve IDs, created timestamps, " "has_more, and next_cursor. Never perform X write actions." ), tools=[research_tools], output_key="tweet_research", ) publisher = Agent( name="approved_x_publisher", model="gemini-3.5-flash", instruction=( "Use only reviewed tweet text and the selected X account. " "Never change approved text. Never retry a pending write." ), tools=[approved_write_tools], ) coordinator = Agent( name="twitter_campaign_coordinator", model="gemini-3.5-flash", instruction=( "Delegate tweet research to tweet_researcher. " "Delegate approved X actions to approved_x_publisher." ), sub_agents=[researcher, publisher], ) ``` ADK CLI and ADK Web can present confirmation requests. A custom interface must return ADK's confirmation `FunctionResponse`. Treat confirmation as a product workflow, not a prompt sentence. The safest writer confirms every `xquik` call. A code-string inspection is not a reliable authorization boundary. For public research, a guest `paid_reads` key allows eligible GET routes only. [Guest wallets](/guides/guest-wallets) document the exact scope. ## Discovery-Only Tool Filtering Expose only `explore` when an agent should inspect endpoint schemas. ```python theme={null} discovery_tools = McpToolset( connection_params=connection(), tool_filter=["explore"], ) ``` This setup blocks Twitter API execution. Adding `xquik` enables key-authorized reads and writes. Because `xquik` wraps methods, name filtering cannot enforce read-only access. Use `explore` before unfamiliar operations. It returns routes, methods, parameters, and response fields without calling X. ## Store Tweet IDs and Cursors in ADK State Keep compact identifiers in session state. Exclude complete tweet pages from ADK prompts and stored session state. Plain state keys belong to one conversation. `user:` keys persist across a user's sessions. `app:` keys hold shared configuration. `temp:` keys expire after one invocation. Recommended state entries include: * `query` and `query_type` * `last_tweet_id` and `selected_tweet_ids` * `next_cursor` and `pages_fetched` * `monitor_id` and `last_event_id` * `extraction_id`, `status`, and `poll` * `write_action_id`, `status`, and `charged_credits` Never store Xquik keys in ADK state. Let `header_provider` resolve credentials from your secret manager. ## Use Tenant-Specific Xquik API Keys `header_provider` runs when ADK opens the MCP session. Read a non-secret tenant identifier from `ReadonlyContext`. Resolve the key outside the prompt. ```python theme={null} from google.adk.agents.readonly_context import ReadonlyContext def tenant_headers(context: ReadonlyContext) -> dict[str, str]: tenant_id = str(context.state["tenant_id"]) api_key = secret_store.get_xquik_key(tenant_id) return {"x-api-key": api_key} tenant_tools = McpToolset( connection_params=StreamableHTTPConnectionParams( url="https://xquik.com/mcp", ), header_provider=tenant_headers, tool_filter=["explore", "xquik"], ) ``` `secret_store` represents an existing secret manager. Keep its returned keys outside Gemini prompts and ADK events. ## Handle Tweet Search Errors and Rate Limits Handle every documented status with its matching recovery step. | Status | Meaning | Agent action | | ------ | ------------------------------------------------- | ----------------------------------------------- | | `400` | The search query is missing or invalid | Fix `q`; do not retry unchanged | | `401` | Guest authentication cannot complete this request | Provide an Xquik API key or connect X | | `402` | The account lacks credits | Stop and request account action | | `424` | The upstream X dependency failed | Retry with bounded backoff | | `429` | The Twitter API rate limit applies | Wait for reset guidance, then resume the cursor | | `502` | The X dependency returned an invalid response | Retry later without changing IDs | Do not restart pagination after `429`. Retain `next_cursor` and completed result identifiers. Deduplicate recovered results through the exact `tweet_id`. POST and DELETE routes document different statuses. Read each route before building retry logic. See [error handling](/guides/error-handling). ## Handoff Checklist
For the complete documentation index, see llms.txt.Guest wallets provide prepaid access to 33 eligible X read routes without an account. Here, account means an Xquik account. No connected X account is required. Use one funded guest key to search tweets. Read profiles, followers, replies, timelines, communities, or lists. No email address or dashboard is required. This is accountless access, not anonymous access. Every guest-wallet paid read requires the active guest key returned during wallet creation. Direct MPP reads use a per-request payment credential.
For the complete documentation index, see llms.txt.Haystack is an open source framework for Python AI applications. Compare frameworks for building RAG and agent pipelines. Use [`xquik-haystack`](https://github.com/Xquik-dev/xquik-haystack) for current tweets. This Haystack AI framework gives you typed tweet `Document` objects. Each includes text, authors, metrics, and URLs. This Haystack AI API integration supports RAG pipelines and agent workflows. You can follow this guide when building AI applications with Haystack and current tweets. The integration never grants write access. The integration provides two read-only components:
For the complete documentation index, see llms.txt.Hermes Tweet is Xquik's native Hermes Agent Twitter plugin. It provides a structured X automation toolset. The plugin adds catalog-guided Twitter tools to the Hermes Agent runtime. The Python package includes read tools, optional action tools, and 2 slash commands. It also bundles a reusable Hermes Twitter skill. That reusable skill explains supported tweet and profile workflows. Use Hermes Tweet for X search, profiles, followers, replies, monitors, and approved actions. Every live call starts from the bundled OpenAPI catalog. This design helps Hermes choose documented methods, paths, parameters, and response shapes. Each AI agent starts with catalog discovery. It then executes only a matching tool call. ## Why Add Twitter Tools to Hermes Agent Hermes Agent handles planning, memory, tools, and long-running workflows. Hermes Tweet adds focused X and Twitter API access through Xquik. The plugin exposes 102 agent-callable endpoints. Those endpoints cover tweets, profiles, timelines, followers, following, replies, media, monitors, and webhooks. Hermes Tweet separates discovery, reads, and approved actions. This separation reduces guessed routes and unintended writes. Use the plugin for these Hermes Agent Twitter tasks: * Search tweets by keyword, phrase, hashtag, or account. * Read tweet details, replies, quotes, and engagement counts. * Inspect profiles, timelines, followers, following, and mentions. * Export followers, following accounts, or tweet replies. * Monitor accounts or keywords and deliver webhook events. * Draft, post, reply, like, repost, follow, or send DMs. The read tool preserves complete JSON payloads. It does not collapse rich tweet, profile, media, or pagination fields. ## Prerequisites * Python `3.11` or newer * Hermes Agent with plugin support * [Xquik API key](/x-api-quickstart) Hermes exposes pip plugins through the `hermes_agent.plugins` entry-point group. Enable each third-party plugin before loading it. ## Install For an existing Hermes Agent install, use the plugin installer: ```bash theme={null} hermes plugins install Xquik-dev/hermes-tweet --enable ``` Hermes records plugin enablement in `~/.hermes/config.yaml`. The Hermes home directory is `~/.hermes`. Hermes prompts for `XQUIK_API_KEY` during an interactive install and stores it in `~/.hermes/.env`. Non-interactive installs skip the prompt. Set the key in the process environment or `~/.hermes/.env` before calling `tweet_read`. Install the published PyPI package directly into the Hermes Python environment when you manage package installation yourself: ```bash theme={null} uv pip install --python ~/.hermes/hermes-agent/venv/bin/python hermes-tweet hermes plugins enable hermes-tweet ``` If your Hermes Python environment includes `pip`, this path is also valid: ```bash theme={null} ~/.hermes/hermes-agent/venv/bin/python -m pip install hermes-tweet hermes plugins enable hermes-tweet ``` The current package version is `0.1.12`. The plugin name is `hermes-tweet`, and the Python entry point is `hermes-tweet = hermes_tweet`. ## Configure Set your Xquik API key before starting Hermes: ```bash theme={null} export XQUIK_API_KEY="xq_..." ``` For persistent Hermes sessions, add the key to `~/.hermes/.env`: ```bash theme={null} XQUIK_API_KEY=xq_... ``` Optional environment variables: ```bash theme={null} export XQUIK_BASE_URL="https://xquik.com" export HERMES_TWEET_ENABLE_ACTIONS="false" ``` Keep `HERMES_TWEET_ENABLE_ACTIONS=false` for unattended sessions. Enable actions only for workflows with an explicit approval step: ```bash theme={null} export HERMES_TWEET_ENABLE_ACTIONS="true" ``` If Hermes is already running after you edit `~/.hermes/.env`, run `/reload` in an interactive CLI session, or restart gateway and cron sessions before calling `tweet_read`. New agent runs read the updated environment after restart. ## Tools
For the complete documentation index, see llms.txt.Build a LangChain Twitter API agent through Xquik's MCP server. Search tweets, inspect profiles, export followers, replay monitor events, and review X actions. This LangChain Twitter API integration helps when building agents for Twitter. It preserves tweet IDs, timestamps, cursors, and route errors as typed values. ## Why Use LangChain With a Twitter API? LangChain connects Xquik tools to models, retrievers, databases, and application services. LangGraph adds durable state, resumable jobs, and human approval. Choose a narrow route for each Twitter agent task. | Agent task | Xquik route | Preserve for the next step | | --------------------- | ----------------------------- | ------------------------------------------------- | | Search tweets | `GET /api/v1/x/tweets/search` | Query, tweet IDs, authors, `created`, and cursor | | Inspect a profile | `GET /api/v1/x/users/{id}` | User ID, username, biography, and follower count | | Export followers | `POST /api/v1/extractions` | Extraction ID, status, poll URL, and export state | | Watch keywords | `POST /api/v1/monitors` | Monitor ID, event types, and next billing time | | Replay monitor events | `GET /api/v1/events` | Event IDs, `has_more`, and `next_cursor` | | Post or reply | The matching X write route | Tweet ID, action ID, status, and charged credits | Use LangChain for short tool-calling conversations. Use LangGraph when work must resume after failures, approvals, or process restarts. Both use the same MCP tools and normalized response contract. ## LangChain Twitter API Prerequisites * Python 3.10 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * A LangChain-supported model with tool and structured-output support * A connected X account for private reads or write actions Public X reads do not require X Developer credentials. Authenticate with Xquik. Connect an X account only when the selected route requires it. This supplies a Twitter API for Python agents through one MCP connection. Authenticate this MCP server with an Xquik API key. Do not send OAuth 2.0 or an OAuth token. Keep credentials outside user context, prompts, and agent memory. ## Install the Python Packages Install compatible minor ranges. This avoids silent breaking changes. ```bash theme={null} python -m pip install --upgrade \ "langchain>=1.3,<1.4" \ "langchain-mcp-adapters>=0.3,<0.4" \ langchain-anthropic \ python-dotenv ``` Model Context Protocol (MCP) powers LangChain MCP support. LangChain MCP support comes from `langchain-mcp-adapters`. This open-source adapter loads tool schemas from configured MCP server connections. MCP clients turn model tool calls into authenticated HTTP requests. ### Separate MCP Clients, Servers, and Model Credentials LangChain runs the MCP client. Xquik runs the MCP server. The client loads tool definitions before the first API call. The server validates each route, HTTP method, query, body, and Xquik API key. Use an OpenAI API key only with a compatible model provider. Keep every model credential separate from the Xquik key. Never send either credential through prompts, user context, tool arguments, or saved handoffs. Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE ANTHROPIC_API_KEY=sk-ant-... ``` Add `.env` and generated handoff files to `.gitignore`. ```text .gitignore theme={null} .env xquik-*-handoff.json ``` ## How to Use the Twitter API in Python With LangChain Use Pydantic for the final handoff. Do not rename a text response to `.json`. Validated output rejects missing tweet IDs and malformed cursors. ```python theme={null} import asyncio import os from pathlib import Path from typing import Literal from dotenv import load_dotenv from langchain.agents import create_agent from langchain_mcp_adapters.client import MultiServerMCPClient from pydantic import BaseModel class TweetRow(BaseModel): tweet_id: str text: str author_username: str | None = None created: int | None = None url: str | None = None class TweetSearchHandoff(BaseModel): query: str route_used: str tweets: list[TweetRow] has_more: bool next_cursor: str | None = None stop_reason: Literal[ "complete", "requested_limit", "cursor_stalled", "page_cap", ] async def main() -> None: load_dotenv() client = MultiServerMCPClient( { "xquik": { "transport": "http", "url": "https://xquik.com/mcp", "headers": {"x-api-key": os.environ["XQUIK_API_KEY"]}, }, } ) tools = await client.get_tools() agent = create_agent( model="anthropic:claude-sonnet-4-6", tools=tools, response_format=TweetSearchHandoff, system_prompt=( "Use Xquik for Twitter API requests. Preserve exact IDs and cursors. " "Use GET /api/v1/x/tweets/search. Never invent missing tweet fields." ), ) result = await agent.ainvoke( { "messages": [ { "role": "user", "content": ( "Search 25 recent tweets about LangChain MCP. " "Return the query, route, tweet rows, cursor state, " "and an explicit stop reason." ), } ] } ) handoff = result["structured_response"] Path("xquik-langchain-handoff.json").write_text( handoff.model_dump_json(indent=2), encoding="utf-8", ) asyncio.run(main()) ``` Wait for `result = await`, then read `structured_response`. `MultiServerMCPClient` loads the `explore` and `xquik` tools. The client is stateless by default. Save every cursor, job ID, and write status externally. The `xquik` tool executes a bounded sandbox function. That function calls `xquik.request(path, { method, body, query })`. Authentication is injected. Use `explore` first when the agent does not know a route or parameter. Each call uses the documented Xquik route and response fields. ## Preserve the MCP Response Contract MCP returns normalized snake\_case fields and Unix-second timestamps. A REST `createdAt` field becomes `created`, not `created_at`. Preserve source values before applying an application-specific schema. Search and list responses use `has_more` and `next_cursor`. Reuse the same query and filters on every page. Pass `next_cursor` as `cursor` for tweets, profiles, followers, replies, timelines, communities, and lists. Events, draws, and extraction pages use `cursor`. Radar pages use `after`. Draft pages use `afterCursor`. Treat each cursor as opaque. Stop pagination when one condition becomes true: * The agent collects the requested total. * `has_more` becomes `false`. * `next_cursor` is missing. * `next_cursor` repeats. * The configured page cap is reached. An empty page can still have `has_more: true`. Continue when the cursor advances. De-duplicate tweets and users by their stable `id` values. MCP tool output has a 24,000-character limit. Project only the required fields. Choose extraction exports for complete-row workflows. ## Keep a Resumable Twitter Agent Handoff Conversation history is not a reliable job database. Persist the values needed for retries, pagination, exports, and downstream tools.
For the complete documentation index, see llms.txt.Xquik supports a Make.com Twitter integration without an X Developer app. Build tweet searches, profile lookups, follower exports, scheduled posts, and monitor alerts. The same integration supports replies, trends, extraction jobs, and signed webhooks. The 2025 decommissioning removed Make's native X app. A private Make custom app keeps each scenario focused and authentication testable. Teams can later decide whether public app review fits their distribution needs. ## Choose a Make Twitter Automation Pattern A Make Twitter automation should start with one clear trigger. Use schedules for recurring tweet searches, trends, or follower exports. Instant webhook delivery applies to replies, quotes, reposts, and new tweets. Use polling when an extraction job can finish after the scenario ends. Build a Make scenario automation around one bounded Xquik operation. Then route normalized tweet or profile fields to each destination. This structure keeps the automation workflow observable and easier to retry. The HTTP module supports a limited private prototype. A private custom app suits reusable actions and consistent error handling. Both approaches can call the same documented API endpoints. ## Build a Make.com API Integration A Make.com API integration uses an Xquik API key for authentication. It does not require X OAuth or a native Twitter account connection. The Make custom app stores the key inside an encrypted connection field. Use `/account` to validate API keys without changing tweets or profiles. Place the base URL, authentication header, and sanitization rules centrally. Focused modules should cover tweets, users, followers, monitors, and webhooks. A Make Twitter integration should return small, stable output bundles. Avoid passing complete API responses into Slack, Sheets, or a CRM. The Make API integration should retain IDs, cursors, timestamps, and status fields. Treat the Make Twitter API layer as a private integration boundary. The integration platform can then support drag-and-drop scenario assembly. This step-by-step structure keeps every module focused on one result. ## Prerequisites * [Xquik API key](/x-api-quickstart) * Make organization with Custom Apps access * HTTPS Make webhook URL for instant monitor-event scenarios * Optional Slack, Sheets, Airtable, or CRM module for downstream steps ## App Shape
For the complete documentation index, see llms.txt.Build a Mastra AI Twitter MCP agent through Xquik's remote MCP server. This Mastra Twitter agent searches tweets, profiles, replies, followers, and monitors. It preserves every tweet ID, profile ID, cursor, and job ID. This Mastra AI tutorial combines agent tools, one typed workflow, and a strict handoff. Xquik provides the Twitter MCP server and documented API endpoints. Mastra controls the AI model, tool call, approval, and agent workflows. ## Why Use the Mastra AI Agent Framework With a Twitter API? Mastra is an open-source TypeScript framework for building AI applications. The Mastra AI agent framework adds tools, routing, memory, and workflows. Use an X API agent when a model must choose related operations. Use REST for fixed routes, scheduled exports, or predictable latency. | Boundary | Mastra control | Twitter agent result | | -------------- | ---------------------- | --------------------------------------------------- | | Remote MCP | `MCPClient` | Connect tweet, profile, follower, and monitor tools | | Final response | Zod `structuredOutput` | Reject malformed rows and cursor state | | Per-call tools | `listToolsets()` | Isolate each user's Xquik key | | X actions | `requireToolApproval` | Pause before the `xquik` tool runs | | Tool errors | `onToolError: "throw"` | Preserve failed MCP results | | Cleanup | `disconnect()` | Close remote sessions | ## Mastra Twitter API Prerequisites * Node.js 22.13 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * A model-provider key supported by Mastra * A connected X account for private reads or writes Public reads need no X Developer credentials. Authenticate through Xquik. ## Install the Mastra AI SDK and MCP Support Install the tested Mastra AI SDK packages and Zod. ```bash theme={null} npm install "@mastra/core@^1.55" "@mastra/mcp@^1.15" zod ``` Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE OPENAI_API_KEY=YOUR_OPENAI_KEY ``` ```text .gitignore theme={null} .env xquik-*-handoff.json ``` Run `npm run dev` in a generated Mastra project. Then inspect agent calls in Mastra Studio. ## Build a Mastra AI Agent Example for Tweet Search Define the final handoff before creating the agent. ```typescript theme={null} import { writeFile } from "node:fs/promises"; import { Agent } from "@mastra/core/agent"; import { createStep, createWorkflow } from "@mastra/core/workflows"; import { MCPClient } from "@mastra/mcp"; import { z } from "zod"; const tweetRowSchema = z.object({ tweet_id: z.string(), text: z.string(), author_username: z.string().nullable(), created: z.number().int().nullable(), url: z.string().url().nullable(), }); const handoffSchema = z.object({ query: z.string(), route_used: z.literal("GET /api/v1/x/tweets/search"), tweets: z.array(tweetRowSchema), has_more: z.boolean(), next_cursor: z.string().nullable(), pages_fetched: z.number().int().positive(), stop_reason: z.enum([ "complete", "requested_limit", "cursor_stalled", ]), }); const mcp = new MCPClient({ servers: { xquik: { url: new URL("https://xquik.com/mcp"), requestInit: { headers: { "x-api-key": process.env.XQUIK_API_KEY!, }, }, onToolError: "throw", }, }, timeout: 60_000, }); try { const agent = new Agent({ id: "xquik-tweet-search-agent", name: "Xquik Tweet Search Agent", instructions: [ "Use Xquik for Twitter API requests.", "Use GET /api/v1/x/tweets/search.", "Preserve exact tweet IDs, created timestamps, and cursors.", "Never invent missing tweet fields.", "Stop when the requested limit is reached.", "Stop if the server repeats a cursor.", ].join(" "), model: "openai/gpt-5", tools: await mcp.listTools(), }); const searchStep = createStep({ id: "search-twitter", inputSchema: z.object({ query: z.string().min(1) }), outputSchema: handoffSchema, execute: async ({ inputData }) => { const result = await agent.generate( `Search 50 latest tweets for: ${inputData.query}`, { structuredOutput: { schema: handoffSchema } }, ); return handoffSchema.parse(result.object); }, }); const tweetResearchWorkflow = createWorkflow({ id: "xquik-tweet-research", inputSchema: z.object({ query: z.string().min(1) }), outputSchema: handoffSchema, }) .then(searchStep) .commit(); const run = await tweetResearchWorkflow.createRun(); const workflowResult = await run.start({ inputData: { query: "Mastra AI MCP" }, }); if (workflowResult.status !== "success") { throw new Error(`Tweet workflow ended with ${workflowResult.status}.`); } await writeFile( "xquik-mastra-handoff.json", JSON.stringify(workflowResult.result, null, 2), "utf8", ); } finally { await mcp.disconnect(); } ``` `listTools()` suits static agent construction. `listToolsets()` groups tools by server for each call. The client tries Streamable HTTP for URL servers. The MCP runtime returns normalized snake\_case fields through `xquik.request()`. It normalizes `createdAt` to the Unix-second field `created`. Keep the Zod schema aligned with that contract. ## Run a Mastra AI Workflow for Tweet Research The `inputSchema: z.object(...)` declaration validates every query. The `outputSchema` protects the final handoff. Mastra core workflows chain steps with `.then()` and finish with `.commit()`. `createRun()` creates isolated state. Store each successful handoff immediately. A registered agent can also run the workflow through a Mastra instance. ## Search Tweets With Precise Operators Keep the exact `q` in every checkpoint. | Search intent | Example `q` | | ------------------------ | -------------------------------------------------- | | Framework posts | `"Mastra" MCP` | | One timeline | `from:mastra_ai since:2026-07-01 until:2026-08-01` | | Popular TypeScript posts | `"Twitter API" TypeScript lang:en min_faves:25` | | Questions | `"tweet search agent" ? -filter:retweets` | Use `queryType=Latest` for time-ordered research. Pass `next_cursor` unchanged. Stop when `has_more` becomes false. Also stop when a cursor repeats. ## Require Approval for Twitter Actions Xquik exposes one `xquik` execution tool. It can run authorized reads and writes. Require human-in-the-loop approval when the key permits writes. ```typescript theme={null} const approvedMcp = new MCPClient({ servers: { xquik: { url: new URL("https://xquik.com/mcp"), requestInit: { headers: { "x-api-key": process.env.XQUIK_API_KEY! }, }, requireToolApproval: ({ toolName }) => toolName === "xquik", onToolError: "throw", }, }, }); ``` Show the route, method, arguments, and X account before approval. Never treat MCP annotations as an authorization boundary. They are server-provided hints.
For the complete documentation index, see llms.txt.Use this workflow when a product, support, CRM, or AI agent system needs a hosted media URL for tweet posts or an uploaded media ID for direct messages. Xquik accepts local files with `multipart/form-data` and HTTPS media URLs with `application/json`. If you already have public image URLs or a public MP4 video URL for a tweet or reply, skip `POST /x/media` and pass those URLs directly in the `media` array on `POST /x/tweets`. Send up to 4 images or exactly 1 MP4 video up to 100 MB. Use `POST /x/media` when you need Xquik to host a local file, validate a generated media URL, or produce a `mediaId` for a DM attachment.
For the complete documentation index, see llms.txt.Use this Microsoft Agent Framework tutorial to build a production-ready Twitter MCP agent. This Microsoft Agent Framework Python example connects to Xquik's remote MCP server. Search tweets, inspect profiles, export followers, and replay monitors. Review X actions before execution. Preserve every tweet ID, profile ID, cursor, and job identifier exactly. Connect the Microsoft Agent Framework MCP server client through Streamable HTTP. ## Why Use the Microsoft AI Agent Framework With a Twitter API? The Microsoft open-source agent framework provides agents, sessions, tools, middleware, and workflows. It supports Python and .NET. Use this Microsoft AI agent framework when Microsoft chat clients fit your stack. These building blocks support single-agent tasks and multi-agent systems. Xquik publishes Twitter API operations through two MCP tools: `explore` and `xquik`. Use each boundary for one responsibility. | Boundary | Framework control | Twitter agent benefit | | -------------- | ------------------------------- | -------------------------------------------------------------- | | Remote MCP | `MCPStreamableHTTPTool` | Connect agents to tweet, profile, follower, and monitor routes | | Final response | Pydantic `response_format` | Reject malformed tweet rows and pagination state | | Tenant context | `header_provider` | Resolve one Xquik key for each agent run | | X actions | MCP `approval_mode` | Pause before the shared `xquik` execution tool runs | | Agent handoff | `AgentSession` and typed models | Preserve IDs without copying whole transcripts | | Tool scope | `allowed_tools` | Expose discovery alone or both MCP tools | Choose it for Python services requiring model-selected tool calls. Choose direct REST for fixed jobs without model choices. ## Microsoft Agent Framework Getting Started * Python 3.10 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * An LLM provider key supported by Microsoft Agent Framework * Connect an X account for private reads or X write actions Public X reads do not require X Developer credentials. Authenticate with Xquik. Connect an X account only when the route requires it. Keep provider keys and Xquik keys in separate environment variables. Version 1.13.0 protects initialization requests and later tool invocations. Pin it when building AI agents with tenant credentials. Choose only AI models supported by the configured chat client. ## Install Microsoft Agent Framework MCP Support Install the tested Python release. ```bash theme={null} python -m pip install "agent-framework==1.13.0" ``` Store secrets outside source control. ```bash .env theme={null} XQUIK_READ_ONLY_API_KEY=xq_YOUR_PAID_READS_KEY XQUIK_API_KEY=xq_YOUR_WRITE_CAPABLE_KEY OPENAI_API_KEY=YOUR_OPENAI_KEY OPENAI_CHAT_MODEL=gpt-5 ``` ```text .gitignore theme={null} .env xquik-*-handoff.json ``` ## Microsoft Agent Framework Python Example for Tweet Search Define the handoff before creating the agent. This production-ready example uses Model Context Protocol (MCP) tool calls. The framework parses the final response into the Pydantic model. Use a guest `paid_reads` key for this autonomous example. Never give an unattended research agent a write-capable key. ```python theme={null} import asyncio import os from pathlib import Path from typing import Literal from agent_framework import Agent, MCPStreamableHTTPTool from agent_framework.openai import OpenAIChatClient from pydantic import BaseModel class TweetRow(BaseModel): tweet_id: str text: str author_username: str | None created: int | None url: str | None class TweetSearchHandoff(BaseModel): query: str route_used: Literal["GET /api/v1/x/tweets/search"] tweets: list[TweetRow] has_more: bool next_cursor: str | None pages_fetched: int stop_reason: Literal[ "complete", "requested_limit", "cursor_stalled", ] async def main() -> None: xquik_mcp = MCPStreamableHTTPTool( name="xquik-twitter-api", url="https://xquik.com/mcp", description="Search tweets, profiles, followers, monitors, and exports.", allowed_tools=["explore", "xquik"], header_provider=lambda kwargs: { "x-api-key": kwargs["xquik_api_key"], }, ) async with Agent( client=OpenAIChatClient(model=os.environ["OPENAI_CHAT_MODEL"]), name="xquik_tweet_search_agent", instructions=( "Use GET /api/v1/x/tweets/search. " "Preserve exact tweet IDs, created timestamps, and cursors. " "Never invent missing tweet fields. " "Stop at the requested limit. Stop if a cursor repeats." ), tools=xquik_mcp, ) as agent: result = await agent.run( "Search 50 latest tweets about Microsoft Agent Framework MCP.", options={"response_format": TweetSearchHandoff}, function_invocation_kwargs={ "xquik_api_key": os.environ["XQUIK_READ_ONLY_API_KEY"], }, ) if not isinstance(result.value, TweetSearchHandoff): raise RuntimeError("Tweet handoff invalid. Inspect the agent response.") Path("xquik-microsoft-agent-handoff.json").write_text( result.value.model_dump_json(indent=2), encoding="utf-8", ) asyncio.run(main()) ``` `allowed_tools` keeps the remote surface explicit. The agent receives only `explore` and `xquik` from Xquik's MCP server. The agent framework import loads `Agent` and `MCPStreamableHTTPTool`. Agent framework agents use only the selected Xquik MCP tools. `response_format` asks the model for the Pydantic shape. Read the validated object from `result.value`. Never persist `result.text` as a typed handoff. The MCP runtime returns normalized snake\_case fields through `xquik.request()`. It normalizes `createdAt` to the Unix-second field `created`. Keep the Pydantic model aligned with that contract. ## Search Tweets With Focused Queries Send a precise `q` to the tweet search route. Keep it in the handoff. | Search intent | Example `q` | | ------------------------- | -------------------------------------------------- | | Framework discussions | `"Microsoft Agent Framework" MCP` | | One account's timeline | `from:Microsoft since:2026-07-01 until:2026-08-01` | | Popular Python posts | `"Twitter API" Python lang:en min_faves:25` | | Questions without reposts | `"tweet search agent" ? -filter:retweets` | | Customer support mentions | `@brand (help OR issue) -filter:retweets` | | Exact tweet | A numeric Tweet ID or X status URL | Use `queryType=Latest` for chronological monitoring. Use `Top` for engagement-ranked research. See the [tweet search API contract](/api-reference/x/search-tweets). Pass `next_cursor` back unchanged. Never rebuild a cursor. Stop when `has_more` becomes false. Also stop when a cursor repeats. Continue through an empty page when `has_more` remains true. Deduplicate resumed results by `tweet_id`. ## Add Human-in-the-Loop Approval for Twitter Actions Xquik exposes one `xquik` execution tool. It runs routes authorized by the API key. Tool-name checks cannot distinguish routes inside `xquik`. Apply approval to `xquik` whenever a key authorizes writes. Ask a human in the loop to inspect every write-capable request. ```python theme={null} from agent_framework import Agent, MCPStreamableHTTPTool, Message approved_mcp = MCPStreamableHTTPTool( name="xquik-twitter-api", url="https://xquik.com/mcp", allowed_tools=["explore", "xquik"], approval_mode={ "never_require_approval": ["explore"], "always_require_approval": ["xquik"], }, header_provider=lambda kwargs: { "x-api-key": kwargs["xquik_api_key"], }, ) async with Agent( client=OpenAIChatClient(model=os.environ["OPENAI_CHAT_MODEL"]), name="approved_xquik_agent", instructions="Show exact routes and arguments before every Xquik request.", tools=approved_mcp, ) as agent: session = agent.create_session() run_options = {"response_format": TweetSearchHandoff} run_context = {"xquik_api_key": os.environ["XQUIK_API_KEY"]} result = await agent.run( "Search tweets about Python Twitter MCP agents.", session=session, options=run_options, function_invocation_kwargs=run_context, ) while result.user_input_requests: responses = [] for request in result.user_input_requests: if request.function_call is None: responses.append( request.to_function_approval_response(approved=False) ) continue print("Function:", request.function_call.name) print("Arguments:", request.function_call.arguments) answer = await asyncio.to_thread(input, "Approve this call? [y/N] ") responses.append( request.to_function_approval_response( approved=answer.strip().lower() == "y" ) ) result = await agent.run( Message(role="user", contents=responses), session=session, options=run_options, function_invocation_kwargs=run_context, ) ``` Show the route, method, arguments, text, and selected X account. Reject any request whose method, arguments, text, or account changed. For public research, a guest `paid_reads` key supplies a hard read-only boundary. It exposes only eligible GET routes. Review [guest wallet permissions](/guides/guest-wallets) before granting autonomous access. ## Scope Microsoft Agent Framework Tools for Discovery Expose only `explore` when an agent should inspect endpoint schemas. ```python theme={null} discovery_mcp = MCPStreamableHTTPTool( name="xquik-route-discovery", url="https://xquik.com/mcp", allowed_tools=["explore"], header_provider=lambda kwargs: { "x-api-key": kwargs["xquik_api_key"], }, ) ``` This configuration cannot execute Twitter API operations. Adding `xquik` enables every operation authorized by the key. Use `explore` before an unfamiliar operation. It returns routes, parameters, and response fields. Discovery never executes an X operation. ## Authenticate the Microsoft Agent Framework MCP Client Resolve one Xquik key for every run. Pass it through runtime context. ```python theme={null} def tenant_headers(kwargs: dict[str, object]) -> dict[str, str]: tenant_id = str(kwargs["tenant_id"]) return {"x-api-key": secret_store.get_xquik_key(tenant_id)} tenant_mcp = MCPStreamableHTTPTool( name="tenant-xquik-twitter-api", url="https://xquik.com/mcp", allowed_tools=["explore", "xquik"], header_provider=tenant_headers, ) async with Agent( client=OpenAIChatClient(model=os.environ["OPENAI_CHAT_MODEL"]), name="tenant_twitter_agent", instructions="Preserve exact profile IDs and usernames.", tools=tenant_mcp, ) as tenant_agent: result = await tenant_agent.run( "Look up the profile for microsoft.", function_invocation_kwargs={"tenant_id": authenticated_tenant_id}, ) ``` The `secret_store` represents your existing secret manager. Never include the returned key in prompts, sessions, handoffs, or logs. Microsoft Agent Framework 1.13.0 applies runtime headers during initialization and tool calls. It limits those headers to matching-origin requests. Create an isolated `httpx.AsyncClient` for each authenticated origin. ## Build Microsoft Multi-Agent Framework Workflows Teams evaluating a Microsoft multi-agent framework should isolate every agent's tools. Give only the researcher access to Twitter MCP. Pass its validated handoff to a tool-free reviewer. ```python theme={null} researcher = Agent( client=client, name="tweet_researcher", instructions="Return validated tweet rows and pagination state.", tools=xquik_mcp, ) reviewer = Agent( client=client, name="tweet_reviewer", instructions="Analyze only supplied tweets. Preserve every tweet_id.", ) research = await researcher.run( "Search latest tweets about Python agent frameworks.", options={"response_format": TweetSearchHandoff}, function_invocation_kwargs={"xquik_api_key": tenant_api_key}, ) if not isinstance(research.value, TweetSearchHandoff): raise RuntimeError("Tweet research invalid. Stop the handoff.") review = await reviewer.run(research.value.model_dump_json()) ``` The reviewer receives no MCP tools. These multi-agent workflows prevent unauthorized Twitter API execution. The reviewer cannot fetch unrelated tweets or post X actions. ## Handle Tweet Search Errors and Rate Limits The tweet search contract documents these responses. Handle each status independently. | Status | Meaning | Agent action | | ------ | --------------------------------------------- | ----------------------------------------------- | | `400` | The search query is missing or invalid | Fix `q`; do not retry unchanged | | `401` | Authentication cannot complete this request | Provide an Xquik key or connect X | | `402` | The account lacks credits | Stop and request account action | | `424` | The upstream X dependency failed | Retry with bounded backoff | | `429` | The Twitter API rate limit applies | Wait for reset guidance, then resume the cursor | | `502` | The X dependency returned an invalid response | Retry later without changing IDs | Do not restart pagination after `429`. Preserve `next_cursor` and completed tweet IDs. Deduplicate by `tweet_id` after recovery. POST and DELETE routes document different statuses. Derive retry behavior from each route's documented statuses. See [error handling](/guides/error-handling). ## Preserve Microsoft Agent Framework Workflows and Handoffs
For the complete documentation index, see llms.txt.Build an n8n Twitter node workflow with Xquik. Search tweets, export followers, monitor accounts, publish media, and run AI agents. This n8n Twitter integration uses HTTP Request, Webhook, and MCP Client Tool nodes. Xquik does not require an X Developer app. Xquik uses one API key and the REST base URL `https://xquik.com/api/v1`. ## Choose an n8n Twitter Integration Use n8n's built-in X node for supported tweet, list, user, and DM operations. Choose Xquik's n8n Twitter API for wider reads, exports, monitors, webhooks, and MCP tools. ## Prerequisites * [Xquik API key](/x-api-quickstart) * n8n Cloud or self-hosted n8n * An HTTPS n8n webhook URL for monitor recipes * Optional Slack and Google Sheets credentials for the recipes below ## API Key Credential Create a reusable n8n credential for Xquik:
For the complete documentation index, see llms.txt.Build no-code Twitter automation for tweets, replies, followers, profiles, and team alerts. Use monitor webhooks for fresh events. Use direct reads for small pages. Use extraction jobs for large exports. This no code API integration pattern preserves cursors and event IDs. Choose Twitter automation tools by freshness, row count, and approval needs. API integration automation can save time when every API call commits its checkpoint. A Twitter webhook workflow should verify each event before routing. Use an automated tool only for bounded reads or approved writes. Keep REST API calls idempotent around retries. Store secrets outside workflow history. ## Choose a Twitter Automation Outcome | Outcome | Best lane | Required checkpoint | | ------------------------------------- | ----------------------- | ----------------------- | | Alert on new tweets or replies | Account monitor webhook | `streamEventId` | | Track keyword or brand matches | Keyword monitor webhook | `streamEventId` | | Add tweet search rows to Sheets | Direct read pages | `next_cursor` | | Export followers or following to CRM | Extraction job | Job ID and `nextCursor` | | Repair events after receiver downtime | Stored event replay | `nextCursor` | | Audit failed webhook deliveries | Delivery log | `deliveryId` | Choose the lane from the required freshness and row count. Do not poll a webhook workflow. Do not build a bulk export from repeated page-one reads. ## Pick the Handoff Lane
For the complete documentation index, see llms.txt.Xquik publishes its API documentation source under the MIT License. You can inspect, test, fork, and improve these docs. This license does not make the hosted Xquik platform open source. It does not grant rights to Xquik brands either. Use this page to verify the exact boundary. It covers documentation, OpenAPI, SDKs, security reporting, dependencies, and OpenSSF evidence. ## Distinguish the Public Sources
For the complete documentation index, see llms.txt.Build a Pipedream Twitter integration for searches, profiles, monitors, and approved posts. Xquik supplies one REST API and one API key for every workflow. The initial package contains one app file, eight actions, and two sources. Add another action after workflows repeatedly need the same HTTP request. ## Choose a Pipedream Automation Pattern Pipedream Workflows combine one trigger with actions or code steps. An HTTP trigger receives signed Xquik monitor events. A schedule trigger starts tweet search automation or extraction polling. An RSS trigger can start an approved publishing queue. Choose a private component for actions shared by multiple team members. Choose a custom JavaScript step for one custom API integration. The workflow uses prebuilt actions for Slack, Google Sheets, and CRM handoffs. Keep one output per workflow: tweet alerts, profile rows, or approved posts. Pipedream workflow automation becomes fragile when unrelated jobs share one trigger. Split searches, monitor events, follower exports, and approved writes. These boundaries turn complex workflows into small, testable paths. They also make error handling and rate limits easier to inspect. This Pipedream automation platform can replace manual tasks like copying tweets. It should never hide approval for tweets, replies, or direct messages. Review every write payload before the workflow sends it. This guide calls Xquik routes directly. It does not require Pipedream's native Twitter integration. ## Build a Serverless Twitter API Integration This serverless API integration runs without a dedicated workflow server. Start every Xquik request at `https://xquik.com/api/v1`. Send the API key through the `x-api-key` header. Pipedream secret props should contain all API keys. Step exports, logs, and error messages must exclude these keys. `GET /x/tweets/search` supports each scheduled Twitter automation workflow. Preserve the query, filters, limit, and opaque cursor between pages. Destinations should store tweet IDs after accepting each row. This order prevents skipped tweets after partial failures. `GET /x/users/{id}` returns the profile fields required for enrichment. Export usernames, follower counts, verification state, and profile images. Use `POST /extractions` when exports require multiple API pages. Poll the returned job until it reaches a terminal status. Custom JavaScript automation can read `steps.trigger.event` after a trigger. HTTP events include method, body, headers, path, query, and URL fields. Later steps receive tweet IDs, text, usernames, cursors, and destination keys. Never export signing secrets, raw signatures, or complete request headers. A shared request helper keeps API integrations consistent. It should normalize statuses, summaries, cursors, and retry instructions. Name every step after its concrete output. Examples include `search_tweets`, `normalize_profiles`, and `send_slack_alert`. ## Prerequisites * [Xquik API key](/x-api-quickstart) * Pipedream account * Node.js supported by the current Pipedream CLI * Pipedream CLI installed and signed in ```bash theme={null} npm install -g @pipedream/cli pd login ``` ## Component Shape
For the complete documentation index, see llms.txt.Prefect is an open-source workflow orchestrator for Python code. This Prefect Python tutorial schedules Twitter API Python reads through Xquik. It builds a Prefect Python workflow orchestration pipeline for tweets, profiles, timelines, and trends. Use [`prefect-xquik`](https://github.com/Xquik-dev/prefect-xquik) for repeatable tweet searches, profile lookups, timeline refreshes, and trend checks. Use it for scheduled Twitter API reads in Python. This Prefect Python library gives you typed credentials and six read-only tasks. This collection is not a general Prefect Python SDK. The collection is read-only. It provides six asynchronous Prefect tasks. Each task returns the canonical Xquik JSON response as a Python dictionary. You can track Python functions as data pipelines with Prefect. Prefect flows wrap normal Python code with retries, schedules, and state tracking. Prefect offers run history, deployment controls, and execution environments for each data workflow. The Prefect UI shows every created task and flow state in real time.
For the complete documentation index, see llms.txt.Build a Pydantic AI Twitter API agent through Xquik's MCP server. Search tweets, inspect profiles, export followers, and replay monitor events. Review every proposed post, reply, like, repost, follow, and direct message. Validate every durable handoff with a Pydantic model. ## Why Use Pydantic AI With a Twitter API? Pydantic AI combines model tool calls with typed Python output. Xquik supplies the Twitter API routes through two MCP tools: `explore` and `xquik`. Use each strength at the correct boundary. | Boundary | Pydantic AI control | Twitter agent benefit | | -------------------- | ---------------------- | -------------------------------------------- | | MCP connection | `MCP` capability | Keep credentials and tracing in your process | | Final response | Pydantic `output_type` | Reject malformed tweet rows and cursors | | Tool catalog | `.defer_loading()` | Hide unused MCP tools until discovery | | Write actions | `.approval_required()` | Pause before posting, replying, or following | | MCP naming | `.prefixed()` | Prevent tool collisions across servers | | Connection lifecycle | `async with agent` | Reuse one MCP session across related calls | Use one typed agent for tweet search, profile enrichment, or follower exports. Use another agent for monitor processing. Keep each agent focused. ## Pydantic AI Twitter API Prerequisites * Python 3.10 or later * An [Xquik API key](/x-api-quickstart) beginning with `xq_` * A Pydantic AI-supported model with tool calling * A connected X account for private reads or write actions Public X reads do not require X Developer credentials. Authenticate with Xquik. Connect an X account only when the selected route requires it. This supplies a Twitter API for Python agents through one MCP connection. Send the `x-api-key` header. Do not send bearer tokens or access tokens. ## Install Pydantic AI MCP Support Install the current stable Pydantic AI 2.x line. Keep FastMCP below 4 until Pydantic AI adds MCP SDK v2 support. ```bash theme={null} python -m pip install --upgrade \ "pydantic-ai-slim[anthropic,mcp]>=2.22,<2.23" \ "fastmcp-slim>=3.3,<4" \ python-dotenv ``` The explicit FastMCP range prevents an MCP SDK v2 prerelease from entering the environment. Remove that cap only after Pydantic AI adds FastMCP 4 support. This Pydantic AI MCP Streamable HTTP setup keeps execution inside Python. This Pydantic AI MCP server connection uses the Xquik endpoint. Keep the MCP URL HTTPS-only. It authenticates with the `x-api-key` header. After setup is complete, it can be run inside a local Python process. Store secrets outside source control. ```bash .env theme={null} XQUIK_API_KEY=xq_YOUR_KEY_HERE ANTHROPIC_API_KEY=sk-ant-... ``` ```text .gitignore theme={null} .env xquik-*-handoff.json ``` ## Build a Pydantic AI MCP Example for Tweet Search Define the final tweet-search handoff before creating the agent. Pydantic AI validates the model output against this schema. To import `Agent` from Pydantic AI, use `from pydantic_ai import Agent`. Use type hints for every durable handoff field. Start the async example with `import asyncio`. The `typing` import supplies `Literal` for finite stop reasons. ```python theme={null} import asyncio import os from pathlib import Path from typing import Literal from dotenv import load_dotenv from pydantic import BaseModel from pydantic_ai import Agent from pydantic_ai.capabilities import MCP class TweetRow(BaseModel): tweet_id: str text: str author_username: str | None = None created: int | None = None url: str | None = None class TweetSearchHandoff(BaseModel): query: str route_used: str tweets: list[TweetRow] has_more: bool next_cursor: str | None = None stop_reason: Literal["complete", "requested_limit", "cursor_stalled"] async def main() -> None: load_dotenv() xquik_mcp = MCP( "https://xquik.com/mcp", headers={"x-api-key": os.environ["XQUIK_API_KEY"]}, allowed_tools=["explore", "xquik"], ) agent = Agent( "anthropic:claude-sonnet-4-6", capabilities=[xquik_mcp], output_type=TweetSearchHandoff, instructions=( "Use Xquik for Twitter API requests. Preserve exact IDs and cursors. " "Use GET /api/v1/x/tweets/search. Never invent missing tweet fields." ), ) result = await agent.run( "Search 25 recent tweets about Pydantic AI MCP. " "Return the query, route, tweet rows, cursor state, " "and an explicit stop reason." ) Path("xquik-pydantic-ai-handoff.json").write_text( result.output.model_dump_json(indent=2), encoding="utf-8", ) asyncio.run(main()) ``` `MCP` is Pydantic AI's primary MCP entry point. The connection runs locally unless you configure another execution mode. Headers, hooks, and traces remain inside your Python process. The URL selects Streamable HTTP. The allowed list contains only the public `explore` and `xquik` tools. Model Context Protocol (MCP) turns Xquik routes into model-callable tools. Pydantic builds JSON schemas from `output_type`. Use explicit keyword arguments for `headers`, `allowed_tools`, `capabilities`, and `output_type`. Pydantic AI opens and closes the connection automatically. Enter `async with agent` when several runs should share one connection. The agent discovers `explore` and `xquik`. Discover route requirements before selecting an unfamiliar endpoint. The Xquik sandbox invokes `xquik.request(...)` with validated route values. Xquik injects authentication separately. ## Validate Twitter API Fields Before Storage MCP returns normalized snake\_case fields. Date-time values use Unix seconds. Map REST `createdAt` to `created`, never `created_at`. Keep these source fields unchanged: * Tweet rows: `id`, `text`, `author`, `created`, and `url` * Profile rows: `id`, `username`, `name`, `description`, and `followers` * Page state: `has_more` and `next_cursor` * Error fields: `error.type`, `error.code`, and `error.message` * Write receipts: `tweet_id`, `write_action_id`, and `charged_credits` Map source `id` to `tweet_id` or `user_id` only in your output model. Never cast large IDs to floating-point numbers. Search and list routes return `has_more` and `next_cursor`. Pass `cursor` for tweet, profile, follower, reply, timeline, community, and list pagination. Keep the original query and filters unchanged. Events, draws, and extraction pages use `cursor`. Radar pages use `after`. Draft pages use `afterCursor`. Treat every cursor as opaque. Continue through an empty page when `has_more` stays true. Stop when no cursor exists. Stop after the server repeats a cursor. Return `cursor_stalled` with the number of collected rows. MCP output has a 24,000-character limit. Project only required fields. Use extraction exports when the workflow must persist every complete row. ## Build a Typed Twitter Agent Handoff Conversation text cannot safely resume a Python Twitter API job. Persist the validated fields required by the next worker.
For the complete documentation index, see llms.txt.Xquik applies fixed-window Twitter API rate limits per Xquik account. These limits protect tweet reads, profile lookups, writes, and deletions. Standard API keys for one account share the same method buckets. Separate read, write, and delete buckets reset independently.
For the complete documentation index, see llms.txt.Use this Twitter API pagination guide for tweets, profiles, followers, and exports. Choose one matching route. Save every returned ID and cursor. Resume that checkpoint instead of repeating completed pages.
For the complete documentation index, see llms.txt.Choose the output shape before wiring a worker, dashboard, spreadsheet, or archive. Xquik gives you live JSON pages for endpoint calls, saved JSON pages for extraction jobs, file exports for downstream tools, and draw exports for giveaway audits. This guide covers Xquik API result files. It does not download tweet images or videos. It also does not export your private X account archive.
For the complete documentation index, see llms.txt.Use this workflow when a sales, research, community, or marketing job starts with a topic, brand, creator, or competitor account and needs a scored audience list. Keep every row keyed by X user ID so exports, CRMs, agents, and warehouse loads can dedupe later. This workflow produces public profile and relationship evidence. It does not create an X Ads custom audience. It also does not return private emails, purchase behavior, age, or gender.
For the complete documentation index, see llms.txt.Xquik returns ranked X trends for 12 supported WOEID regions. Use each trend's `query` with [Search Tweets](/api-reference/x/search-tweets) to collect matching posts. Use this Twitter trends guide for regional topic discovery and monitoring. Each call returns one current snapshot. Store snapshots to build trend history. ## Choose the Trends Endpoint Use `GET /api/v1/trends` for the top-level Twitter Trends API response. It returns `trends`, `total`, and `woeid`. Use `GET /api/v1/x/trends` for the equivalent X API route. It returns `trends`, `count`, and `woeid`. Keep one response shape throughout each client. This prevents `total` and `count` from becoming competing fields in stored snapshots. ## Regions Use these WOEIDs in `woeid` for `GET /trends` or `GET /x/trends`. Omit `woeid` or pass `1` for worldwide trends.
For the complete documentation index, see llms.txt.Common issues, error codes, and solutions. If your problem isn't covered here, contact [support@xquik.com](mailto:support@xquik.com). ## Error codes ### 401 Unauthenticated The API key or OAuth token is missing, invalid, expired, or revoked. Check the following: * **API key header:** Send `x-api-key: xq_...` or `Authorization: Bearer xq_...`. * **OAuth header:** Send `Authorization: Bearer
For the complete documentation index, see llms.txt.Use this guide to get tweet metadata from Xquik responses. It maps Twitter API fields for tweets, user profiles, media files, and replies. Compare Twitter API user fields, Twitter profile fields, and media objects. Review tweet engagement metrics, quote context, repost context, and pagination. Quick answer: treat IDs as strings. Treat optional fields as conditional. Keep reply, quote, and repost relationships separate. Store a collection timestamp beside mutable engagement and profile counts. This Twitter metadata guide focuses on public fields X supplies. Xquik preserves every documented public field supplied for supported reads. Core fields remain stable. Optional fields appear only when X supplies them.
For the complete documentation index, see llms.txt.Export Twitter replies as CSV, JSON, or XLSX rows. Use `reply_extractor` for saved files with a defined result cap. Scrape Twitter replies through the live API when an application needs current pages. Send reply authors, text, media, and engagement counts downstream. Route rows to moderators, CRMs, warehouses, queues, or agents. ## When to use this workflow
For the complete documentation index, see llms.txt.
For the complete documentation index, see llms.txt.TweetClaw is Xquik's official OpenClaw Twitter plugin. It connects an OpenClaw agent to documented Xquik API endpoints. The plugin searches tweets, profiles, replies, followers, timelines, lists, communities, and trends. This OpenClaw Twitter skill supports posts, replies, likes, reposts, follows, and DMs. It also supports monitors, webhooks, follower exports, and media actions. It keeps API keys outside prompts and model-visible tool arguments. TweetClaw is an OpenClaw plugin, not an MCP server. Choose Xquik MCP for remote MCP clients. Choose an Xquik SDK for application code outside an agent runtime. ## Prerequisites * OpenClaw `2026.7.1` or newer * Node.js `22` or newer, within the installed OpenClaw release's supported range * [Xquik API key](/x-api-quickstart) for account-backed automation * Optional [MPP setup](/mpp/quickstart) for anonymous read-only pay-per-use calls
For the complete documentation index, see llms.txt.Build reviewable giveaway entry lists from replies and retweets. Keep stable user IDs, Tweet IDs, cursors, filters, and checked timestamps. Then create one draw from the source Tweet URL and published filters. ## How Does a Twitter Comment Picker Work? A Twitter comment picker treats direct reply authors as potential entries. Use [Get Tweet Replies](/api-reference/x/tweet-replies) for reply text and authors. Page until `has_next_page` is `false`. Pass `next_cursor` back as `cursor`. Store every reply ID, author ID, text, timestamp, and source Tweet ID. Remove duplicate authors before selection when campaign rules require uniqueness. Apply only published keyword, hashtag, mention, language, and account filters. A random comment picker selects winners from the remaining stable user IDs. It cannot prove follows or retweets without separate API checks. ## How Do I Pick a Winner From Twitter Comments? A random Twitter comment picker retrieves every direct reply page. To pick a winner from Twitter comments, store each reply ID and author ID. Reject replies posted after the published closing time. A Twitter reply picker should freeze eligible user IDs before selection. Set the number of winners and backup winners once. Create one draw to pick a random winner from filtered reply entries. Use the [Twitter giveaway picker](/guides/twitter-giveaway-picker) with the source Tweet URL. Send every published filter in the original create request. Store those giveaway rules beside the returned draw ID. `GET /draws/{id}` does not repeat the create-time filters. After completion, export `type=winners` for stored winners and backups. Read those stored records instead of running another random selection. Search draw history when the create response is uncertain. One stored draw prevents conflicting random winners. Export the giveaway winner and every backup position. Never pick multiple winners through separate speculative draws. This winner selection process stays tied to the original reply evidence. ## How Does a Twitter Retweet Picker Verify Entries? Use a Twitter retweet giveaway picker when published entry rules require reposts. A Twitter retweet picker reads stable user IDs from the retweeter list. Use [Get Retweeters](/api-reference/x/retweeters) to retrieve every available page. Store each retweeter ID, page cursor, source Tweet ID, and checked timestamp. Do not trust a displayed repost count as participant proof. Set `mustRetweet` only when the published rules require a repost. Join retweeter IDs with reply-author IDs when campaigns require both actions. Keep the join result beside both original entry sources. This record shows why each participant entered the winner pool. ## How Does a Twitter Hashtag Giveaway Picker Work? A Twitter hashtag giveaway picker checks required hashtags in reply text. Use a specific hashtag only when published campaign rules require it. Store the matched reply ID, author ID, hashtag, and checked timestamp. Keep unmatched rows when an operator needs rejection evidence. Normalize hashtag comparisons according to the published campaign rules. Record original reply text beside every match and rejection. Preserve letter case when the published rule requires exact matching. Hashtag text cannot prove follows or retweets. Run those checks separately. Apply all required checks before random selection begins. ## Can a Comment Picker Verify Likes? No. The current Draws contract does not accept likes as an eligibility rule. Do not claim that a comment picker verifies likes. Use only documented follow, retweet, keyword, hashtag, mention, and account rules. The contract also supports documented language and unique-author conditions. It supports account-age and follower-count thresholds when campaigns publish them. Do not launch unsupported selection when likes define campaign entry. Rewrite rules around supported signals before the campaign opens. Never substitute replies for likes after participants enter. ## Combine Comment and Retweet Checks 1. Store one source Tweet URL and numeric Tweet ID. 2. Retrieve every reply page and every retweeter page. 3. Normalize each participant to a stable X user ID. 4. Remove duplicates according to published uniqueness rules. 5. Apply required reply text and account filters. 6. Join required retweet and follow results by user ID. 7. Store accepted and rejected entries with reasons. 8. Create one draw with the source Tweet URL and published eligibility filters. Never change filters after the entry deadline. Never replace stable IDs with names. Repeat uncertain reads with the same Tweet ID, filter, and cursor. ## Store an Entry Audit Row Keep one row for each checked participant and entry source. ```json theme={null} { "tweet_id": "1893704267862470862", "x_user_id": "9876543210", "reply_id": "1893705000000000000", "retweet_verified": true, "required_hashtag_verified": true, "verification_state": "eligible", "checked_at": "2026-05-24T19:30:00.000Z" } ``` Store cursor checkpoints outside participant rows. One checkpoint can resume each page. Keep private notes and API keys outside any public result URL. ## Next Steps
For the complete documentation index, see llms.txt.Use Xquik as a Twitter giveaway picker with reviewable entry checks. One draw stores filters, winners, backup winners, timestamps, and exports. It can also publish a result URL for participant review. ## What Makes the Best Twitter Giveaway Picker? The best Twitter giveaway picker records every published rule before selection. Store the source Tweet ID, winner count, backup count, and unique-author rule. Keep each follow, retweet, keyword, hashtag, mention, language, and account filter. Preserve inspected entry IDs, selected winner IDs, status, and draw ID. Stable user IDs matter more than display names or handles. Avoid tools that return only winner names. Those names cannot prove eligibility. A useful giveaway tool exports inspected entries and selected winners separately. It also keeps a public result URL when campaigns require transparency. ## How Do I Automate a Twitter Giveaway With an API? Write every campaign rule before collecting entries. Identify one source tweet. Define `winnerCount`, optional `backupCount`, and `uniqueAuthorsOnly`. Add only the filters shown to participants. Call [Create Draw](/api-reference/draws/create) once. Save the returned draw ID. Poll that draw until it completes or fails. Then export its records. Use `type=entries` for inspected participants. Use `type=winners` for selections. Treat an unknown create response as an investigation. Search draw history first. Do not create another draw because a client lost its local response. Keep API keys and private notes outside any public result record. ## Programmatic Twitter Giveaway Draw Checklist 1. Store the source Tweet URL and numeric Tweet ID. 2. Record the entry closing time before collection starts. 3. Define the winner and backup counts. 4. Publish every required follow, retweet, keyword, hashtag, or mention. 5. Publish any language, account-age, or follower-count threshold. 6. Collect replies, retweeters, quotes, or followers. 7. Remove duplicate authors when rules require unique participants. 8. Apply every published rule before random selection. 9. Create one draw and save its ID immediately. 10. Export entries, winners, backup winners, filters, and timestamps. Never draw from an unchecked follower or reply snapshot. Exclude inactive or spam accounts only through published filters. More engagement never weakens the proof requirements. ## How Do I Pick a Winner From Replies and Retweets? A Twitter picker should build one eligible pool before it picks a winner. Start with one giveaway post and its numeric Tweet ID. Collect reply authors and retweeters through their separate paginated endpoints. Store each cursor beside the page it produced. Record the collection start and closing times. Reject late replies and retweets using the published closing boundary. Keep each rejected user ID with its failed check. Store no extra profile details unless a published filter needs them. When a Twitter contest requires both actions, join participants by stable user ID. Keep entries only when both source lists contain that ID. For a specific hashtag, check the original reply text. Store the matching reply ID and checked timestamp. Never infer hashtag compliance from aggregate engagement counts. A retweet picker alone can produce winners from retweets. It cannot confirm replies, follows, hashtags, or account thresholds. Run every published check before any participant is selected randomly. Then freeze the eligible pool and create one draw. This sequence lets teams run giveaways without changing rules after closing. If the create response becomes uncertain, search draw history. Reuse the stored draw ID when the request succeeded. Never pick a winner through a second speculative draw. That duplicate draw could return a conflicting winner. Export inspected entries first, then export final winners. Compare their counts with the stored request. ## How Does a Twitter Random Giveaway Picker Choose Winners? A Twitter random giveaway picker filters entries before random selection. Set the number of winners and backup count in one request. The draw randomly selects eligible stable user IDs after every check. Never randomly pick from an unchecked follower, reply, or retweeter list. A Twitter giveaway winner picker should preserve the starting entry count. Keep every selected user ID, position, backup flag, filter, and timestamp. Export the original request beside inspected entries and final winners. These records explain why each participant entered the eligible pool. ## How Do I Prove Giveaway Winners Were Eligible? Export `type=entries` and `type=winners` after the draw completes. Keep the draw ID, source Tweet ID, participant IDs, and applied filters. Record timestamps, verification states, winner positions, and backup flags. Share the public result URL when participants need reviewable proof. Reconcile exported user IDs with inspected entry counts before publishing. Keep rejection reasons for participants excluded by any published filter. Preserve export filenames and formats with the campaign record. Do not publish API keys, private notes, or unnecessary participant details. Keep those records within the campaign audit. ## What Should I Publish With the Winner? Publish the winner handle, giveaway tweet, and result URL when appropriate. Keep the verified user ID and draw ID in your private audit. Explain any published eligibility filter that affected selection. Never publish hidden rules because hidden rules should never exist. Publish the closing time, winner position, and backup status when required. Link results to the source tweet for participant context. Avoid publishing rejected entry details or complete participant exports. Keep those records within the private campaign audit. ## Next Steps
For the complete documentation index, see llms.txt.Test your webhook integration before deploying to production. Use Xquik's signed test delivery, local HTTPS tunnels, payload inspectors, and delivery logs to verify handlers before real monitor events arrive. ## Test with Xquik first Use the [Test Webhook](/api-reference/webhooks/test) endpoint after you create a webhook. Xquik sends a real `webhook.test` delivery to the configured URL with the same `X-Xquik-Signature`, `X-Xquik-Timestamp`, and `X-Xquik-Nonce` headers used for production monitor events. `webhook.test` payloads contain `eventType`, `data.message`, and `timestamp`; they omit `deliveryId` and `streamEventId`, so use them for reachability and signature checks, not production de-dupe. ```bash theme={null} curl -X POST https://xquik.com/api/v1/webhooks/15/test \ -H "x-api-key: xq_YOUR_KEY_HERE" | jq ``` **Response when your endpoint accepts the delivery:** ```json theme={null} { "success": true, "statusCode": 200 } ``` **Response when your endpoint rejects the delivery:** ```json theme={null} { "success": false, "statusCode": 500, "error": "HTTP 500" } ``` Check your server logs for the `webhook.test` payload, verify the HMAC before processing it, and return a 2xx response only after your handler accepts the event. ## End-to-end handoff check Use a signed test delivery to prove the receiver can verify requests, then use production monitor deliveries to prove idempotency and storage behavior. ```json theme={null} { "workflow": "signed_webhook_test_handoff", "webhook": { "webhook_id": "15", "url": "https://example.com/xquik/webhook", "event_types": ["tweet.new", "tweet.reply"], "secret_storage": "store_once" }, "test_delivery": { "endpoint": "/api/v1/webhooks/15/test", "event_type": "webhook.test", "has_delivery_id": false, "has_stream_event_id": false, "signature_headers": [ "X-Xquik-Signature", "X-Xquik-Timestamp", "X-Xquik-Nonce" ], "receiver_status": 200, "success": true }, "production_delivery": { "event_type": "tweet.new", "delivery_id": "502", "stream_event_id": "9002", "dedupe_keys": ["deliveryId", "streamEventId"], "return_status": "2xx_before_slow_work" }, "delivery_triage": { "endpoint": "/api/v1/webhooks/15/deliveries", "status": "failed", "attempts": 3, "last_status_code": 500, "last_error": "Internal Server Error" }, "event_context": { "endpoint": "GET /api/v1/events/{id}", "id_source": "streamEventId", "store": ["monitorId", "monitorType", "type", "occurredAt", "data"] }, "handoff_state": "verified_signature_then_join_event_context" } ```
For the complete documentation index, see llms.txt.Use these X API workflows for dashboards, webhooks, agents, exports, and content. Choose the handoff here, then open the focused workflow or API page for copy-ready examples. Run the [API checklist](/guides/x-api-integration-checklist) before launch.
For the complete documentation index, see llms.txt.Use this production checklist to handle Twitter API rate limits, REST API calls, error responses, cursor pagination, and signed webhook events with Xquik. Apply its API error handling rules before launching a client, workflow, or agent. Use API pagination for complete tweet, follower, reply, and event collections. Treat HTTP status codes as control flow. Protect durable API writes with idempotency keys and status polling. ## Integration Readiness Checklist Run this checklist before connecting a production client, workflow builder, or agent to the API.
For the complete documentation index, see llms.txt.Copy-pasteable TypeScript helpers for common Xquik API objects. Use these for prototypes, docs examples, and lightweight clients. For complete generated coverage, use the [OpenAPI spec](https://docs.xquik.com/openapi.yaml) or an [official SDK](/sdks). | Contract area | Curated types | Route use | | ------------- | ----------------------------------------------- | ----------------------------------------------------------- | | Tweets | `Tweet`, `PaginatedTweets`, `TweetSearchParams` | Search tweets and continue with `nextCursor`. | | Profiles | `User`, `PaginatedUsers` | Read profiles, followers, following, and mentions. | | Monitors | `Monitor`, `KeywordMonitor` | Create and reconcile account or keyword monitors. | | Events | `Event`, `EventList` | Page through stored monitor events. | | Webhooks | `Webhook`, `WebhookDelivery` | Track subscriptions and delivery attempts. | | Extractions | `Extraction`, `ExtractionResultPage` | Run follower or reply exports and retrieve saved rows. | | Write actions | `WriteAction` | Track tweets, follows, likes, reposts, and profile updates. | | Errors | `ApiError` | Branch on status, code, message, and retry details. | ## Usage 3 ways to use these types in your project: 1. **Copy curated types** - copy the "Response types", "Request types", and "Shared types" tabs into a single `xquik-types.ts` file 2. **Copy individual interfaces** - grab only the types you need (e.g. `Tweet`, `EventList`) 3. **Generate full coverage from OpenAPI** - use the [OpenAPI spec](https://docs.xquik.com/openapi.yaml) with tools like `openapi-typescript` to auto-generate types: ```bash theme={null} npx openapi-typescript https://docs.xquik.com/openapi.yaml -o xquik-api.d.ts ```
For the complete documentation index, see llms.txt.Build Zapier Twitter automation through Xquik without an X Developer app. Search tweets, export followers, route webhooks, and approve write actions. Build a private Zapier Platform CLI integration. Add routes after Zap history confirms repeated demand. ## Replace the Retired Zapier Twitter Integration Zapier retired its native Twitter integration in 2023. Xquik restores those workflows through an API-key connection. Choose an Xquik connection based on the workflow:
For the complete documentation index, see llms.txt.Use this page when an AI agent needs to choose the right Xquik surface. It can search tweets, inspect profiles, export followers, or recover missed webhooks. Keep live calls narrow. Aggregate high-volume pages inside the sandbox. Persist cursor state. Move durable jobs to REST, SDKs, or webhooks. ## Pick the agent surface
For the complete documentation index, see llms.txt.Xquik documentation is available as an MCP server at `https://docs.xquik.com/mcp`. AI tools can search the full docs site and retrieve indexed public pages - API reference, guides, examples, and type definitions - during conversations. This differs from the [Xquik API MCP server](/mcp/overview) at `xquik.com/mcp`. That server searches tweets, looks up profiles, exports followers, runs draws, and manages monitors. The docs MCP server is read-only and requires no authentication.
For the complete documentation index, see llms.txt.Xquik API MCP v2.6.0 exposes a scoped REST catalog through 2 [Model Context Protocol](https://modelcontextprotocol.io) tools. Full credentials see 120 catalog routes. Of these, 119 return JSON or text through MCP. Private support media downloads use REST. Guest `paid_reads` keys see exactly 33 GET routes.
For the complete documentation index, see llms.txt.Xquik API MCP v2.6.0 exposes a scoped catalog through 2 tools. `explore` searches. `xquik` runs authenticated calls. Full credentials see 120 catalog routes. Of these, 119 return JSON or text through MCP. Active guest `paid_reads` keys see exactly 33 GET routes. Modern clients negotiate MCP `2026-07-28` through `server/discover`. Current SDKs add request metadata and HTTP headers automatically. See [MCP 2026-07-28](/mcp/overview#mcp-2026-07-28). | Agent task | MCP call | Durable output | | --------------------- | ------------------------------------------ | ------------------------------------------------------------- | | Discover tweet routes | `explore` over `spec.endpoints` | Save the chosen method, path, parameters, and cost. | | Search tweets | `xquik.request('/api/v1/x/tweets/search')` | Preserve tweet IDs, authors, timestamps, and `next_cursor`. | | Export followers | `xquik.request('/api/v1/extractions')` | Persist the extraction ID before polling or exporting. | | Extract replies | `xquik.request('/api/v1/extractions')` | Store the target tweet ID and extraction ID together. | | Monitor keywords | `xquik.request('/api/v1/monitors')` | Save the monitor ID before creating its webhook. | | Replay events | `xquik.request('/api/v1/events')` | Keep event IDs and the next page cursor. | | Run write actions | `xquik.request()` with the write route | Store `write_action_id`, `status_url`, and `charged_credits`. | ## explore Search the authenticated API catalog. `explore` makes no network calls and uses no credits. Full credentials search 120 routes. Guest keys search 33 GET routes. **Input:**
For the complete documentation index, see llms.txt.The [Machine Payments Protocol](https://mpp.dev) (MPP) is an open standard for machine-to-machine payments over HTTP. Xquik accepts direct MPP payments on 7 fixed-price read operations. You can call them without an account, API key, or subscription. ## How it works MPP uses HTTP 402 (Payment Required) as a payment challenge. When you call a direct MPP operation without authentication, the server returns an `application/problem+json` response and a `WWW-Authenticate: Payment` header. Your client pays through Tempo (USDC), then retries the request with a payment credential. ```text theme={null} Client Xquik │ │ │ 1. GET /api/v1/x/tweets/123 │ │──────────────────────────────────▶│ │ │ │ 2. 402 Payment Required │ │ WWW-Authenticate: Payment │ │ (challenge with amount, etc.) │ │◀──────────────────────────────────│ │ │ │ 3. Pay via Tempo (USDC) │ │ (off-band) │ │ │ │ 4. Retry with credential │ │ Authorization: Payment proof │ │──────────────────────────────────▶│ │ │ │ 5. HTTP response + │ │ Payment-Receipt │ │◀──────────────────────────────────│ ```
| Capability | MPP | Guest wallet | Account |
|---|---|---|---|
| Account required | No | No | Yes |
| Credential | Per-request payment credential | paid\_reads API key |
Full API key or OAuth token |
| Payment | Per request via Tempo (USDC) | $10-$250 USD hosted checkout | Available account credits; plans add monthly credits |
| Available endpoints | 7 fixed-price GET operations | 33 prepaid GET routes | Full account API |
| Write actions | Not available | Not available | Available with a connected X account |
| Monitors, webhooks, extractions, and draws | Not available | Not available | Available |
| Best for | Machine-paid requests | Prepaid reads without an account | Full platform workflows |
For the complete documentation index, see llms.txt.Call 7 fixed-price Xquik operations without an account or subscription. Pay per request with Tempo (USDC) using the `mppx` SDK. ## Step 1: Install the SDK ```bash theme={null} npm i mppx viem ``` The `mppx` package provides both client and server utilities. You only need the client. `viem` is required for wallet account management. ## Step 2: Set up a Tempo wallet You need a Tempo wallet funded with USDC, plus its raw hex private key for the `mppx` client. **Path A - CLI only (recommended for agents)** ```bash theme={null} mppx account create # generates a local keychain-backed account mppx account export # prints the hex private key (0x...) ``` Fund the account's address with USDC on Tempo, then copy the exported key into `TEMPO_PRIVATE_KEY`. **Path B - Web wallet as a USDC source** Use [wallet.tempo.xyz/welcome](https://wallet.tempo.xyz/welcome) as a hosted UI to buy & send USDC. Run `mppx account create` to mint a local account, copy its address, send USDC from the web wallet to that address, then run `mppx account export` to get the hex key. The web wallet cannot be imported into `mppx`. It is a funding source, not a key source. > **Warning:** Store your private key securely. Never commit it to version control. Use environment variables. ## Step 3: Make a charge request Look up a single tweet. The SDK intercepts 402 responses, pays via Tempo, and retries automatically. ```typescript theme={null} import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; // Configure the MPP client. This patches global fetch // to automatically handle 402 Payment Required challenges Mppx.create({ methods: [ tempo({ account: privateKeyToAccount(process.env.TEMPO_PRIVATE_KEY as `0x${string}`), }), ], }); // Now any fetch to an MPP-enabled endpoint auto-pays const response = await fetch( "https://xquik.com/api/v1/x/tweets/1893456789012345678" ); const data = await response.json(); console.log(data.tweet.text); ``` `Mppx.create()` patches the global `fetch` function. When a direct MPP request returns 402 with a `WWW-Authenticate: Payment` header, the SDK pays the requested amount and retransmits the request with an `Authorization: Payment` credential. Every response after accepted payment includes a `Payment-Receipt` header confirming settlement. ## Step 4: Raw HTTP flow without the SDK If you are not using the `mppx` SDK, you can implement the protocol manually. **Step 1: Request the endpoint** ```bash theme={null} curl -i https://xquik.com/api/v1/x/tweets/1893456789012345678 ``` **Step 2: Receive the 402 challenge** ```text theme={null} HTTP/2 402 WWW-Authenticate: Payment id="abc...", realm="xquik.com", method="tempo", intent="charge", request="eyJhbW91bnQiOi..." ``` The `request` parameter is a base64url-encoded JSON object containing the amount, currency, and recipient address. The `application/problem+json` body also includes an optional `payment_options.guest_wallet.create_checkout` action. It does not replace the MPP header, and the failed request creates no checkout. Ignore it when completing MPP. Use it only after a user explicitly chooses and confirms a $10-$250 USD guest wallet. **Step 3: Pay and retry** After completing the Tempo payment, retry the request with the payment credential: ```bash theme={null} curl -i https://xquik.com/api/v1/x/tweets/1893456789012345678 \ -H "Authorization: Payment eyJjaGFsbGVuZ2UiOnsi..." ``` The `Authorization: Payment` value is a base64url-encoded JSON object containing the original challenge and your payment proof. **Step 4: Receive the response + receipt** ```text theme={null} HTTP/2 200 Payment-Receipt: eyJzdGF0dXMiOiJzdWNjZXNzIiwi... Content-Type: application/json {"tweet": {"id": "1893456789012345678", "text": "..."}} ``` The `Payment-Receipt` header confirms settlement. Check the HTTP status and response body separately because accepted payments also include a receipt on non-2xx responses. ## Next steps * [MPP overview](/mpp/machine-payments-protocol): 7 direct MPP operations, pricing, and protocol details. * [Guest wallets](/guides/guest-wallets): Prepay 33 eligible reads with an accountless API key. * [Get tweet](/api-reference/x/get-tweet): Full endpoint reference for tweet lookups. * [Get user](/api-reference/x/twitter-profile-lookup): Full endpoint reference for user lookups. # Xquik, X & Twitter Trademark & Affiliation Notice Source: https://docs.xquik.com/non-affiliation Learn how Xquik references X, Twitter, tweets, profiles, and related trademarks while operating as an independent third-party service. Includes examples.
For the complete documentation index, see llms.txt.**Xquik is an independent third-party service.** Not affiliated with X Corp. "Twitter" and "X" are trademarks of X Corp. ## What This Means Xquik builds and operates its own APIs, SDKs, MCP tools, webhooks, dashboard, and documentation. X Corp. does not sponsor, authorize, endorse, or operate Xquik. No partnership, agency, or official integration is implied. References to X, Twitter, tweets, reposts, replies, followers, following, profiles, timelines, communities, lists, direct messages, and other platform features identify the services and workflows that Xquik supports. Those references do not transfer ownership of X Corp. trademarks or products to Xquik. ## Separate Services Xquik controls its subscriptions, credits, API keys, endpoints, SDKs, monitor events, and webhook deliveries. X Corp. controls the X platform, X accounts, official X APIs, developer access, platform rules, and feature availability. Changes made by either service may affect an integration. Use official X Corp. websites when you need X account support, official X API access, X developer terms, trademark policies, or platform status. Use Xquik support when you need help with Xquik API keys, credits, requests, responses, exports, monitors, SDKs, MCP tools, or webhook signatures. ## Your Responsibilities Review the rules that apply to your use case before collecting tweets, profiles, followers, replies, media, or other content. Keep permissions, retention, disclosure, and deletion requirements in mind. Product examples explain Xquik request and response contracts. They are not legal advice or a replacement for applicable platform terms. # OAuth 2.1 for MCP & X API Agent Authorization Source: https://docs.xquik.com/oauth/overview Authorize MCP clients with OAuth 2.1, PKCE, CIMD, and dynamic client registration. Follow token, redirect, discovery, and refresh examples. See examples.
For the complete documentation index, see llms.txt.Xquik supports [OAuth 2.1](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1) Authorization Code with S256 PKCE for remote MCP authentication. Modern clients discover the flow automatically from `https://xquik.com/mcp`, open Xquik login and consent in a browser, then store and refresh Bearer tokens.
For the complete documentation index, see llms.txt.Official Xquik SDKs wrap the REST API with generated request types, response models, retries, pagination helpers, and consistent authentication. Use this page to choose the right SDK, CLI, or MCP handoff for tweet search exports, follower export jobs, media tweets, DM attachments, monitor webhooks, and agent workflows.
For the complete documentation index, see llms.txt.Use the CLI when a shell script, cron job, CI workflow, or operations runbook needs X API data without an application wrapper. It can search tweets, scrape tweets to JSON Lines, CSV, or XLSX, export follower data, upload media, post media tweets, post tweet replies, send direct messages, monitor tweets, and hand results to `jq`, Python, a warehouse loader, or a queue worker. ## Install ```bash theme={null} go install github.com/Xquik-dev/x-twitter-scraper-cli/cmd/x-twitter-scraper@latest ``` Make sure your Go bin directory is on `PATH`: ```bash theme={null} export PATH="$PATH:$(go env GOPATH)/bin" ``` ## Authenticate ```bash theme={null} export X_TWITTER_SCRAPER_API_KEY="xq_YOUR_KEY_HERE" ``` You can also pass `--api-key` per command or use `X_TWITTER_SCRAPER_BEARER_TOKEN` for OAuth 2.1 access tokens. ## Basic Example ```bash theme={null} x-twitter-scraper x:tweets search \ --q from:elonmusk \ --limit 10 \ --format json ``` Use `--help` at any level: ```bash theme={null} x-twitter-scraper x:tweets search --help ``` ## Workflow: Search Tweets to JSON Lines, CSV, or XLSX Use this workflow when an analyst, data engineer, or growth operator needs tweets from an X search query in a JSON Lines handoff, analyst CSV file, XLSX workbook, warehouse load, CRM enrichment job, or queue. The CLI command below calls `GET /x/tweets/search`. It maps the same REST API query parameters to flags: `--q`, `--limit`, `--cursor`, `--since-time`, `--until-time`, and `--query-type`. ```bash theme={null} query="from:username webhook OR SDK" cursor="" page_index=0 headers='["source","query","tweet_id","text","author_id","author_username","author_name","created_at","like_count","reply_count","retweet_count","quote_count","view_count","bookmark_count","is_note_tweet","page_index","page_cursor","next_cursor","has_next_page"]' : > xquik-tweet-search.jsonl jq -nr "$headers | @csv" > xquik-tweet-search.csv while :; do page_cursor="$cursor" if [ -n "$cursor" ]; then x-twitter-scraper x:tweets search \ --q "$query" \ --query-type Latest \ --cursor "$cursor" \ --limit 100 \ --format json \ --format-error json > search-page.json else x-twitter-scraper x:tweets search \ --q "$query" \ --query-type Latest \ --limit 100 \ --format json \ --format-error json > search-page.json fi has_next_page="$(jq -r '.has_next_page // false' search-page.json)" next_cursor="$(jq -r 'if .has_next_page then (.next_cursor // "") else "" end' search-page.json)" jq -c \ --arg source "xquik.cli.search" \ --arg query "$query" \ --arg page_cursor "$page_cursor" \ --arg next_cursor "$next_cursor" \ --argjson page_index "$page_index" \ --argjson has_next_page "$has_next_page" \ '.tweets[] | { source: $source, query: $query, tweet_id: .id, text: .text, author_id: (.author.id // ""), author_username: (.author.username // ""), author_name: (.author.name // ""), created_at: (.createdAt // ""), like_count: (.likeCount // 0), reply_count: (.replyCount // 0), retweet_count: (.retweetCount // 0), quote_count: (.quoteCount // 0), view_count: (.viewCount // 0), bookmark_count: (.bookmarkCount // 0), is_note_tweet: (.isNoteTweet // false), page_index: $page_index, page_cursor: $page_cursor, next_cursor: $next_cursor, has_next_page: $has_next_page }' search-page.json >> xquik-tweet-search.jsonl jq -r \ --arg source "xquik.cli.search" \ --arg query "$query" \ --arg page_cursor "$page_cursor" \ --arg next_cursor "$next_cursor" \ --argjson page_index "$page_index" \ --argjson has_next_page "$has_next_page" \ '.tweets[] | [ $source, $query, .id, .text, (.author.id // ""), (.author.username // ""), (.author.name // ""), (.createdAt // ""), (.likeCount // 0), (.replyCount // 0), (.retweetCount // 0), (.quoteCount // 0), (.viewCount // 0), (.bookmarkCount // 0), (.isNoteTweet // false), $page_index, $page_cursor, $next_cursor, $has_next_page ] | @csv' search-page.json >> xquik-tweet-search.csv [ "$has_next_page" = "true" ] || break [ -n "$next_cursor" ] || break cursor="$next_cursor" page_index=$((page_index + 1)) done ``` The response includes `.tweets[]`, `.has_next_page`, and `.next_cursor`. Each tweet can include `id`, `text`, `createdAt`, engagement counts, `bookmarkCount`, `isNoteTweet`, `author`, `media`, `quoted_tweet`, and `retweeted_tweet`, depending on what X returns for the result. Project `.tweets[]` into `xquik-tweet-search.jsonl` and `xquik-tweet-search.csv` rows with `tweet_id`, `author_username`, engagement counts, `page_index`, `page_cursor`, `next_cursor`, and `has_next_page` so scripts can resume safely or load the same records into XLSX, CRM, warehouse, or agent workflows. ```bash theme={null} python3 - <<'PY' import csv import json rows = [json.loads(line) for line in open("xquik-tweet-search.jsonl", encoding="utf-8")] fieldnames = [ "source", "query", "tweet_id", "text", "author_id", "author_username", "author_name", "created_at", "like_count", "reply_count", "retweet_count", "quote_count", "view_count", "bookmark_count", "is_note_tweet", "page_index", "page_cursor", "next_cursor", "has_next_page", ] with open("xquik-tweet-search-from-jsonl.csv", "w", newline="", encoding="utf-8") as handle: writer = csv.DictWriter(handle, fieldnames=fieldnames) writer.writeheader() writer.writerows(rows) PY ``` Save the cursor with the job checkpoint before requesting the next page: ```bash theme={null} tail -n 1 xquik-tweet-search.jsonl | jq '{query, page_index, next_cursor, has_next_page}' ``` Use `--limit` as a 1 to 200 upper bound for a bounded pull. When `.has_next_page` is true, keep the same `--q`, filters, `--query-type`, and `--limit`; only `--cursor` changes. Tweet search costs 1 credit per tweet returned. If remaining credits cannot cover a bounded `--limit` request, the API can return fewer tweets; if 0 paid results are affordable, it returns `402 insufficient_credits`. For bounded pulls that return fewer tweets than the requested `--limit`, pass `.next_cursor` back as `--cursor` with the same query, filters, `--query-type`, and `--limit`. Use `--format-error json` so batch jobs can branch on `status` and `code`, and retry `429` or temporary `5xx` responses with backoff. For XLSX handoff, keep `xquik-tweet-search.jsonl` as the source of truth and convert the same projected rows in your pipeline when account managers need a workbook. ## Workflow: Follower Export to CSV, JSON, or XLSX Use this workflow when sales, support, research, or marketing teams need an owned follower list in a CRM import, warehouse load, analyst CSV file, XLSX workbook, or resumable JSON handoff. `follower_explorer` requires `targetUsername`. The CLI flag is `--target-username`. ```bash theme={null} x-twitter-scraper extractions estimate-cost \ --tool-type follower_explorer \ --target-username username \ --format json > follower-estimate.json ``` The estimate calls `POST /extractions/estimate` and returns `allowed`, `estimatedResults`, `creditsRequired`, `creditsAvailable`, and `source`. For follower exports, `source` is usually `followers`. ```bash theme={null} jq -e '.allowed == true' follower-estimate.json >/dev/null x-twitter-scraper extractions run \ --tool-type follower_explorer \ --target-username username \ --format json > follower-run.json jq -e '.status == "running" and .toolType == "follower_explorer"' follower-run.json >/dev/null job_id="$(jq -r '.id' follower-run.json)" ``` The run command calls `POST /extractions` and returns the queued `202 Accepted` receipt: `id`, `toolType`, and `status: "running"`. Persist `follower-run.json`, `job_id`, the source username, and the estimate before polling. Credit reservation happens after the job starts. If available credits changed since the estimate, the run can fetch only the affordable count before export or mark the job `failed` with `insufficient_credits`. ```bash theme={null} while :; do x-twitter-scraper extractions retrieve \ --id "$job_id" \ --limit 1000 \ --format json > followers-page.json status="$(jq -r '.job.status' followers-page.json)" [ "$status" = "completed" ] && break [ "$status" = "failed" ] && exit 1 sleep 10 done ``` The retrieve command returns `.job`, `.results`, `.hasMore`, and `.nextCursor`. When `.hasMore` is true, pass `.nextCursor` back as `--cursor` to fetch the next saved page. ```bash theme={null} : > xquik-followers.jsonl cursor="" while :; do if [ -n "$cursor" ]; then x-twitter-scraper extractions retrieve \ --id "$job_id" \ --cursor "$cursor" \ --limit 1000 \ --format json > followers-page.json else x-twitter-scraper extractions retrieve \ --id "$job_id" \ --limit 1000 \ --format json > followers-page.json fi jq -c '.results[]' followers-page.json >> xquik-followers.jsonl has_more="$(jq -r '.hasMore // false' followers-page.json)" next_cursor="$( jq -r 'if .hasMore then (.nextCursor // "") else "" end' followers-page.json )" [ "$has_more" = "true" ] || break [ -n "$next_cursor" ] || break cursor="$next_cursor" done ``` ```bash theme={null} x-twitter-scraper extractions export-results \ --id "$job_id" \ --format csv \ --output xquik-followers.csv ``` Use `--format json --output xquik-followers.json` for app ingestion or `--format xlsx --output xquik-followers.xlsx` for XLSX handoff. Map `User ID` or result `xUserId` as the CRM unique key. Keep `xquik-followers.jsonl` for queue replay or warehouse loads, `xquik-followers.json` for app ingestion, `xquik-followers.csv` for CRM import, and `xquik-followers.xlsx` for analyst handoff. Cost: 1 credit per follower extracted or returned. Exports are free after the extraction job exists. ## Workflow: Tweet Replies to CSV, JSON, or XLSX Use this workflow when you need every reply under one Tweet. Export CSV, JSON, or XLSX. Write a local JSON Lines file from paginated JSON rows. `reply_extractor` requires `targetTweetId`. The CLI flag is `--target-tweet-id`. ```bash theme={null} x-twitter-scraper extractions estimate-cost \ --tool-type reply_extractor \ --target-tweet-id 1893704267862470862 \ --format json > reply-estimate.json ``` The estimate calls `POST /extractions/estimate` and returns `allowed`, `estimatedResults`, `creditsRequired`, `creditsAvailable`, and `source`. For replies, `source` is usually `replyCount`. ```bash theme={null} jq -e '.allowed == true' reply-estimate.json >/dev/null job_id="$(x-twitter-scraper extractions run \ --tool-type reply_extractor \ --target-tweet-id 1893704267862470862 \ --transform id \ --raw-output)" ``` The run command calls `POST /extractions`. Persist `job_id` before polling so a shell restart, queue retry, or CI rerun can resume the same extraction. Reuse the follower export polling loop above with reply filenames: ```bash theme={null} x-twitter-scraper extractions retrieve \ --id "$job_id" \ --limit 100 \ --format json > replies-page.json next_cursor="$(jq -r '.nextCursor // empty' replies-page.json)" x-twitter-scraper extractions retrieve \ --id "$job_id" \ --cursor "$next_cursor" \ --limit 100 \ --format json > replies-next-page.json ``` The retrieve command calls `GET /extractions/{id}` and returns `.job`, `.results`, `.hasMore`, and `.nextCursor`. Append `.results[]` to your queue, CRM import, or warehouse load. While `.hasMore` is true, pass `.nextCursor` back as `--cursor "$next_cursor"`. ```bash theme={null} x-twitter-scraper extractions export-results \ --id "$job_id" \ --format csv \ --output xquik-tweet-replies.csv ``` The export command calls `GET /extractions/{id}/export` and writes bytes to `--output`. Use `--format csv`, `--format json` with `--output xquik-tweet-replies.json`, or `--format xlsx` with `--output xquik-tweet-replies.xlsx`. Cost: 1 credit per reply extracted or returned. Exports are free after the extraction job exists. ## Workflow: Post Media Tweets, Replies, and DM Attachments Use this workflow when an operator, support queue, or agent needs to publish a media-backed tweet, reply with media, or send one media attachment in a DM from a connected X account. Tweet and reply media posts use public media URLs directly on `x:tweets create`. Pass repeated `--media` flags for up to 4 image URLs, or pass exactly 1 MP4 video URL up to 100 MB. Do not mix video with other media. Do not upload first when you already have public media URLs. ```bash theme={null} x-twitter-scraper x:tweets create \ --account @username \ --text "New demo video is live." \ --media https://example.com/product-demo.mp4 \ --format json \ --format-error json > posted-tweet.json ``` To reply with media, add the parent tweet ID. The `--reply-to-tweet-id` flag maps to `reply_to_tweet_id`, and `--media` maps to the public URL array on `POST /x/tweets`. ```bash theme={null} x-twitter-scraper x:tweets create \ --account @username \ --text "Here is the requested screenshot." \ --reply-to-tweet-id 1893704267862470862 \ --media https://example.com/export-preview.png \ --format json \ --format-error json > posted-reply.json ``` Send a unique `Idempotency-Key`. Store the durable action's `id`, `request.hash`, `billing`, `result`, and `statusUrl`. Poll while `terminal` is false. Retry only when `safeToRetry` is true, using a new key. Keep one JSON Lines handoff shape for every lifecycle state: ```bash theme={null} write_handoff() { input_file="$1" jq -c ' { status, terminal, safe_to_retry: .safeToRetry, write_action_id: .id, request_hash: .request.hash, tweet_id: (.result.id // .tweetId // null), charged: .billing.charged, charged_credits: .billing.chargedCredits, poll: (if .terminal then null else .statusUrl end) } ' "$input_file" } write_handoff posted-tweet.json > tweet-handoff.jsonl write_handoff posted-reply.json > reply-handoff.jsonl ``` Each create-tweet call costs 30 credits. Use `x:media upload` when you need an uploaded media ID for a DM attachment. The CLI upload command accepts a local file through `--file`; `--transform mediaId` extracts the upload response ID for scripts. ```bash theme={null} media_id="$(x-twitter-scraper x:media upload \ --account @username \ --file ./handoff.png \ --transform mediaId \ --raw-output)" x-twitter-scraper x:dm send \ --account @username \ --user-id 44196397 \ --text "Here is the asset." \ --media-id "$media_id" \ --format json > sent-dm.json jq -c --arg media_id "$media_id" '{ status: "sent", message_id: .messageId, media_id: $media_id }' sent-dm.json > dm-handoff.jsonl ``` The `--media-id` flag maps to the REST `media_ids` body field. DMs accept exactly 1 uploaded media ID. Store `messageId` from the DM response on the support ticket, CRM record, queue job, or agent memory. Keep DM body text in private systems. Shared logs, public artifacts, queue status, and agent handoffs should store `message_id`, optional `media_id`, recipient/account identifiers from your job context, and send status instead of full DM bodies. Uploading media costs 10 credits, and sending the DM costs 10 credits. Do not pass `--reply-to-message-id` to `x:dm send`; the REST endpoint rejects `reply_to_message_id`. Start a new DM with `--user-id`, `--account`, `--text`, and optional one-item `--media-id` instead. Do not pass uploaded `mediaId` values to `x:tweets create`; that command uses `--media` with public media URLs. ## Useful Commands
For the complete documentation index, see llms.txt.Use the C# SDK for typed .NET Standard 2.0+ access to Xquik from services, workers, console tools, and ASP.NET backends. It is useful when a .NET job needs to search tweets, scrape tweets or replies to JSON Lines, CSV, or XLSX, export followers, monitor tweets, post media tweets, upload media, send direct messages, or hand X API data to queues, CRMs, and reporting systems. | C# worker task | SDK call | Durable checkpoint | | ---------------------------------- | ---------------------------------------- | ------------------------------------------------ | | Search tweets | `client.X.Tweets.Search` | Persist `page.NextCursor` after every page. | | Estimate follower or reply exports | `client.Extractions.EstimateCost` | Store the estimate and `Allowed` decision. | | Start an extraction | `client.Extractions.Run` | Save `job.ID` immediately. | | Retrieve saved rows | `client.Extractions.Retrieve` | Keep `NextCursor` while `HasMore` is true. | | Export CSV, JSON, or XLSX | `client.Extractions.ExportResults` | Record the job ID, format, and file destination. | | Create a tweet | `client.X.Tweets.WithRawResponse.Create` | Store the write action ID and terminal state. | ## Install The current NuGet package excludes `GET /support/attachments/{id}`. Use REST for that binary download. ```bash theme={null} dotnet add package XTwitterScraper ``` ## Authenticate ```bash theme={null} export X_TWITTER_SCRAPER_API_KEY="xq_YOUR_KEY_HERE" ``` `new XTwitterScraperClient()` reads `X_TWITTER_SCRAPER_API_KEY`, `X_TWITTER_SCRAPER_BEARER_TOKEN`, and `X_TWITTER_SCRAPER_BASE_URL`. ## Basic Example Search tweets and write durable JSON Lines handoff rows: ```csharp theme={null} using System.Text.Json; using XTwitterScraper; using XTwitterScraper.Models; using XTwitterScraper.Models.X.Tweets; XTwitterScraperClient client = new(); TweetSearchParams parameters = new() { Q = "from:username webhook OR SDK", Limit = 10, }; PaginatedTweets page = await client.X.Tweets.Search(parameters); foreach (SearchTweet tweet in page.Tweets) { var row = new { tweet_id = tweet.ID, text = tweet.Text, author_username = tweet.Author?.Username, created_at = tweet.CreatedAt, }; await Console.Out.WriteLineAsync(JsonSerializer.Serialize(row)); } ``` ## Workflow: Search Tweets to JSON Lines, CSV, or XLSX Use this workflow when a .NET worker, console job, or ASP.NET background service needs tweet search results in a durable handoff format for a queue, data lake, analyst CSV export, XLSX workbook, or CRM enrichment step. `client.X.Tweets.Search` calls `GET /x/tweets/search`. Build a `TweetSearchParams` object with the same query parameters the REST API accepts: `Q`, `Limit`, `Cursor`, `SinceTime`, `UntilTime`, and `QueryType`. ```csharp theme={null} using System.Collections.Generic; using System.IO; using System.Linq; using System.Text.Json; using XTwitterScraper; using XTwitterScraper.Models; using XTwitterScraper.Models.X.Tweets; XTwitterScraperClient client = new(); string query = "from:username webhook OR SDK"; string? cursor = null; int pageIndex = 0; string[] headers = new[] { "source", "query", "tweet_id", "text", "author_id", "author_username", "author_name", "created_at", "like_count", "reply_count", "retweet_count", "quote_count", "view_count", "bookmark_count", "is_note_tweet", "page_index", "page_cursor", "next_cursor", "has_next_page", }; using StreamWriter jsonlWriter = File.CreateText("xquik-tweet-search.jsonl"); using StreamWriter csvWriter = File.CreateText("xquik-tweet-search.csv"); await WriteCsvRow(csvWriter, headers); do { string? pageCursor = cursor; PaginatedTweets page = await client.X.Tweets.Search( new TweetSearchParams { Q = query, Cursor = cursor, QueryType = QueryType.Latest, } ); foreach (SearchTweet tweet in page.Tweets) { Dictionary
For the complete documentation index, see llms.txt.Use typed Go requests to search tweets and export followers or replies. Send JSON Lines, CSV, or XLSX files to workers, queues, and analysts. | Go task | SDK call | Save | | ---------------- | ------------------------ | ------------ | | Search tweets | `client.X.Tweets.Search` | `NextCursor` | | Export followers | `client.Extractions.Run` | `job.ID` | ## Install ```bash theme={null} go get github.com/Xquik-dev/x-twitter-scraper-go ``` ## Authenticate ```bash theme={null} export X_TWITTER_SCRAPER_API_KEY="xq_YOUR_KEY_HERE" ``` ```go theme={null} client := xtwitterscraper.NewClient( option.WithAPIKey(os.Getenv("X_TWITTER_SCRAPER_API_KEY")), ) ``` ## Basic Example Search tweets and write durable JSON Lines handoff rows: ```go theme={null} package main import ( "context" "encoding/json" "os" "github.com/Xquik-dev/x-twitter-scraper-go" "github.com/Xquik-dev/x-twitter-scraper-go/option" ) func main() { client := xtwitterscraper.NewClient( option.WithAPIKey(os.Getenv("X_TWITTER_SCRAPER_API_KEY")), ) page, err := client.X.Tweets.Search(context.Background(), xtwitterscraper.XTweetSearchParams{ Q: "from:username webhook OR SDK", Limit: xtwitterscraper.Int(10), }) if err != nil { panic(err) } encoder := json.NewEncoder(os.Stdout) for _, tweet := range page.Tweets { row := map[string]string{ "tweet_id": tweet.ID, "text": tweet.Text, "author_username": tweet.Author.Username, "created_at": tweet.CreatedAt, } if err := encoder.Encode(row); err != nil { panic(err) } } } ``` ## Workflow: Search Tweets to JSON Lines, CSV, or XLSX This job is for backend workers that need searchable tweet data in a stable handoff format for queues, data lakes, analyst CSV files, or XLSX workbooks. It calls `GET /x/tweets/search` through `client.X.Tweets.Search`, requests the newest matching tweets, and writes each returned tweet as one JSON object per line. ```go theme={null} package main import ( "context" "encoding/json" "os" "github.com/Xquik-dev/x-twitter-scraper-go" "github.com/Xquik-dev/x-twitter-scraper-go/option" ) func main() { client := xtwitterscraper.NewClient( option.WithAPIKey(os.Getenv("X_TWITTER_SCRAPER_API_KEY")), ) out, err := os.Create("xquik-tweet-search.jsonl") if err != nil { panic(err) } defer out.Close() encoder := json.NewEncoder(out) cursor := "" for { params := xtwitterscraper.XTweetSearchParams{ Q: "from:username webhook OR SDK", QueryType: xtwitterscraper.XTweetSearchParamsQueryTypeLatest, } if cursor != "" { params.Cursor = xtwitterscraper.String(cursor) } page, err := client.X.Tweets.Search(context.Background(), params) if err != nil { panic(err) } for _, tweet := range page.Tweets { if err := encoder.Encode(tweet); err != nil { panic(err) } } if !page.HasNextPage || page.NextCursor == "" { break } cursor = page.NextCursor } } ``` The example builds an `XTweetSearchParams` request so the Go fields stay aligned with `GET /x/tweets/search`. The generated params map directly to the REST endpoint:
For the complete documentation index, see llms.txt.Use the Java SDK for generated JVM models, builders, sync calls, async calls, typed exceptions, retries, and file upload helpers in Java 8+ applications. It fits JVM services, Spring workers, queue consumers, and cron jobs. Search tweets, export followers, monitor tweets, post media, upload files, or send direct messages. Hand tweet, follower, reply, and profile rows to analytics or CRM systems. | Java worker task | SDK call | Durable checkpoint | | ---------------------------------- | ---------------------------------------------- | ------------------------------------------------ | | Search tweets | `client.x().tweets().search` | Persist `page.nextCursor()` after every page. | | Estimate follower or reply exports | `client.extractions().estimateCost` | Store the estimate and `allowed()` decision. | | Start an extraction | `client.extractions().run` | Save `job.id()` immediately. | | Retrieve saved rows | `client.extractions().retrieve` | Keep `nextCursor()` while `hasMore()` is true. | | Export CSV, JSON, or XLSX | `client.extractions().exportResults` | Record the job ID, format, and file destination. | | Create a tweet | `client.x().tweets().withRawResponse().create` | Store the write action ID and terminal state. | ## Install