X Twitter Scraper

https://github.com/xquik-dev/x-twitter-scraper-csharp
Admin
X Twitter Scraper is an official .NET library that provides convenient access to the X Twitter...
Tokens:32,595
Snippets:439
Trust Score:5.5
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### BinaryContent Usage

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Example of initializing BinaryContent for media uploads.

```csharp
using var fileStream = File.OpenRead("image.jpg");
var binaryContent = new BinaryContent(fileStream, "image/jpeg");

// Used internally when uploading media
var response = await client.X.Media.Upload(new()
{
    MediaData = binaryContent,
});
```

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

### Execute Advanced Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/10-raw-response-usage.md

Demonstrates manual request execution using the WithRawResponse client.

```csharp
// Normally use high-level APIs instead
var request = new HttpRequest<TweetSearchParams>
{
    Method = HttpMethod.Get,
    Params = new TweetSearchParams { Q = "search term" },
};

var response = await client.WithRawResponse.Execute(request);
var statusCode = response.StatusCode;
var headers = response.Headers;
```

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

### IPage Usage Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Shows how to check for additional pages and fetch them using the cursor.

```csharp
var tweets = await client.X.Tweets.Search(new()
{
    Q = "search term",
    Limit = 50,
});

Console.WriteLine($"Got {tweets.Tweets.Count} tweets");
Console.WriteLine($"Has next page: {tweets.HasNextPage}");

if (tweets.HasNextPage)
{
    var nextPage = await client.X.Tweets.Search(new()
    {
        Q = "search term",
        Limit = 50,
        Cursor = tweets.NextCursor,
    });
}
```

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

### Retrieve Trending Topics Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Demonstrates how to fetch and iterate through global trending topics using the client.

```csharp
var trends = await client.Trends.List(new()
{
    WOEID = "1", // Global trends
});

foreach (var trend in trends.Trends)
{
    Console.WriteLine($"{trend.Name}: {trend.TweetVolume} tweets");
}
```

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

### Usage Example for XTwitterScraperClient

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

Demonstrates initializing the client, overriding options for a specific request, and disposing of the client.

```csharp
using XTwitterScraper;

// Initialize with environment variables
var client = new XTwitterScraperClient();

// Override options for a single call
var response = await client
    .WithOptions(opts => opts with { Timeout = TimeSpan.FromSeconds(30) })
    .Account.Retrieve();

// Dispose when done
client.Dispose();
```

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

### Install XTwitterScraper Package

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Use the .NET CLI to add the required package to your project.

```bash
dotnet add package XTwitterScraper
```

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

### GET /support

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Retrieve support information.

```APIDOC
## GET /support

### Description
Get support information.

### Method
GET

### Endpoint
/support

### Response
#### Success Response (200)
- **SupportRetrieveResponse** (object) - Support details
```

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

### Using StreamingHttpResponse<T>

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/04-http-response.md

Example of asynchronously streaming items from the response.

```csharp
// Stream items asynchronously
var response = await client.WithRawResponse.X.Tweets.Search(parameters);

await foreach (var tweet in response.Enumerate())
{
    Console.WriteLine($"Tweet: {tweet.Text}");
}
```

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

### POST /extractions

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Start a new data extraction job.

```APIDOC
## POST /extractions

### Description
Start a new data extraction job.

### Method
POST

### Endpoint
/extractions

### Parameters
#### Request Body
- **parameters** (ExtractionCreateParams) - Required - Extraction configuration (query, filters, format)

### Response
#### Success Response (200)
- **ExtractionCreateResponse** - Returns job ID and status
```

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

### PaginatedUsers Usage Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Retrieving and iterating through a collection of user profiles.

```csharp
var followers = await client.X.Followers.GetFollowers(new()
{
    ID = "123456789",
    Limit = 100,
});

foreach (var user in followers.Users)
{
    Console.WriteLine($"@{user.Username} - {user.Name}");
    Console.WriteLine($"  Followers: {user.PublicMetrics?.FollowerCount}");
    Console.WriteLine($"  Following: {user.PublicMetrics?.FollowingCount}");
}
```

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

### JsonModel Usage Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Demonstrates lazy validation, raw data access, and explicit validation.

```csharp
var tweets = await client.X.Tweets.Search(parameters);

// Lazy validation - validation happens only when properties are accessed
var count = tweets.Tweets.Count;

// Access raw data for undocumented fields
if (tweets.RawData.TryGetValue("custom_field", out var value))
{
    var customValue = value.GetString();
}

// Explicit validation
tweets.Validate();
```

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

### Using HttpResponse<T>

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/04-http-response.md

Example of accessing raw response metadata and deserializing the response body.

```csharp
// Get typed response with raw access
HttpResponse<PaginatedTweets> response = 
    await client.WithRawResponse.X.Tweets.Search(parameters);

// Access raw response metadata
Console.WriteLine($"Status: {response.StatusCode}");

// Deserialize to typed model
var tweets = await response.Deserialize();
Console.WriteLine($"Found {tweets.Tweets.Count} tweets");
```

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

### Get Account Information

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Retrieve details about the authenticated account.

```csharp
using XTwitterScraper;

var client = new XTwitterScraperClient
{
    BearerToken = "your-oauth-token",
};

var account = await client.Account.Retrieve();

Console.WriteLine($"User ID: {account.UserID}");
Console.WriteLine($"Username: {account.Username}");
Console.WriteLine($"Email: {account.Email}");
Console.WriteLine($"Phone: {account.Phone}");
Console.WriteLine($"Verified: {account.Verified}");
Console.WriteLine($"Locale: {account.Locale}");
```

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

### SearchTweet Usage Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Demonstrates how to perform a search query and iterate through the returned SearchTweet objects to access properties like ID, metrics, and media.

