X Twitter Scraper

https://github.com/xquik-dev/x-twitter-scraper-ruby
Admin
X Twitter Scraper is a Ruby library providing convenient access to the X Twitter Scraper REST API...
Tokens:37,914
Snippets:441
Trust Score:5.5
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Add and Run Examples

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Place your custom example scripts in the 'examples/' directory. Make them executable and then run them using the Ruby interpreter.

```ruby
#!/usr/bin/env ruby
# frozen_string_literal: true

require_relative "../lib/x_twitter_scraper"

# ...
```

```bash
$ chmod +x './examples/<your-example>.rb'

# run the example against your api
$ ruby './examples/<your-example>.rb'
```

--------------------------------

### Install x-twitter-scraper

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Add this line to your Gemfile to install the library.

```ruby
gem "x-twitter-scraper", "~> 0.4.0"
```

--------------------------------

### Install Gem from Git

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Add this line to your Gemfile to install the gem directly from its GitHub repository. This is useful for using the latest development version.

```ruby
gem "x-twitter-scraper", git: "https://github.com/Xquik-dev/x-twitter-scraper-ruby"
```

--------------------------------

### Complete Account Management Example

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/10-account-resource.md

Demonstrates a full workflow including retrieval, username linking, and locale updates.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Get account info
account = client.account.retrieve
puts "Account email: #{account.email}"
puts "Current locale: #{account.locale}"

# Update X username
updated = client.account.set_x_username(username: "myaccount")
puts "Linked to X account: @#{updated.username}"

# Change locale
locale_updated = client.account.update_locale(locale: :es)
puts "Locale changed to: Spanish"
```

--------------------------------

### Setup and manage webhooks

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Demonstrates creating a webhook, testing the connection, and listing recent delivery statuses.

```ruby
require "x_twitter_scraper"
require "webrick"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Create webhook pointing to your server
webhook = client.webhooks.create(
  url: "https://myapp.com/x-webhook",
  events: ["tweet_created", "tweet_liked"]
)

puts "Webhook created: #{webhook.id}"

# Test the webhook
test = client.webhooks.test(id: webhook.id)
puts "Test status: #{test.status_code}"

# View recent deliveries
deliveries = client.webhooks.list_deliveries(webhook.id)
deliveries.data.each do |delivery|
  puts "#{delivery.event}: #{delivery.status}"
end
```

--------------------------------

### client.extractions.run

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Start a data extraction process using a specific tool.

```APIDOC
## client.extractions.run(tool:, params:)

### Description
Initiate a data extraction task.

### Parameters
- **tool** (string) - Required - The extraction tool to use.
- **params** (hash) - Required - Parameters for the extraction tool.
```

--------------------------------

### Complete request configuration example

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/09-request-options.md

Demonstrates overriding client-level defaults like timeout and retries while simultaneously adding custom query parameters and headers.

```ruby
require "x_twitter_scraper"
require "securerandom"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"],
  timeout: 60,
  max_retries: 2
)

# Override defaults for specific request
response = client.x.tweets.search(
  q: "ruby -tips",
  limit: 50,
  request_options: {
    # Override defaults
    timeout: 30,
    max_retries: 5,
    
    # Add custom parameters
    extra_query: {
      # Custom filter not in standard API
      min_likes: 100,
      include_retweets: false
    },
    
    # Add custom headers
    extra_headers: {
      "X-Request-ID" => SecureRandom.uuid,
      "X-Client-Version" => "1.0.0"
    }
  }
)

puts "Found #{response.data.length} tweets"
```

--------------------------------

### Bootstrap Project Dependencies

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Run this command to install all necessary dependencies for the project. Ensure your Ruby environment is set up correctly.

```bash
$ ./scripts/bootstrap
```

--------------------------------

### Basic Initialization and Tweet Search

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/01-client.md

Example of initializing the client with an API key and performing a paginated tweet search.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Search tweets
paginated_tweets = client.x.tweets.search(
  q: "from:elonmusk",
  limit: 10
)

puts paginated_tweets.has_next_page
```

--------------------------------

### client.extractions.run

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/14-extractions-drafts.md

Starts an extraction job to collect data from Twitter using a specified tool.

```APIDOC
## client.extractions.run

### Description
Starts an extraction job to collect data. Supported tools include followers, following, tweets, likes, bookmarks, search_tweets, thread, mentions, media, hashtag, retweets, quotes, replies, communities, list_tweets, and spaces.

### Parameters
- **tool** (String) - Required - Extraction tool name
- **params** (Hash) - Required - Tool-specific parameters
- **notify_email** (String) - Optional - Email for completion notification
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::ExtractionRunResponse
```

--------------------------------

### client.x.users.retrieve_following

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get users that a user follows.

```APIDOC
## client.x.users.retrieve_following(id, cursor: nil, page_size: nil, request_options: {})

### Description
Get users that a user follows.

### Parameters
- **id** (String) - Required - User ID or username
- **cursor** (String) - Optional - Pagination cursor
- **page_size** (Integer) - Optional - Results per page (20-200, default 200)
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::PaginatedUsers
```

