Twitter Integration

Overview

Twitter Integration empowers your AI agents to communicate with Twitter’s API, enabling actions such as posting tweets, responding to user mentions, and retrieving data. This integration relies on OAuth for secure authentication and authorized access to user accounts or app-level functionalities.

Why Integrate Twitter?

Real-Time Engagement: Interact with users on a global social media platform in real time.
Automation: Schedule tweets or respond programmatically to mentions, hashtags, and other triggers.
Data Collection: Gather valuable insights from user tweets, trends, and other public data.
Brand Presence: Allow your AI agent to maintain a consistent presence by automatically posting updates or announcements.

Prerequisites

Twitter Developer Account: Sign up at Twitter Developer Portal.
API Credentials: Obtain the Consumer Key and Consumer Secret for OAuth.
Rust & Cargo (if using Rust for your agent implementation).

Setting Up Twitter API Authentication

Step 1: Obtain Consumer Key and Consumer Secret

Log in to the Twitter Developer Portal.
Create a new project/app and record the API Key (Consumer Key) and API Secret (Consumer Secret).

Step 2: Configure OAuth Request

Use the following Rust code to request OAuth tokens from Twitter:

use reqwest::Client;
use reqwest_oauth1::{Secrets, OAuthClientProvider};
use std::error::Error;

/// Initiates the OAuth flow to obtain request tokens.
pub async fn setup(consumer_key: &str, consumer_secret: &str) -> Result<(String, String), Box<dyn Error>> {
    let secrets = Secrets::new(consumer_key, consumer_secret);
    let client = Client::new();
    // Twitter’s endpoint for obtaining a request token
    let endpoint_reqtoken = "https://api.twitter.com/oauth/request_token?oauth_callback=oob&x_auth_access_type=write";

    // Send request to obtain the OAuth token
    let resp = client.oauth1(secrets).get(endpoint_reqtoken).send().await?;
    let auth_url = format!("https://api.twitter.com/oauth/authorize?oauth_token={}", resp.oauth_token);

    // Output the authorization URL to the console
    println!("Authorize the app by visiting: {}", auth_url);
    println!("Enter the PIN provided by Twitter into your application to finalize the OAuth process.");

    // Return the request token and token secret
    Ok((resp.oauth_token, resp.oauth_token_secret))
}

Use the following Rust code to post a Tweet Example:

use oauth1::Token;
use reqwest::Client;
use serde_json::json;
use std::error::Error;

/// Posts a new tweet to the authorized Twitter account.
pub async fn post_tweet(
    consumer_key: &str,
    consumer_secret: &str,
    access_token: &str,
    access_token_secret: &str,
    tweet_text: &str,
) -> Result<(), Box<dyn Error>> {

    // Tokens for OAuth
    let consumer = Token::new(consumer_key, consumer_secret);
    let access = Token::new(access_token, access_token_secret);

    // Twitter API endpoint for posting tweets
    let url = "https://api.twitter.com/2/tweets";
    // JSON payload containing the tweet text
    let body = json!({ "text": tweet_text });

    // Send the request
    let client = Client::new();
    let response = client.post(url)
        .header("Authorization", oauth1::authorize("POST", url, &consumer, Some(&access), None))
        .header("Content-Type", "application/json")
        .json(&body)
        .send()
        .await?;

    // Print the response for debugging
    println!("Tweet posted: {:?}", response.text().await?);

    Ok(())
}

Twitter