```csharp
var result = await client.X.Tweets.Search(new()
{
    Q = "machine learning",
    Limit = 10,
});

foreach (var tweet in result.Tweets)
{
    Console.WriteLine($"Tweet ID: {tweet.ID}");
    Console.WriteLine($"Author: {tweet.AuthorID}");
    Console.WriteLine($"Text: {tweet.Text}");
    Console.WriteLine($"Posted: {tweet.CreatedAt}");
    
    if (tweet.PublicMetrics != null)
    {
        Console.WriteLine($"Likes: {tweet.PublicMetrics.LikeCount}");
        Console.WriteLine($"Retweets: {tweet.PublicMetrics.RetweetCount}");
    }
    
    if (tweet.Media != null)
    {
        Console.WriteLine($"Media attachments: {tweet.Media.Count}");
    }
}
```

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

### GET /credits/balance

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Retrieves the current account credit balance.

```APIDOC
## GET /credits/balance

### Description
Get current account credit balance.

### Method
GET

### Endpoint
/credits/balance

### Parameters
#### Query Parameters
- **parameters** (CreditRetrieveBalanceParams) - Optional - Balance retrieval parameters

### Response
#### Success Response (200)
- **response** (CreditRetrieveBalanceResponse) - Balance information
```

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

### GET /guest-wallets/{id}

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Retrieve guest wallet details using the wallet ID.

```APIDOC
## GET /guest-wallets/{id}

### Description
Retrieve guest wallet details.

### Method
GET

### Endpoint
/guest-wallets/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - Wallet ID

### Response
#### Success Response (200)
- **response** (GuestWalletRetrieveResponse) - Wallet info
```

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

### GET /webhooks

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

List all registered webhook endpoints.

```APIDOC
## GET /webhooks

### Description
List all registered webhooks.

### Method
GET

### Endpoint
/webhooks
```

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

### GET /account

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Retrieves account information for the authenticated user.

```APIDOC
## GET /account

### Description
Get account information for the authenticated user.

### Method
GET

### Endpoint
/account

### Parameters
#### Query Parameters
- **parameters** (AccountRetrieveParams) - Optional - Request parameters

### Response
#### Success Response (200)
- **AccountRetrieveResponse** (object) - Account details
```

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

### GET /subscribe/check

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Check the current subscription status.

```APIDOC
## GET /subscribe/check

### Description
Check current subscription status.

### Method
GET

### Endpoint
/subscribe/check

### Response
#### Success Response (200)
- **SubscribeCheckResponse** (object) - Subscription details
```

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

### Retrieve Account Balance

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Fetches the current account credit balance via GET /credits/balance.

```csharp
Task<CreditRetrieveBalanceResponse> RetrieveBalance(
    CreditRetrieveBalanceParams? parameters = null,
    CancellationToken cancellationToken = default
)
```

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

### GET /monitors/{id}

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Retrieve the details of a specific account monitor.

```APIDOC
## GET /monitors/{id}

### Description
Get monitor details.

### Method
GET

### Endpoint
/monitors/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - Monitor ID
```

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

### PaginatedTweets Usage Example

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Retrieving tweets and handling pagination using the NextCursor property.

```csharp
var tweets = await client.X.Tweets.Search(new()
{
    Q = "from:elonmusk",
    Limit = 50,
});

Console.WriteLine($"Retrieved {tweets.Tweets.Count} tweets");
Console.WriteLine($"Has next page: {tweets.HasNextPage}");

foreach (var tweet in tweets.Tweets)
{
    Console.WriteLine($"{tweet.AuthorId}: {tweet.Text}");
}

// Paginate to next page if available
if (tweets.HasNextPage)
{
    var nextPage = await client.X.Tweets.Search(new()
    {
        Q = "from:elonmusk",
        Limit = 50,
        Cursor = tweets.NextCursor,
    });
}
```

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

### GET /trends

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Get a list of trending topics by region.

```APIDOC
## GET /trends

### Description
Get list of trending topics by region.

### Method
GET

### Endpoint
/trends

### Parameters
#### Query Parameters
- **parameters** (TrendListParams) - Optional - Region/WOEID

### Response
#### Success Response (200)
- **TrendListResponse** (object) - Trending topics
```

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

### GET /events/{id}

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Get details of a specific event by its ID.

```APIDOC
## GET /events/{id}

### Description
Get details of a specific event.

### Method
GET

### Endpoint
/events/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - Event ID

### Response
#### Success Response (200)
- **response** (EventRetrieveResponse) - Event details
```

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

### Configure Client via Environment Variables

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

Initialize the client to automatically read configuration from environment variables.

```csharp
using XTwitterScraper;

// Reads API key, bearer token, and base URL environment variables.
XTwitterScraperClient client = new();
```

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

### GET /radar

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Get real-time radar data for a specific topic or keyword.

```APIDOC
## GET /radar

### Description
Get real-time radar data for a topic.

### Method
GET

### Endpoint
/radar

### Parameters
#### Query Parameters
- **topic** (string) - Required - Topic or keyword

### Response
#### Success Response (200)
- **response** (RadarGetResponse) - Real-time data
```

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

### GET /events

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

List recent events.

```APIDOC
## GET /events

### Description
List recent events.

### Method
GET

### Endpoint
/events

### Response
#### Success Response (200)
- **response** (EventListResponse) - Event list
```

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

### Bootstrap the development environment

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

Run this command to restore pinned tools and locked dependencies.

```sh
./scripts/bootstrap
```

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

### GET /x/drafts

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

List all draft tweets.

```APIDOC
## GET /x/drafts

### Description
List all draft tweets.

### Method
GET

### Endpoint
/x/drafts

### Parameters
#### Query Parameters
- **parameters** (DraftListParams) - Optional - List filtering parameters

### Response
#### Success Response (200)
- **response** (PaginatedDrafts) - Draft list
```

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