--------------------------------

### Handle API Connection Errors

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/02-errors.md

Example of rescuing connection errors to log the URL and underlying cause.

```ruby
begin
  tweets = client.x.tweets.search(q: "ruby")
rescue XTwitterScraper::Errors::APIConnectionError => e
  puts "Network error: #{e.message}"
  puts "URL: #{e.url}"
  puts "Cause: #{e.cause}"
end
```

--------------------------------

### Handle Conversion Errors

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/02-errors.md

Example of rescuing a conversion error to inspect the cause and message.

```ruby
begin
  response = client.x.users.retrieve("some_user")
rescue XTwitterScraper::Errors::ConversionError => e
  puts "Failed to parse response: #{e.message}"
  puts "Cause: #{e.cause}"
  # Access raw unparsed value with response[property]
end
```

--------------------------------

### client.x.users.retrieve_batch

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get multiple users by IDs or usernames (batch lookup).

```APIDOC
## client.x.users.retrieve_batch(ids:, request_options: {})

### Description
Get multiple users by IDs or usernames (batch lookup).

### Parameters
- **ids** (String) - Required - Comma-separated user IDs or usernames (max 100)
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::PaginatedUsers
```

--------------------------------

### Retrieve following list

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get a paginated list of users that a specific user follows.

```ruby
following = client.x.users.retrieve_following(
  "elonmusk",               # User ID or username (required)
  cursor: nil,              # Pagination cursor
  page_size: nil            # Results per page (20-200, default 200)
)
```

```ruby
following = client.x.users.retrieve_following(
  "elonmusk",
  page_size: 50
)

following.data.each do |user|
  puts "Follows: @#{user.username}"
end
```

--------------------------------

### Preview Documentation

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Generate and preview the project's documentation locally. An optional port can be specified for the preview server.

```bash
$ bundle exec rake docs:preview [PORT=8808]
```

--------------------------------

### client.x.users.retrieve_followers

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get followers of a user (paginated).

```APIDOC
## client.x.users.retrieve_followers(id, cursor: nil, page_size: nil, request_options: {})

### Description
Get followers of a user (paginated).

### Parameters
- **id** (String) - Required - User ID or username
- **cursor** (String) - Optional - Pagination cursor for followers list
- **page_size** (Integer) - Optional - Items per page (20-200, default 200)
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::PaginatedUsers
```

--------------------------------

### client.x.users.retrieve_followers_you_know

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get followers you know (mutual connections) for a user.

```APIDOC
## client.x.users.retrieve_followers_you_know(id, cursor: nil, request_options: {})

### Description
Get followers you know (mutual connections) for a user.

### Parameters
- **id** (String) - Required - User ID for followers-you-know lookup
- **cursor** (String) - Optional - Pagination cursor
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::PaginatedUsers
```

--------------------------------

### Initialize with Custom Configuration

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/01-client.md

Configuring the client with specific timeout and retry limits.

```ruby
client = XTwitterScraper::Client.new(
  api_key: "your-api-key",
  timeout: 30,        # 30 second timeout
  max_retries: 5      # Retry up to 5 times
)
```

--------------------------------

### Create a monitor

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Initializes a new monitor for specific keywords or account activity.

```ruby
monitor = client.monitors.create(
  account: "@myaccount",
  keywords: ["ruby", "rails"],
  track_mentions: true
)
```

```ruby
monitor = client.monitors.create(
  account: "@myaccount",
  keywords: ["python", "django", "fastapi"],
  track_mentions: true
)

puts "Monitor created: #{monitor.id}"
puts "Status: #{monitor.status}"
```

--------------------------------

### client.x.tweets.list

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Get multiple tweets by IDs (batch lookup).

```APIDOC
## client.x.tweets.list

### Description
Get multiple tweets by IDs (batch lookup).

### Parameters
- **ids** (String) - Required - Comma-separated tweet IDs (max 100)
- **request_options** (Hash) - Optional - Request configuration

### Returns
`XTwitterScraper::Models::PaginatedTweets`
```

--------------------------------

### Initialize and use the client

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/README.md

Create a client instance and perform a search query for tweets.

```ruby
require "bundler/setup"
require "x_twitter_scraper"

x_twitter_scraper = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"] # This is the default and can be omitted
)

response = x_twitter_scraper.x.tweets.search(q: "from:elonmusk", limit: 10)

puts(response)
```

--------------------------------

### Create a New Community

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/15-trends-communities.md

Demonstrates how to initialize a new community and retrieve its metadata, including rules and member counts.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Create community
community = client.x.communities.create(
  name: "Web Developers Global",
  description: "Discussion about web development trends, frameworks, and best practices",
  private: false
)

puts "Created community: #{community.name}"
puts "ID: #{community.id}"

# Add rules via description
info = client.x.communities.retrieve_info(community.id)
puts "Rules: #{info.rules.join(", ")}"

# Get initial members (just creator)
members = client.x.communities.retrieve_members(community.id)
puts "Members: #{members.data.length}"
```

--------------------------------

### client.monitors.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Create a new monitor for specific keywords on an account.

```APIDOC
## client.monitors.create(account:, keywords:)

### Description
Set up a monitor to track specific keywords for an account.

### Parameters
- **account** (string) - Required - The account to monitor.
- **keywords** (array) - Required - The list of keywords to track.
```

--------------------------------

### Get tweet retweeters with Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Retrieves a list of users who have retweeted a specific tweet.

```ruby
users = client.x.tweets.get_retweeters(
  "123456789",              # Tweet ID (required)
  cursor: nil,
  request_options: {}
)
```

--------------------------------

### Initialize and Use Request Parameters

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/08-base-model.md

Demonstrates creating a parameter object, using it with the splat operator, and converting it to a hash.

```ruby
# Create a params object
params = XTwitterScraper::X::TweetSearchParams.new(
  q: "ruby",
  limit: 10,
  query_type: :Latest
)

# Use with splat operator
tweets = client.x.tweets.search(**params)

# Convert to hash
hash = params.to_h
```

--------------------------------

### Get tweet replies with Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Retrieves reply tweets for a specific tweet ID.

```ruby
replies = client.x.tweets.get_replies(
  "123456789",              # Tweet ID (required)
  cursor: nil,
  request_options: {}
)
```

--------------------------------

### client.monitors.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Creates a new monitor to track specific keywords or account activity.

```APIDOC
## client.monitors.create

### Description
Creates a monitor to track keywords or account activity.

### Parameters
- **account** (String) - Required - X account to monitor
- **keywords** (Array<String>) - Required - Keywords to track
- **track_mentions** (Boolean) - Optional - Track mentions of account
- **track_replies** (Boolean) - Optional - Track replies to account
- **match_type** (Symbol) - Optional - :exact or :fuzzy matching
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::MonitorCreateResponse
```

--------------------------------

### Retrieve mutual followers

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Get a list of followers that you also follow (mutual connections).

```ruby
known_followers = client.x.users.retrieve_followers_you_know(
  "123456789",              # User ID (required)
  cursor: nil               # Pagination cursor
)
```

```ruby
known = client.x.users.retrieve_followers_you_know("1234567890")
known.data.each do |user|
  puts "You both know: @#{user.username}"
end
```

--------------------------------

### Initialize and use x-twitter-scraper

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Initialize the client with an API key and perform basic operations like searching tweets, retrieving user profiles, and creating tweets.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Search tweets
tweets = client.x.tweets.search(
  q: "ruby",
  limit: 10
)

puts "Found #{tweets.count} tweets"

# Lookup user
user = client.x.users.retrieve("elonmusk")
puts "@#{user.username} has #{user.followers_count} followers"

# Create tweet
tweet = client.x.tweets.create(
  account: "@myaccount",
  text: "Hello, Ruby!"
)
```

--------------------------------

### Handle API Timeout Errors

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/02-errors.md

Example of handling a timeout error when a specific request duration is exceeded.

```ruby
begin
  tweets = client.x.tweets.search(
    q: "ruby",
    request_options: { timeout: 5 }
  )
rescue XTwitterScraper::Errors::APITimeoutError => e
  puts "Request timed out after 5 seconds"
  puts "URL: #{e.url}"
end
```

--------------------------------

### Get tweet thread with Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Retrieves the full chain of replies associated with a specific tweet ID.

```ruby
thread = client.x.tweets.get_thread(
  "123456789",              # Tweet ID (required)
  request_options: {}
)
```

--------------------------------

### XTwitterScraper::Client.new

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/01-client.md

Initializes a new client instance with authentication credentials and configuration options.

```APIDOC
## XTwitterScraper::Client.new

### Description
Initializes a new instance of the XTwitterScraper client. This client manages authentication, connection pooling, and request retries.

### Parameters
- **api_key** (String, nil) - Optional - API key for authentication. Defaults to ENV["X_TWITTER_SCRAPER_API_KEY"].
- **bearer_token** (String, nil) - Optional - OAuth 2.1 access token. Defaults to ENV["X_TWITTER_SCRAPER_BEARER_TOKEN"].
- **base_url** (String, nil) - Optional - Base URL for API requests. Defaults to "https://xquik.com/api/v1".
- **max_retries** (Integer) - Optional - Maximum number of automatic retries on failure. Defaults to 2.
- **timeout** (Float) - Optional - Request timeout in seconds. Defaults to 60.0.
- **initial_retry_delay** (Float) - Optional - Initial retry delay in seconds. Defaults to 0.5.
- **max_retry_delay** (Float) - Optional - Maximum retry delay in seconds. Defaults to 8.0.
```

--------------------------------

### client.x.communities.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/15-trends-communities.md

Creates a new community.

```APIDOC
## client.x.communities.create

### Description
Create a new community.

### Parameters
- **name** (String) - Required - Community name
- **description** (String) - Required - Community description
- **private** (Boolean) - Optional - Whether private (default public)
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::X::CommunityCreateResponse
```

--------------------------------

### Create and Poll Real-Time Monitor in Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Initializes a client to create a monitor and enters a loop to poll for events every 60 seconds. Requires the X_TWITTER_SCRAPER_API_KEY environment variable to be set.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