### Complete Account Service Operations in C#

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Demonstrates initializing the client and performing common account-related tasks including retrieving profile info, updating settings, and accessing raw response data.

```csharp
using System;
using XTwitterScraper;
using XTwitterScraper.Models.Account;

var client = new XTwitterScraperClient
{
    BearerToken = "your-oauth-token"
};

// Retrieve account info
var account = await client.Account.Retrieve();
Console.WriteLine($"Logged in as: @{account.Username}");
Console.WriteLine($"Email: {account.Email}");
Console.WriteLine($"Locale: {account.Locale}");

// Link X username
var setUsername = await client.Account.SetXUsername(new()
{
    Username = "myxhandle",
});
Console.WriteLine($"X username set: @{setUsername.Username}");

// Update locale
var updateLocale = await client.Account.UpdateLocale(new()
{
    Locale = "en-GB",
});
Console.WriteLine($"Locale updated to: {updateLocale.Locale}");

// Access raw response
var rawResponse = await client.WithRawResponse.Account.Retrieve();
Console.WriteLine($"Response status: {rawResponse.StatusCode}");
foreach (var header in rawResponse.Headers)
{
    Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
}
```

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

### Configure Client with Direct Credentials

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

Set API credentials directly on the client instance.

```csharp
using XTwitterScraper;

XTwitterScraperClient client = new()
{
    ApiKey = "My API Key",
    BearerToken = "My Bearer Token",
};
```

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

### Create an account monitor

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Initializes a MonitorCreateParams object and uses it to create a monitor via the client.

```csharp
var parameters = new MonitorCreateParams
{
    AccountID = "123456789",
    WebhookUrl = new Uri("https://example.com/webhook"),
    Events = new[] { "tweet", "follow" },
};

var monitor = await client.Monitors.Create(parameters);
```

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

### GetTrends

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

Get trending hashtags and topics from X by region.

```APIDOC
## Task<XGetTrendsResponse> GetTrends(XGetTrendsParams? parameters = null, CancellationToken cancellationToken = default)

### Description
Get trending hashtags and topics from X by region.

### Parameters
- **parameters** (XGetTrendsParams?) - Optional - Optional region/location parameters

### Returns
- **XGetTrendsResponse** - Containing trending topics
```

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

### Create Account Monitor

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Initializes a new account monitor with a specified webhook URL and event types.

```csharp
var monitor = await client.Monitors.Create(new()
{
    AccountID = "123456789",
    WebhookUrl = "https://example.com/webhook",
    Events = new[] { "tweet", "like", "follow" },
});

Console.WriteLine($"Monitor created: {monitor.ID}");
```

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

### Manage Client Lifecycle

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

Instantiate the client once and reuse it for multiple operations, ensuring proper disposal after use.

```csharp
// Create once and reuse
using var client = new XTwitterScraperClient();

// All operations go through the client
var tweets = await client.X.Tweets.Search(parameters);
var user = await client.X.Users.Retrieve("username");
var account = await client.Account.Retrieve();

// Dispose when done
client.Dispose();
```

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

### Configure Client Options

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Configures global client settings and demonstrates overriding options for a specific request.

```csharp
using XTwitterScraper;

var client = new XTwitterScraperClient
{
    // Increase timeout to 2 minutes
    Timeout = TimeSpan.FromMinutes(2),
    
    // Disable automatic retries
    MaxRetries = 0,
    
    // Enable response validation
    ResponseValidation = true,
    
    // Use custom base URL
    BaseUrl = "https://custom-api.example.com/v1",
};

// Override options for a single call
var result = await client
    .WithOptions(opts => opts with
    {
        Timeout = TimeSpan.FromSeconds(30),
        MaxRetries = 0,
    })
    .X.Tweets.Search(new() { Q = "test", Limit = 10 });
```

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

### Run verification gates

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

Execute these commands to lint, test, check coverage, audit, and verify reproducibility before requesting a review.

```sh
./scripts/lint
./scripts/test
./scripts/coverage
./scripts/audit
reuse lint
./scripts/check-reproducible
```

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

### IterateAll Pagination Usage

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Demonstrates how to use IterateAll to automatically traverse paginated results.

```csharp
var initialPage = await client.X.Followers.GetFollowers(new()
{
    ID = "123456789",
    Limit = 100,
});

// Iterate through all pages automatically
await foreach (var user in initialPage.IterateAll<UserProfile>(cursor =>
    client.X.Followers.GetFollowers(new()
    {
        ID = "123456789",
        Cursor = cursor,
        Limit = 100,
    })
))
{
    Console.WriteLine($"@{user.Username}");
}
```

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

### Apply Temporary Configuration

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

Use the WithOptions pattern to override client settings for a single request without affecting the original client instance.

```csharp
var result = await client
    .WithOptions(opts => opts with { MaxRetries = 0 })
    .X.Tweets.Search(parameters);

// Original client unchanged
var result2 = await client.X.Tweets.Search(parameters); // Uses MaxRetries = 2
```

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

### GET /extractions/{id}

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Check status of an ongoing extraction job.

```APIDOC
## GET /extractions/{id}

### Description
Check status of an ongoing extraction job.

### Method
GET

### Endpoint
/extractions/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the extraction job.

### Response
#### Success Response (200)
- **ExtractionRetrieveResponse** - Returns status and progress
```

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

### Define ClientOptions record struct

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

The core configuration structure for the SDK client.

```csharp
public record struct ClientOptions()
```

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

### Download Media from Extraction

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Demonstrates creating an extraction, polling for completion, and exporting results to a CSV file.