# Create monitor
monitor = client.monitors.create(
  account: "@myaccount",
  keywords: ["ruby", "rails"],
  track_mentions: true
)

puts "Monitor created: #{monitor.id}"

# Poll for events
loop do
  events = client.events.list(monitor_id: monitor.id)
  
  events.data.each do |event|
    case event.type
    when "keyword_match"
      puts "Keyword matched: #{event.tweet.text}"
      puts "Author: @#{event.tweet.author.username}"
    when "mention"
      puts "You were mentioned: #{event.tweet.text}"
    when "follow"
      puts "New follower: @#{event.user.username}"
    end
  end
  
  sleep(60)  # Check every minute
end
```

--------------------------------

### client.x.users.follow.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/05-x-users.md

Follows a specific user on X.

```APIDOC
## client.x.users.follow.create

### Description
Follows a user on X using the specified account and user ID.

### Parameters
- **account** (String) - Required - The handle of the account performing the action.
- **user_id** (String) - Required - The ID of the user to follow.

### Example
```ruby
response = client.x.users.follow.create(
  account: "@myaccount",
  user_id: "1234567890"
)
```
```

--------------------------------

### Compare large file upload efficiency

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Demonstrates the difference between streaming via Pathname and loading into memory via File.read.

```ruby
# Good - streams the file
response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/large_video.mp4")
)

# Less efficient - loads entire file into memory
response = client.x.media.upload(
  account: "@myaccount",
  file: File.read("/path/to/large_video.mp4")
)
```

--------------------------------

### Get quote tweets with Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Retrieves quote tweets for a given tweet ID, with optional filtering by time and reply inclusion.

```ruby
quotes = client.x.tweets.get_quotes(
  "123456789",              # Tweet ID (required)
  cursor: nil,
  include_replies: nil,
  since_time: nil,
  until_time: nil,
  request_options: {}
)
```

--------------------------------

### Create a Community

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/15-trends-communities.md

Creates a new community with the specified name and description.

```ruby
new_community = client.x.communities.create(
  name: "Ruby Enthusiasts",
  description: "A community for Ruby developers"
)
```

```ruby
community = client.x.communities.create(
  name: "Ruby on Rails Developers",
  description: "Discuss Rails frameworks, best practices, and projects"
)

puts "Created: #{community.id}"
puts "Name: #{community.name}"
```

--------------------------------

### Get tweet favoriters with Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/04-x-tweets.md

Retrieves a list of users who liked a specific tweet. Supports pagination via the cursor parameter.

```ruby
users = client.x.tweets.get_favoriters(
  "123456789",              # Tweet ID (required)
  cursor: nil,              # Pagination cursor
  request_options: {}
)
```

```ruby
users = client.x.tweets.get_favoriters("1234567890")
users.data.each do |user|
  puts "Liked by: @#{user.username}"
end
```

--------------------------------

### Upload Media to X

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/12-data-types.md

Uploads a local file to X using the media client. Requires a valid account handle and a Pathname object.

```ruby
response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/image.jpg")
)
```

--------------------------------

### Retrieve monitor details

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Fetches the configuration and status of a specific monitor by its ID.

```ruby
monitor = client.monitors.retrieve(
  id: "monitor_123456"
)
```

--------------------------------

### Run All Rake Commands

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Execute this command to display a list of all available Rake tasks and commands within the project. Use 'bundle exec rake' to ensure tasks run with the correct gem versions.

```bash
$ bundle exec rake
```

--------------------------------

### Lint and Typecheck Project Files

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Run this command to perform linting and type checking on the project's Ruby files using RuboCop and the configured type checkers (Sorbet/Steep).

```bash
$ bundle exec rake lint
```

--------------------------------

### Initialize XTwitterScraper Client

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Instantiate the client with API credentials and optional connection parameters.

```ruby
client = XTwitterScraper::Client.new(
  api_key: "...",
  bearer_token: "...",
  base_url: "https://xquik.com/api/v1",
  max_retries: 2,
  timeout: 60.0,
  initial_retry_delay: 0.5,
  max_retry_delay: 8.0
)
```

--------------------------------

### Basic Request Options Usage

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/09-request-options.md

Demonstrates passing timeout and max_retries within the request_options hash.

```ruby
response = client.x.tweets.search(
  q: "ruby",
  request_options: {
    timeout: 120,
    max_retries: 5
  }
)
```

--------------------------------

### client.monitors.update

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Updates the settings for an existing monitor.

```APIDOC
## client.monitors.update

### Description
Update monitor settings.

### Parameters
- **id** (String) - Required - Monitor ID
- **keywords** (Array<String>) - Optional - New keywords
- **track_mentions** (Boolean) - Optional - Track mentions
- **track_replies** (Boolean) - Optional - Track replies
- **match_type** (Symbol) - Optional - Matching type
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::Monitor
```

--------------------------------

### Initialize XTwitterScraper Client

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/01-client.md

Standard initialization of the client with API credentials and connection settings.

```ruby
client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"],
  bearer_token: ENV["X_TWITTER_SCRAPER_BEARER_TOKEN"],
  base_url: "https://xquik.com/api/v1",
  max_retries: 2,
  timeout: 60.0,
  initial_retry_delay: 0.5,
  max_retry_delay: 8.0
)
```

--------------------------------

### Overriding Configuration per Request

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/09-request-options.md

Demonstrates how to override global client settings for a specific request.

```ruby
response = client.x.tweets.search(
  q: "ruby",
  request_options: {
    timeout: 30,
    max_retries: 10
  }
)
```

--------------------------------

### Clone and Reference Local Repository

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Clone the repository locally and then reference it in your Gemfile using a local path. This is useful for development and testing changes.

```bash
$ git clone -- 'https://github.com/Xquik-dev/x-twitter-scraper-ruby' '<path-to-repo>'
```

```ruby
gem "x-twitter-scraper", path: "<path-to-repo>"
```

--------------------------------

### Initialize XTwitterScraper::FilePart

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Constructor for creating a FilePart object with content, optional filename, and content type.

```ruby
XTwitterScraper::FilePart.new(
  content,
  filename: nil,
  content_type: nil
)
```

--------------------------------

### Configuring Client-level Defaults

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/09-request-options.md

Sets default configuration values that apply to all requests made by the client instance.

```ruby
client = XTwitterScraper::Client.new(
  api_key: "...",
  timeout: 120,
  max_retries: 5,
  initial_retry_delay: 1.0,
  max_retry_delay: 16.0
)
```

--------------------------------

### Share Client Across Threads

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/11-advanced-features.md

Demonstrates thread-safe usage of the client instance across multiple concurrent threads.

```ruby
require "concurrent"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

# Safe to use across multiple threads
threads = 5.times.map do |i|
  Thread.new(i) do |thread_id|
    tweets = client.x.tweets.search(
      q: "ruby",
      limit: 10
    )
    puts "Thread #{thread_id}: Found #{tweets.count} tweets"
  end
end

threads.each(&:join)
```

--------------------------------

### Pretty-printing instances and classes

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/08-base-model.md

Uses inspect to view the structure of instances and classes.

```ruby
user = client.x.users.retrieve("elonmusk")
puts user.inspect
# => #<XTwitterScraper::Models::X::UserProfile username="elonmusk", followers_count=150000000, ...>

puts XTwitterScraper::Models::X::UserProfile.inspect
# => XTwitterScraper::Models::X::UserProfile
```

--------------------------------

### client.x

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Methods for X data lookups and operations.

```APIDOC
## client.x

### Methods
- `get_article(tweet_id:)`: Get full article content
- `get_home_timeline(cursor:)`: Get home timeline
- `get_notifications(cursor:, type:)`: Get notifications
- `get_trends(cursor:)`: Get trending topics
```

--------------------------------

### Initialize TweetCreateParams

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/12-data-types.md

Configures parameters for creating a new tweet, including account, text, media, and reply references.

```ruby
params = XTwitterScraper::X::TweetCreateParams.new(
  account: "@myaccount",
  text: "Hello world",
  media_ids: ["123456"],
  reply_to_tweet_id: "999999"
)

tweet = client.x.tweets.create(**params)
```

--------------------------------

### client.webhooks.list

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Retrieves a list of all webhooks configured for the account.

```APIDOC
## client.webhooks.list

### Description
List all webhooks for the account.

### Parameters
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::WebhookListResponse
```

--------------------------------

### Upload file using Pathname

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Recommended approach for large files to avoid loading entire contents into memory.

```ruby
require "pathname"
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

# Upload using Pathname (recommended for large files)
response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/image.jpg")
)

puts response.mediaId
```

--------------------------------

### client.x.communities.join.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/15-trends-communities.md

Joins a specific community by its ID.

```APIDOC
## client.x.communities.join.create

### Description
Join a community.

### Method
Ruby Method

### Parameters
- **community_id** (String) - Required - Community ID
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::X::CommunityActionResult

### Example
```ruby
result = client.x.communities.join.create(community_id: "community_123456")
puts "Joined: #{result.success}"
```
```

--------------------------------

### List Webhooks

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Retrieves a list of all configured webhooks for the account.

```ruby
webhooks = client.webhooks.list
```

```ruby
webhooks = client.webhooks.list

webhooks.data.each do |webhook|
  puts "ID: #{webhook.id}"
  puts "URL: #{webhook.url}"
  puts "Events: #{webhook.events.join(", ")}"
  puts "Active: #{webhook.active}"
end
```

--------------------------------

### Accessing Request Configuration

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/09-request-options.md

Demonstrates passing custom request options like timeouts and headers to a specific API call.

```ruby
begin
  response = client.x.tweets.search(
    q: "ruby",
    request_options: {
      timeout: 5,
      extra_headers: {"X-Trace" => "abc123"}
    }
  )
rescue XTwitterScraper::Errors::APITimeoutError => e
  puts "Request timed out after 5 seconds"
  puts "URL: #{e.url}"
  puts "Headers sent: #{e.headers}"