```csharp
using XTwitterScraper;
using XTwitterScraper.Models.Extractions;

var client = new XTwitterScraperClient();

// Create extraction
var extraction = await client.Extractions.Create(new()
{
    Query = "machine learning",
    MaxResults = 1000,
});

Console.WriteLine($"Extraction started: {extraction.ID}");

// Poll for completion
var status = extraction;
while (status.Status != "completed")
{
    await Task.Delay(TimeSpan.FromSeconds(5));
    
    status = await client.Extractions.Retrieve(new()
    {
        ID = extraction.ID,
    });
    
    Console.WriteLine($"Status: {status.Status}");
}

// Export results
var response = await client.Extractions.ExportResults(new()
{
    ID = extraction.ID,
    Format = Format.Csv,
});

using (var stream = await response.ReadAsStream())
using (var fileStream = File.Create("tweets.csv"))
{
    await stream.CopyToAsync(fileStream);
}

Console.WriteLine("Export saved to tweets.csv");
```

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

### Get Trending Topics

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

Retrieves trending hashtags and topics based on region parameters.

```csharp
Task<XGetTrendsResponse> GetTrends(
    XGetTrendsParams? parameters = null,
    CancellationToken cancellationToken = default
)
```

```csharp
var trends = await client.X.GetTrends(new()
{
    WOEID = "23424977", // Worldwide
});

foreach (var trend in trends.Trends)
{
    Console.WriteLine($"{trend.Name}: {trend.TweetVolume} tweets");
}
```

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

### IPageExtensions.IterateAll<T>

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Iterates through all pages of results, handling pagination automatically using a provided fetcher function.

```APIDOC
## IPageExtensions.IterateAll<T>

### Description
Iterates through all pages of results, handling pagination automatically.

### Method
public static async IAsyncEnumerable<T> IterateAll<T>(this IPage page, Func<string?, Task<IPage>> pageFetcher)

### Parameters
- **page** (IPage) - The initial page object.
- **pageFetcher** (Func<string?, Task<IPage>>) - A function that takes a cursor string and returns the next page.

### Example
```csharp
var initialPage = await client.X.Followers.GetFollowers(new()
{
    ID = "123456789",
    Limit = 100,
});

await foreach (var user in initialPage.IterateAll<UserProfile>(cursor =>
    client.X.Followers.GetFollowers(new()
    {
        ID = "123456789",
        Cursor = cursor,
        Limit = 100,
    })
))
{
    Console.WriteLine($"@{user.Username}");
}
```
```

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

### Add SDK reference to a project

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

Use this command to add a directory reference to the SDK from another project.

```sh
dotnet add reference /path/to/sdk/src/XTwitterScraper
```

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

### Initialize XTwitterScraperClient Constructors

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

The client can be initialized with default settings or custom ClientOptions.

```csharp
public XTwitterScraperClient()
public XTwitterScraperClient(ClientOptions options)
```

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

### Implement Cursor-Based Pagination

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Demonstrates how to fetch paginated results by passing the NextCursor from a previous response into the subsequent request.

```csharp
var page1 = await client.X.Followers.GetFollowers(new()
{
    ID = "user-id",
    Limit = 100,
});

Console.WriteLine($"Page 1: {page1.Users.Count} users");
Console.WriteLine($"Has next: {page1.HasNextPage}");

if (page1.HasNextPage)
{
    var page2 = await client.X.Followers.GetFollowers(new()
    {
        ID = "user-id",
        Limit = 100,
        Cursor = page1.NextCursor,
    });
    
    Console.WriteLine($"Page 2: {page2.Users.Count} users");
}
```

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

### ParamsBase Methods

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Core methods for URL generation, header management, and request body handling.

```csharp
public abstract Uri Url(ClientOptions options)
```

```csharp
internal abstract void AddHeadersToRequest(
    HttpRequestMessage request,
    ClientOptions options
)
```

```csharp
internal virtual HttpContent? BodyContent()
```

```csharp
internal virtual bool BodyCanRetry()
```

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

### Creating Parameters with FromRawUnchecked

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

Use FromRawUnchecked to initialize parameters with unsupported or raw values.

```csharp
using System.Collections.Generic;
using System.Text.Json;
using XTwitterScraper.Models.X.Tweets;

var parameters = TweetSearchParams.FromRawUnchecked
(

    rawHeaderData: new Dictionary<string, JsonElement>(),
    rawQueryData: new Dictionary<string, JsonElement>
    {
        {
            "q",
            JsonSerializer.SerializeToElement("custom value")
        }
    }
);
```

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

### Implement Pagination for X Service

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

Uses a while loop to iterate through pages by checking HasNextPage and passing the NextCursor to subsequent requests.

```csharp
var results = await client.X.Tweets.List(new()
{
    Q = "from:elonmusk",
    Limit = 50,
});

while (results.HasNextPage)
{
    results = await client.X.Tweets.List(new()
    {
        Q = "from:elonmusk",
        Limit = 50,
        Cursor = results.NextCursor,
    });
    
    foreach (var tweet in results.Tweets)
    {
        ProcessTweet(tweet);
    }
}
```

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

### Get real-time radar data via IRadarService

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Retrieves real-time insights for a specific topic or keyword.

```csharp
Task<RadarGetResponse> Get(
    RadarGetParams parameters,
    CancellationToken cancellationToken = default
)
```

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

### Get User Followers

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Retrieve a list of followers for a specific user ID, including pagination support.

```csharp
using XTwitterScraper;

var client = new XTwitterScraperClient();

var followers = await client.X.Followers.GetFollowers(new()
{
    ID = "44196397", // User ID for @Twitter
    Limit = 100,
});

Console.WriteLine($"First 100 followers of @{followers.Users[0]}:");

foreach (var follower in followers.Users)
{
    Console.WriteLine($"  @{follower.Username} - {follower.Name}");
}

// Paginate through all followers (may take time for popular accounts)
while (followers.HasNextPage)
{
    followers = await client.X.Followers.GetFollowers(new()
    {
        ID = "44196397",
        Limit = 100,
        Cursor = followers.NextCursor,
    });
    
    Console.WriteLine($"Retrieved {followers.Users.Count} more followers");
}
```

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

### Saving Binary Content to a Stream

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

Shows how to read a binary response as a stream and copy it to a file using CopyToAsync.

```csharp
using System.IO;

using var response = await client.Extractions.ExportResults(parameters);
using var contentStream = await response.ReadAsStream();
using var fileStream = File.Open(path, FileMode.OpenOrCreate);
await contentStream.CopyToAsync(fileStream); // Accepts any Stream.
```

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

### Construct parameters from raw data

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Demonstrates using FromRawUnchecked to build parameter objects from a dictionary of JsonElements.

```csharp
var parameters = TweetSearchParams.FromRawUnchecked(
    rawQueryData: new Dictionary<string, JsonElement>
    {
        { "q", JsonSerializer.SerializeToElement("search term") },
        { "max_results", JsonSerializer.SerializeToElement(50) },
    }
);

var results = await client.X.Tweets.Search(parameters);
```

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

### Modify Configuration with WithOptions

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

Use the with expression to create a temporary client instance with modified options for a single operation without affecting the original client.

```csharp
var result = await client
    .WithOptions(options =>
        options with
        {
            Timeout = TimeSpan.FromSeconds(30),
            MaxRetries = 0,
        }
    )
    .X.Tweets.Search(parameters);
```

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

### IPageExtensions Class and Method Declaration

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/08-models.md

Defines the extension class and the IterateAll method for automatic pagination.

```csharp
public static class IPageExtensions
```

```csharp
public static async IAsyncEnumerable<T> IterateAll<T>(
    this IPage page,
    Func<string?, Task<IPage>> pageFetcher
)
```

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

### Get tweet favoriters

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

Use the GetFavoriters method to retrieve profiles of users who liked a tweet. Handle the 424 status code if X withholds this information.

```csharp
try
{
    var users = await client.X.Tweets.GetFavoriters("1234567890");
    foreach (var user in users.Users)
    {
        Console.WriteLine(user.Username);
    }
}
catch (XTwitterScraperUnprocessableEntityException) when (ex.StatusCode == 424)
{
    Console.WriteLine("Favoriters are not available for this tweet");
}
```

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

### Initialize XTwitterScraper Client

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Initialize the client using environment variables or by setting credentials directly in the object initializer.

```csharp
using XTwitterScraper;

// Load from environment variables
var client = new XTwitterScraperClient();

// Or set credentials directly
var client = new XTwitterScraperClient
{
    ApiKey = "your-api-key",
    BearerToken = "your-bearer-token",
};

// Use the client
try
{
    var tweets = await client.X.Tweets.Search(new()
    {
        Q = "csharp",
        Limit = 10,
    });
    
    foreach (var tweet in tweets.Tweets)
    {
        Console.WriteLine($"{tweet.AuthorID}: {tweet.Text}");
    }
}
finally
{
    client.Dispose();
}
```

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

### Exporting Extraction Results

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

Demonstrates how to export extraction results by passing a parameters object to the client.

```csharp
using System;
using XTwitterScraper.Models.Extractions;

ExtractionExportResultsParams parameters = new()
{
    ID = "id",
    Format = Format.Csv,
};

var response = await client.Extractions.ExportResults(parameters);

Console.WriteLine(response);
```

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

### Check Response Status and Headers

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/10-raw-response-usage.md

Demonstrates verifying the HTTP status code and safely retrieving specific header values using TryGetHeaderValues.

```csharp
var response = await client.WithRawResponse.Account.Retrieve();

if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
    Console.WriteLine("Success");
    
    if (response.TryGetHeaderValues("X-RateLimit-Remaining", out var rateLimitRemaining))
    {
        Console.WriteLine($"Rate limit remaining: {rateLimitRemaining.FirstOrDefault()}");
    }
}
```

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

### Run maintenance and verification commands

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

Execute these commands prior to releases to ensure code quality, security compliance, and provenance verification.

```sh
./scripts/lint
./scripts/test
./scripts/coverage
./scripts/audit
reuse lint
./scripts/check-reproducible
gh attestation verify PACKAGE \
  --repo Xquik-dev/x-twitter-scraper-csharp \
  --signer-workflow Xquik-dev/x-twitter-scraper-csharp/.github/workflows/publish-nuget.yml
```

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

### Retrieve guest wallet details via IGuestWalletService

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Fetches wallet information using the specified wallet ID parameters.

```csharp
Task<GuestWalletRetrieveResponse> Retrieve(
    GuestWalletRetrieveParams parameters,
    CancellationToken cancellationToken = default
)
```

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

### Monitor an Account

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Creates a monitor to track specific account events and send them to a webhook URL.

```csharp
using XTwitterScraper;

var client = new XTwitterScraperClient
{
    BearerToken = "your-oauth-token",
};

// Create monitor
var monitor = await client.Monitors.Create(new()
{
    AccountID = "123456789",
    WebhookUrl = new Uri("https://example.com/monitor-webhook"),
    Events = new[] { "tweet", "like", "follow" },
});

Console.WriteLine($"Monitor created: {monitor.ID}");
Console.WriteLine($"Monitoring account: {monitor.AccountID}");
```

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

### Create Extraction Job with ExtractionCreateParams

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Initializes an extraction job using a search query and optional constraints.

```csharp
var parameters = new ExtractionCreateParams
{
    Query = "bitcoin lang:en",
    MaxResults = 10000,
    Format = "csv",
};

var extraction = await client.Extractions.Create(parameters);
```

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

### EnvironmentUrl Configuration

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Configures the API base URL for different environments using predefined constants.