end
```

--------------------------------

### client.x.media.upload

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/06-x-media.md

Uploads media files such as images or videos to an X account. Supports various file input types including Pathname, StringIO, IO, and FilePart.

```APIDOC
## client.x.media.upload

### Description
Uploads media (images, videos) to an X account for use in tweets.

### Parameters
- **account** (String) - Required - X account (@username or ID) uploading media
- **file** (Pathname, StringIO, IO, String, FilePart) - Required - Media file to upload
- **is_long_video** (Boolean) - Optional - Whether this is a long-form video
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::X::MediaUploadResponse

### Example
```ruby
response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/image.jpg")
)
```
```

--------------------------------

### Retrieving and Paginating Users

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/08-base-model.md

Fetch followers and use the next_cursor to retrieve subsequent pages of users.

```ruby
users = client.x.users.retrieve_followers("elonmusk")

users.data.each do |user|
  puts "Followed by: @#{user.username}"
end

if users.has_next_page
  next_users = client.x.users.retrieve_followers(
    "elonmusk",
    cursor: users.next_cursor
  )
end
```

--------------------------------

### Authenticate Account Resource

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/10-account-resource.md

Initializes the client with an API key required for all account resource methods.

```ruby
# Account methods require API key
client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

account = client.account.retrieve
```

--------------------------------

### Create a Webhook

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Registers a new webhook endpoint to receive specified event notifications.

```ruby
webhook = client.webhooks.create(
  url: "https://example.com/webhook",
  events: ["tweet_created", "user_followed"]
)
```

```ruby
webhook = client.webhooks.create(
  url: "https://myapp.com/x-webhook",
  events: ["tweet_created", "tweet_liked", "user_followed"]
)

puts "Webhook created: #{webhook.id}"
```

--------------------------------

### Client Default Constants

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/01-client.md

Accessing the default configuration constants used by the client.

```ruby
XTwitterScraper::Client::DEFAULT_MAX_RETRIES           # => 2
XTwitterScraper::Client::DEFAULT_TIMEOUT_IN_SECONDS    # => 60.0
XTwitterScraper::Client::DEFAULT_INITIAL_RETRY_DELAY   # => 0.5
XTwitterScraper::Client::DEFAULT_MAX_RETRY_DELAY       # => 8.0
```

--------------------------------

### Upload media to X

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/06-x-media.md

Uploads images or videos to an X account. Pathname is the recommended file input type for large files.

```ruby
response = client.x.media.upload(
  account: "@myaccount",            # X account (required)
  file: Pathname("/path/to/file"),  # Media file (required)
  is_long_video: nil                # Long video flag
)
```

```ruby
require "pathname"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

# Upload using Pathname (recommended)
response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/image.jpg")
)

puts "Uploaded media ID: #{response.mediaId}"
```

```ruby
file = XTwitterScraper::FilePart.new(
  File.read("/path/to/video.mp4"),
  filename: "my_video.mp4",
  content_type: "video/mp4"
)

response = client.x.media.upload(
  account: "@myaccount",
  file: file,
  is_long_video: true
)

puts "Media ID: #{response.mediaId}"
```

```ruby
require "stringio"

file_content = StringIO.new(some_binary_data)

response = client.x.media.upload(
  account: "@myaccount",
  file: file_content
)
```

```ruby
# Upload media first
media_response = client.x.media.upload(
  account: "@myaccount",
  file: Pathname("/path/to/image.jpg")
)

# Use media ID in tweet
tweet = client.x.tweets.create(
  account: "@myaccount",
  text: "Check out this image!",
  media_ids: [media_response.mediaId]
)
```

--------------------------------

### Run an extraction job

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/14-extractions-drafts.md

Initiates a data collection job using a specified tool and parameters. Returns an ExtractionRunResponse model.

```ruby
response = client.extractions.run(
  tool: "followers",
  params: {
    user_id: "1234567890"
  }
)
```

```ruby
# Export followers
response = client.extractions.run(
  tool: "followers",
  params: {
    user_id: "1234567890",
    include_stats: true
  },
  notify_email: "me@example.com"
)

puts "Job ID: #{response.job_id}"
puts "Status: #{response.status}"
```

--------------------------------

### List all monitors

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Retrieves a collection of all monitors associated with the account.

```ruby
monitors = client.monitors.list
```

```ruby
monitors = client.monitors.list

monitors.data.each do |monitor|
  puts "Account: #{monitor.account}"
  puts "Keywords: #{monitor.keywords.join(", ")}"
  puts "Status: #{monitor.status}"
end
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/00-index.md

Required and optional environment variables for configuring the scraper.

```bash
X_TWITTER_SCRAPER_API_KEY         # Required API key
X_TWITTER_SCRAPER_BEARER_TOKEN    # Optional OAuth token
X_TWITTER_SCRAPER_BASE_URL        # Override base URL
```

--------------------------------

### Upload using StringIO

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Upload file data stored in an in-memory buffer.

```ruby
require "stringio"
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

# Create StringIO with file data
file_content = StringIO.new(some_binary_data)

response = client.x.media.upload(
  account: "@myaccount",
  file: file_content
)
```

--------------------------------

### client.support

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Methods for managing the support ticket system.