```csharp
// Use sandbox for development/testing
var client = new XTwitterScraperClient
{
    BaseUrl = EnvironmentUrl.Sandbox,
};

// Or via environment variable
Environment.SetEnvironmentVariable(
    "X_TWITTER_SCRAPER_BASE_URL",
    EnvironmentUrl.Sandbox
);
```

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

### Compare Typed and Raw Response Patterns

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/10-raw-response-usage.md

Demonstrates the difference between standard typed response retrieval and accessing the raw response for manual handling.

```csharp
// Typed response (auto-deserialization)
var tweets = await client.X.Tweets.Search(parameters);

// Raw response (manual deserialization)
var rawResponse = await client.WithRawResponse.X.Tweets.Search(parameters);
var statusCode = rawResponse.StatusCode;
var headers = rawResponse.Headers;
var tweets = await rawResponse.Deserialize();
```

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

### Service Configuration Methods

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

Methods for accessing raw HTTP responses or modifying client options for the service instance.

```csharp
IXServiceWithRawResponse WithRawResponse { get; }
```

```csharp
IXService WithOptions(Func<ClientOptions, ClientOptions> modifier)
```

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

### Handle Errors

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Shows how to catch specific SDK exceptions to handle API, network, and authentication errors.

```csharp
using XTwitterScraper;
using XTwitterScraper.Exceptions;

var client = new XTwitterScraperClient();

try
{
    var tweet = await client.X.Tweets.Retrieve("invalid-id");
}
catch (XTwitterScraperNotFoundException ex)
{
    Console.WriteLine($"Tweet not found: {ex.StatusCode}");
}
catch (XTwitterScraperRateLimitException ex)
{
    Console.WriteLine($"Rate limited. Response: {ex.ResponseBody}");
}
catch (XTwitterScraperUnauthorizedException ex)
{
    Console.WriteLine($"Authentication failed: {ex.StatusCode}");
}
catch (XTwitterScraperApiException ex)
{
    Console.WriteLine($"API error {ex.StatusCode}: {ex.ResponseBody}");
}
catch (XTwitterScraperIOException ex)
{
    Console.WriteLine($"Network error: {ex.Message}");
}
catch (XTwitterScraperException ex)
{
    Console.WriteLine($"SDK error: {ex.Message}");
}
```

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

### Topup Account Balance

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Adds credits to the account balance via POST /credits/topup.

```csharp
Task<CreditTopupBalanceResponse> TopupBalance(
    CreditTopupBalanceParams parameters,
    CancellationToken cancellationToken = default
)
```

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

### client.X.Users.Retrieve

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Retrieves user information with optional field expansions.

```APIDOC
## Method: client.X.Users.Retrieve

### Description
Retrieves user data. You can specify additional fields to include in the response using the UserFields parameter.

### Parameters
#### UserFields (Array of strings)
- created_at: Account creation timestamp
- description: User bio
- location: User-specified location
- public_metrics: Follower/following counts
- url: User website
- verified: Verification status
- withheld: Content withholding info

### Request Example
var parameters = new UserRetrieveParams
{
    ID = "123456789",
    UserFields = new[]
    {
        "created_at",
        "public_metrics",
        "verified",
    },
};

var user = await client.X.Users.Retrieve(parameters);
```

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

### MonitorCreateParams

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Parameters required to create an account monitor using the SDK.

```APIDOC
## MonitorCreateParams

### Description
Defines the parameters required to create an account monitor.

### Parameters
- **AccountID** (string) - Required - User ID to monitor
- **WebhookUrl** (Uri) - Required - Webhook to deliver events
- **Events** (IReadOnlyList<string>?) - Optional - Events to monitor

### Usage Example
```csharp
var parameters = new MonitorCreateParams
{
    AccountID = "123456789",
    WebhookUrl = new Uri("https://example.com/webhook"),
    Events = new[] { "tweet", "follow" },
};

var monitor = await client.Monitors.Create(parameters);
```
```

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

### Configure Environment Variables

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Set the necessary credentials as environment variables for the scraper.

```bash
export X_TWITTER_SCRAPER_API_KEY="your-api-key"
export X_TWITTER_SCRAPER_BEARER_TOKEN="your-bearer-token"
export X_TWITTER_SCRAPER_BASE_URL="https://xquik.com/api/v1"
```

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

### BinaryContent Serialization Method

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Method signature for serializing binary content to a stream.

```csharp
protected override Task SerializeToStreamAsync(
    Stream stream,
    TransportContext? context
)
```

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

### Configure Proxy via HttpClient

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

Routes requests through a custom HttpClient configured with a WebProxy.

```csharp
using System.Net;
using System.Net.Http;
using XTwitterScraper;

var httpClient = new HttpClient
(
    new HttpClientHandler
    {
        Proxy = new WebProxy("https://example.com:8080")
    }
);

XTwitterScraperClient client = new() { HttpClient = httpClient };
```

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

### Sign a commit

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

Use this command to sign every commit with the Developer Certificate of Origin.

```sh
git commit --signoff
```

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

### Create Default HttpClientHandler

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

Configures the handler with automatic decompression and disabled redirects for optimal performance.

```csharp
internal static HttpClientHandler CreateDefaultHttpClientHandler() =>
    new()
    {
        AllowAutoRedirect = false,
        AutomaticDecompression = DecompressionMethods.Available,
    };
```

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

### EnvironmentUrl

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Provides predefined API base URLs for different environments.

```APIDOC
## EnvironmentUrl

### Description
Provides default API URLs for different environments.

### Constants
- **Production**: https://xquik.com/api/v1
- **Sandbox**: https://sandbox.xquik.com/api/v1

### Usage
```csharp
// Use sandbox for development/testing
var client = new XTwitterScraperClient
{
    BaseUrl = EnvironmentUrl.Sandbox,
};
```
```

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

### Custom Query Parameters and Headers

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/10-raw-response-usage.md

Techniques for adding custom query parameters and headers to standard SDK requests using raw data dictionaries.

```APIDOC
## Custom Parameter Injection

### Description
Users can inject undocumented API fields or custom headers into standard SDK calls using rawQueryData or rawHeaderData dictionaries.

### Custom Query Parameters Example
var parameters = new TweetSearchParams(
    rawQueryData: new Dictionary<string, JsonElement>
    {
        { "custom_param", JsonSerializer.SerializeToElement("value") }
    }
) { Q = "search term" };

### Custom Headers Example
var parameters = new TweetSearchParams(
    rawHeaderData: new Dictionary<string, JsonElement>
    {
        { "X-Custom-Header", JsonSerializer.SerializeToElement("custom-value") }
    }
) { Q = "search term" };

### FromRawUnchecked
For parameters consisting entirely of undocumented fields, use the FromRawUnchecked factory method:
var parameters = TweetSearchParams.FromRawUnchecked(
    rawQueryData: new Dictionary<string, JsonElement>
    {
        { "q", JsonSerializer.SerializeToElement("search term") },
        { "experimental_field", JsonSerializer.SerializeToElement(42) }
    }
);
```

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

### Retrieve

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Retrieves account information and returns the raw HTTP response.

```APIDOC
## Task<HttpResponse<AccountRetrieveResponse>> Retrieve(AccountRetrieveParams? parameters, CancellationToken cancellationToken)

### Description
Retrieves account details. Returns an HttpResponse containing the AccountRetrieveResponse object along with status codes and headers.

### Parameters
- **parameters** (AccountRetrieveParams) - Optional - Configuration parameters for the retrieval request.
- **cancellationToken** (CancellationToken) - Optional - Token to cancel the asynchronous operation.
```

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

### Manage parameter immutability

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Shows how to use C# record 'with' expressions to create modified copies of immutable parameter objects.

```csharp
// Create with object initializer
var params1 = new TweetSearchParams { Q = "query", Limit = 10 };

// Create a copy with changes (with expression)
var params2 = params1 with { Limit = 20 };

// Original is unchanged
Console.WriteLine(params1.Limit); // 10
Console.WriteLine(params2.Limit); // 20
```

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

### Define a Request Parameter Class

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/11-request-parameters.md

Shows the base structure for creating a custom parameter class inheriting from ParamsBase.

```csharp
public record class XxxParams : ParamsBase
{
    // Properties define request data
    public string? Property1 { get; init; }
    public int? Property2 { get; init; }
    
    // Constructor for passing raw data
    public XxxParams(
        IReadOnlyDictionary<string, JsonElement>? rawQueryData = null,
        IReadOnlyDictionary<string, JsonElement>? rawHeaderData = null
    )
}
```

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

### Create an extraction job

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Initiates a new data extraction job using the specified query and result limits.

```csharp
var extraction = await client.Extractions.Create(new()
{
    Query = "from:elonmusk",
    MaxResults = 10000,
});

Console.WriteLine($"Extraction job ID: {extraction.ID}");
Console.WriteLine($"Status: {extraction.Status}");
```

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

### Verify Release Provenance

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

Verify the authenticity of a GitHub release package using the GitHub CLI.

```bash
release_tag=vVERSION
package_version="${release_tag#v}"

gh release download "$release_tag" \
  --repo Xquik-dev/x-twitter-scraper-csharp \
  --pattern "XTwitterScraper.$package_version.nupkg"

gh attestation verify "XTwitterScraper.$package_version.nupkg" \
  --repo Xquik-dev/x-twitter-scraper-csharp \
  --signer-workflow Xquik-dev/x-twitter-scraper-csharp/.github/workflows/publish-nuget.yml \
  --source-ref "refs/tags/$release_tag" \
  --deny-self-hosted-runners
```

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

### POST /x/compose

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Compose a tweet for preview before posting.

```APIDOC
## POST /x/compose

### Description
Compose a tweet for preview before posting.

### Method
POST

### Endpoint
/x/compose

### Parameters
#### Request Body
- **parameters** (ComposeCreateParams) - Required - Tweet text and media

### Response
#### Success Response (200)
- **response** (ComposeCreateResponse) - Preview and validation details
```

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

### Retrieve Support Information Method

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Defines the asynchronous method for fetching support-related information.

```csharp
Task<SupportRetrieveResponse> Retrieve(
    SupportRetrieveParams? parameters = null,
    CancellationToken cancellationToken = default
)
```

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

### Implement Pagination

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

Iterate through paginated results using the HasNextPage property and the NextCursor value.

```csharp
var page = await client.X.Followers.GetFollowers(new()
{
    ID = "user-id",
    Limit = 100,
});

while (page.HasNextPage)
{
    // Process current page
    foreach (var user in page.Users) { }
    
    // Get next page
    page = await client.X.Followers.GetFollowers(new()
    {
        ID = "user-id",
        Limit = 100,
        Cursor = page.NextCursor,
    });
}
```

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

### Configure Account Service

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Methods for accessing raw HTTP responses or modifying client options.

```csharp
IAccountServiceWithRawResponse WithRawResponse { get; }
```

```csharp
IAccountService WithOptions(Func<ClientOptions, ClientOptions> modifier)
```

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

### Check Subscription Status Method

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Defines the asynchronous method for verifying current subscription status.

```csharp
Task<SubscribeCheckResponse> Check(
    SubscribeCheckParams? parameters = null,
    CancellationToken cancellationToken = default
)
```

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

### Define AccountSetXUsernameParams

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Represents the parameters required to link an X username to an account.

```csharp
public record class AccountSetXUsernameParams : ParamsBase
{
    public required string Username { get; init; }
}
```

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