```APIDOC
## client.support

### Methods
- `tickets.create(subject:, body:)`: Create a ticket
- `tickets.retrieve(id:)`: Get ticket details
- `tickets.list`: List all tickets
- `tickets.update(id:, status:)`: Update ticket
- `tickets.reply(id:, message:)`: Reply to ticket
```

--------------------------------

### Accessing BaseModel fields

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/08-base-model.md

Demonstrates accessing fields using dot notation and bracket notation, including support for undocumented fields.

```ruby
user = client.x.users.retrieve("elonmusk")

# Dot notation
puts user.username
puts user.followers_count

# Bracket notation (also works with unknown fields)
puts user[:username]
puts user[:followers_count]

# Bracket notation for undocumented fields
puts user[:undocumented_field]
```

--------------------------------

### X::Users

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Methods for user profile lookup, following/follower management, and retrieving user-specific content.

```APIDOC
## X::Users Methods

- `retrieve(id:)`: Lookup user
- `retrieve_batch(ids:)`: Batch lookup
- `retrieve_followers(id:)`: Get followers
- `retrieve_followers_you_know(id:)`: Mutual followers
- `retrieve_following(id:)`: Get following
- `retrieve_likes(id:)`: Get liked tweets
- `retrieve_media(id:)`: Get media tweets
- `retrieve_mentions(id:)`: Get mentions
- `retrieve_tweets(id:)`: Get user tweets
- `retrieve_search(q:)`: Search users
- `retrieve_verified_followers(id:)`: Get verified followers
- `follow.create` / `follow.delete_all`: Follow operations
```

--------------------------------

### Run Project Tests

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/CONTRIBUTING.md

Execute all defined tests for the project using Rake. This command ensures that the codebase is functioning as expected.

```bash
$ bundle exec rake test
```

--------------------------------

### Automation & Integration

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Methods for monitoring accounts, managing events, running bulk data extractions, and configuring webhooks and integrations.

```APIDOC
## client.monitors
- create(account:, keywords:): Create a monitor
- retrieve(id:): Get monitor details
- list(): List all monitors
- update(id:, settings:): Update monitor
- deactivate(id:): Stop monitoring

## client.events
- retrieve(id:): Get event details
- list(monitor_id:): List events for a monitor

## client.extractions
- run(tool:, params:): Start an extraction job
- retrieve(id:): Get extraction status/results
- list(): List all extractions
- estimate_cost(tool:, params:): Estimate extraction cost
- export_results(id:, format:): Export extraction results

## client.webhooks
- create(url:, events:): Create a webhook
- retrieve(id:): Get webhook details
- list(): List all webhooks
- update(id:, settings:): Update webhook
- deactivate(id:): Deactivate webhook
- test(id:): Send test webhook
- list_deliveries(id:): View webhook deliveries

## client.integrations
- create(provider:, settings:): Create integration
- retrieve(id:): Get integration details
- list(): List integrations
- update(id:, settings:): Update integration
- delete(id:): Delete integration
- send_test(id:): Send test notification
- list_deliveries(id:): View delivery logs
```

--------------------------------

### client.monitors.list

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Retrieves a list of all monitors associated with the account.

```APIDOC
## client.monitors.list

### Description
List all monitors for the account.

### Parameters
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::MonitorListResponse
```

--------------------------------

### Configure request options in Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Pass a request_options hash to customize timeouts, retries, and additional query parameters or headers.

```ruby
response = client.x.tweets.search(
  q: "ruby",
  request_options: {
    timeout: 120,
    max_retries: 5,
    extra_query: {custom_param: "value"},
    extra_headers: {"X-Custom" => "header"}
  }
)
```

--------------------------------

### client.webhooks.create

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Creates a new webhook endpoint to receive notifications for specific events.

```APIDOC
## client.webhooks.create

### Description
Creates a new webhook endpoint to receive notifications for specific events.

### Parameters
- **url** (String) - Required - HTTPS endpoint to receive webhooks
- **events** (Array<String>) - Required - Event types to subscribe to
- **active** (Boolean) - Optional - Whether webhook is active (default true)
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::Webhook
```

--------------------------------

### Upload media with rate limit handling

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/06-x-media.md

Uploads a file using a Pathname to ensure memory efficiency and supports retry logic via error handling.

```ruby
begin
  response = client.x.media.upload(
    account: "@myaccount",
    file: Pathname("/path/to/file.jpg")
  )
rescue XTwitterScraper::Errors::RateLimitError => e
  puts "Rate limited. Retry after: #{e.headers['retry-after']} seconds"
end
```

--------------------------------

### Upload using raw bytes

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Upload file content provided as a raw string of bytes.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

image_bytes = File.read("/path/to/image.jpg")

response = client.x.media.upload(
  account: "@myaccount",
  file: image_bytes
)
```

--------------------------------

### client.monitors.retrieve

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Fetches the details of a specific monitor by its ID.

```APIDOC
## client.monitors.retrieve

### Description
Get details of a specific monitor.