### POST /credits/topup

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Adds credits to the account balance.

```APIDOC
## POST /credits/topup

### Description
Add credits to account balance.

### Method
POST

### Endpoint
/credits/topup

### Parameters
#### Request Body
- **parameters** (CreditTopupBalanceParams) - Required - Amount and payment method

### Response
#### Success Response (200)
- **response** (CreditTopupBalanceResponse) - Transaction details
```

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

### XTwitterScraperClientWithRawResponse.WithOptions

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

Configures the client options using a modifier function.

```APIDOC
## WithOptions

### Description
Modifies the client configuration options.

### Method
Synchronous

### Parameters
- **modifier** (Func<ClientOptions, ClientOptions>) - Required - A function to modify the current client options.

### Response
- **IXTwitterScraperClientWithRawResponse** - The configured client instance.
```

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

### Retrieve Account with Raw Response

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/06-services-account.md

Demonstrates accessing status codes and headers before deserializing the account response.

```csharp
var response = await client.WithRawResponse.Account.Retrieve();

Console.WriteLine($"Status: {response.StatusCode}");
Console.WriteLine($"Content-Type: {response.Headers.GetValues("Content-Type")}");

var account = await response.Deserialize();
Console.WriteLine($"User: {account.Username}");
```

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

### BinaryContent Declaration

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Class declaration for handling binary HTTP content.

```csharp
public sealed class BinaryContent : HttpContent
{
    public BinaryContent(
        Stream stream,
        string contentType
    )
}
```

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

### Deserializing with ModelBase Options

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Use the SDK's predefined SerializerOptions to ensure consistent deserialization of API models.

```csharp
// Custom deserialization using SDK's options
var json = @"{ ""id"": ""123"", ""text"": ""Hello"" }";
var tweet = JsonSerializer.Deserialize<Tweet>(json, ModelBase.SerializerOptions);
```

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

### Retrieve User Profile

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Fetch user profile data by username or user ID.

```csharp
using XTwitterScraper;

var client = new XTwitterScraperClient();

// By username
var user = await client.X.Users.Retrieve("elonmusk");

Console.WriteLine($"Name: {user.Data.Name}");
Console.WriteLine($"@{user.Data.Username}");
Console.WriteLine($"Followers: {user.Data.PublicMetrics?.FollowerCount:N0}");

// By user ID
var userById = await client.X.Users.Retrieve(new()
{
    ID = "44196397",
});

Console.WriteLine(userById.Data.Name);
```

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

### ParamsBase Declaration

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

The abstract base class definition for all request parameter objects.

```csharp
public abstract record class ParamsBase
```

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

### List Trending Topics Method

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Defines the asynchronous method for retrieving trending topics by region.

```csharp
Task<TrendListResponse> List(
    TrendListParams? parameters = null,
    CancellationToken cancellationToken = default
)
```

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

### Custom Parameter Handling

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/07-core-types.md

Methods for passing undocumented API fields using raw dictionaries or creating parameters from raw data.

```csharp
var parameters = new TweetSearchParams(
    rawQueryData: new Dictionary<string, JsonElement>
    {
        { "custom_param", JsonSerializer.SerializeToElement("value") }
    }
)
{
    Q = "search term",
};
```

```csharp
var parameters = TweetSearchParams.FromRawUnchecked(
    rawQueryData: new Dictionary<string, JsonElement>
    {
        { "q", JsonSerializer.SerializeToElement("search term") }
    }
);
```

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

### Configure Custom Headers via Environment Variables

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

Set custom headers by defining the X_TWITTER_SCRAPER_CUSTOM_HEADERS environment variable with newline-separated key-value pairs.

```bash
export X_TWITTER_SCRAPER_CUSTOM_HEADERS="X-Custom-Header: value
X-Another-Header: another-value"
```

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

### Use Custom HttpClient with Proxy

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/12-quick-start-examples.md

Injects a custom HttpClient configured with a proxy into the scraper client.

```csharp
using System.Net;
using System.Net.Http;
using XTwitterScraper;

var handler = new HttpClientHandler
{
    Proxy = new WebProxy("https://proxy.example.com:8080"),
    UseProxy = true,
};

var httpClient = new HttpClient(handler)
{
    Timeout = System.Threading.Timeout.InfiniteTimeSpan,
};

var client = new XTwitterScraperClient { HttpClient = httpClient };

var tweets = await client.X.Tweets.Search(new()
{
    Q = "csharp",
    Limit = 10,
});
```

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

### Pagination Pattern

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

Describes the standard pagination pattern used by listing endpoints in the SDK, utilizing cursors to fetch subsequent pages of data.

```APIDOC
## Pagination Pattern

### Description
Most listing endpoints return a paginated collection. Use the `NextCursor` property to fetch subsequent pages until `HasNextPage` is false.

### Properties
- **Data/Users/Tweets** (Collection) - The current page of results.
- **HasNextPage** (bool) - Indicates if more results are available.
- **NextCursor** (string) - The cursor value required to request the next page.

### Usage Example
```csharp
var results = await client.X.Tweets.List(new() { Q = "from:elonmusk", Limit = 50 });
while (results.HasNextPage) {
    results = await client.X.Tweets.List(new() { Q = "from:elonmusk", Limit = 50, Cursor = results.NextCursor });
    foreach (var tweet in results.Tweets) { ProcessTweet(tweet); }
}
```

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

### Create Draft Tweet

Source: https://github.com/xquik-dev/x-twitter-scraper-csharp/blob/main/_autodocs/09-additional-services.md

Initializes a new draft tweet using the provided parameters.

```csharp
Task<DraftCreateResponse> Create(
    DraftCreateParams parameters,
    CancellationToken cancellationToken = default
)
```
Tokens:
Raw