### Parameters
- **id** (String) - Required - Monitor ID
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::Monitor
```

--------------------------------

### Create a draft tweet

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/14-extractions-drafts.md

Use the create method to initialize a new draft. Requires account and text parameters.

```ruby
draft = client.drafts.create(
  account: "@myaccount",
  text: "Draft tweet content"
)
```

```ruby
draft = client.drafts.create(
  account: "@myaccount",
  text: "Check out this amazing article about Ruby!"
)

puts "Draft created: #{draft.id}"
puts "Text: #{draft.text}"
```

--------------------------------

### Retrieve Webhook Details

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Fetches configuration details for a specific webhook by its ID.

```ruby
webhook = client.webhooks.retrieve(
  id: "webhook_123456"
)
```

--------------------------------

### X::Accounts

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Methods for managing connected X accounts.

```APIDOC
## X::Accounts Methods

- `create(username:, password:)`: Add account
- `retrieve(id:)`: Get account
- `list`: List accounts
- `delete(id:)`: Delete account
- `reauth(id:, password:)`: Re-authenticate
- `bulk_retry(account_ids:)`: Retry bulk operations
```

--------------------------------

### Accessing Undocumented Properties and Parameters

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/README.md

Demonstrates how to send custom query, body, and header parameters to endpoints and access undocumented response properties.

```ruby
account =
  x_twitter_scraper.account.retrieve(
    request_options: {
      extra_query: {my_query_parameter: value},
      extra_body: {my_body_parameter: value},
      extra_headers: {"my-header": value}
    }
  )

puts(account[:my_undocumented_property])
```

--------------------------------

### Manage Connection Pooling

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/11-advanced-features.md

Illustrates how concurrent requests utilize the client's internal HTTP connection pool.

```ruby
# Default pool size is 99
client = XTwitterScraper::Client.new(api_key: "...")

# Concurrent requests share pooled connections
100.times.map do |i|
  Thread.new { client.x.tweets.search(q: "ruby") }
end.each(&:join)

# When all connections are in use, requests queue and wait
# Queue time counts toward request timeout
```

--------------------------------

### Upload using IO descriptor

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/03-file-handling.md

Upload from an open file descriptor. Note that this method does not support automatic retries.

```ruby
require "x_twitter_scraper"

client = XTwitterScraper::Client.new(api_key: ENV["X_TWITTER_SCRAPER_API_KEY"])

File.open("/path/to/file.jpg", "rb") do |file|
  response = client.x.media.upload(
    account: "@myaccount",
    file: file
  )
end
```

--------------------------------

### Paginate resource results in Ruby

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/07-resources-overview.md

Use the cursor returned in the initial response to fetch subsequent pages of results.

```ruby
# Get first page
results = client.x.tweets.search(q: "ruby", limit: 10)

# Check if more results exist
if results.has_next_page
  next_results = client.x.tweets.search(
    q: "ruby",
    cursor: results.next_cursor,
    limit: 10
  )
end
```

--------------------------------

### Extract Followers with X Twitter Scraper

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/14-extractions-drafts.md

Demonstrates the full workflow for extracting follower data, including cost estimation, job polling, and CSV export.

```ruby
require "x_twitter_scraper"
require "csv"
require "json"

client = XTwitterScraper::Client.new(
  api_key: ENV["X_TWITTER_SCRAPER_API_KEY"]
)

user_id = "1234567890"

# Check cost first
cost = client.extractions.estimate_cost(
  tool: "followers",
  params: {user_id: user_id}
)

puts "Estimated cost: #{cost.credit_cost} credits"
puts "Estimated items: #{cost.estimated_items}"

# Start extraction
response = client.extractions.run(
  tool: "followers",
  params: {user_id: user_id},
  notify_email: "me@example.com"
)

puts "Started job: #{response.job_id}"

# Poll for completion
loop do
  job = client.extractions.retrieve(response.job_id)
  puts "Status: #{job.status} (#{job.progress_percentage}%)"
  
  break if job.status == "completed" || job.status == "failed"
  sleep(30)
end

# Export results
if job.status == "completed"
  result = client.extractions.export_results(
    id: response.job_id,
    format: "csv"
  )
  
  # Save CSV
  File.write("followers.csv", result.file_content)
  puts "Saved #{result.item_count} followers to followers.csv"
end
```

--------------------------------

### client.webhooks.test

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/13-webhooks-monitoring.md

Sends a test webhook event to verify the configured endpoint.

```APIDOC
## client.webhooks.test

### Description
Send a test webhook to verify the endpoint.

### Parameters
- **id** (String) - Required - Webhook ID
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::WebhookTestResponse
```

--------------------------------

### client.drafts.list

Source: https://github.com/xquik-dev/x-twitter-scraper-ruby/blob/main/_autodocs/14-extractions-drafts.md

Lists all drafts for an account.

```APIDOC
## client.drafts.list

### Description
Retrieves a list of all drafts, optionally filtered by account.

### Parameters
- **account** (String) - Optional - Filter by account
- **cursor** (String) - Optional - Pagination cursor
- **request_options** (Hash) - Optional - Request configuration

### Returns
XTwitterScraper::Models::DraftListResponse
```
Tokens:
Raw