Posting to X (Twitter) with the API

1. Understanding X API Authentication

Just like with LinkedIn, our application needs to get permission to post on your behalf. The X API provides two primary authentication contexts:

• App-only authentication (OAuth 2.0 Bearer Token): This context authenticates your application itself, not a specific user. It's useful for reading public data (like searching for tweets) but does not have permission to post, follow, or like on behalf of a user.
• User context authentication: This context allows your app to act on behalf of a specific user who has granted permission. This is what we need to post content. There are two common ways to achieve this with the v2 API:
  1. OAuth 2.0 Authorization Code Flow with PKCE: This is a 3-legged flow, conceptually similar to what you implemented for LinkedIn. It's the modern standard and is essential if you were building an app that other users would log into.
  2. OAuth 1.0a User Context: This is the legacy method but remains fully supported and is often simpler for personal bots or scripts that only need to act on behalf of a single, pre-authorized account (your own). It requires a set of four credentials: App Key, App Secret, User Access Token, and User Access Secret.

For your goal of creating a personal content agent, the OAuth 1.0a flow is the most direct and efficient path to get started. We will focus on that for our implementation, but it's valuable to understand the OAuth 2.0 flow as well.

2. Setting Up Your X Developer Application

Before writing any code, you must register an application on the X Developer Portal. This process will generate the credentials our TypeScript code needs.

Your User authentication settings page should look similar to this, with "Automated App or bot" selected.

3. Implementing the X Publisher in TypeScript

Now that we have our credentials, we can start coding. We'll use a popular, lightweight library called twitter-api-v2 that makes interacting with the X API straightforward and is fully typed for TypeScript.

Step 1: Project Setup

1. Install the library:
   npm install twitter-api-v2

2. Update your .env file: Add the four keys you saved from the X Developer Portal.

   
   
   
   # .env
   LINKEDIN_ACCESS_TOKEN="..."
   
   
   
   
   # X API Credentials (OAuth 1.0a)
   X_APP_KEY="your_api_key_here"
   X_APP_SECRET="your_api_key_secret_here"
   X_ACCESS_TOKEN="your_access_token_here"
   X_ACCESS_SECRET="your_access_secret_here"
   

Step 2: Creating the X Client and Posting Logic

We'll create a new file, x.ts, to house our publishing logic. The implementation is remarkably concise thanks to the twitter-api-v2 library.

The documentation for twitter-api-v2 provides excellent code examples for various tasks. We will use these as our guide.

Now, let's put it all together in a reusable function. Create a new file src/publishers/x.ts:

import { TwitterApi } from 'twitter-api-v2';

// Instantiate the client with your OAuth 1.0a credentials
const client = new TwitterApi({
  appKey: process.env.X_APP_KEY!,
  appSecret: process.env.X_APP_SECRET!,
  accessToken: process.env.X_ACCESS_TOKEN!,
  accessSecret: process.env.X_ACCESS_SECRET!,
});

// Tell the library that this client will be used for read-write operations.
// This provides better autocompletion and type-checking.
const rwClient = client.readWrite;

export async function shareOnX(text: string): Promise<string> {
  if (!text) {
    throw new Error('Tweet text cannot be empty.');
  }

  try {
    // Use the v2 endpoint to post a tweet
    const { data: createdTweet } = await rwClient.v2.tweet({
      text,
    });
    
    console.log('Successfully posted to X (Twitter).');
    console.log('Tweet ID:', createdTweet.id);
    console.log('Tweet Text:', createdTweet.text);
    
    return createdTweet.id;
  } catch (error) {
    console.error('Error posting to X:', error);
    throw error;
  }
}

This self-contained shareOnX function is now ready to be integrated into your agent. It initializes the client, ensures it has read-write permissions at the type level, and uses the modern v2.tweet endpoint.

4. Integration with Your LangGraph Agent

As in the previous lesson, you can now add a new publishing node to your LangGraph workflow.

1. Import your new shareOnX function into your main graph definition file.
2. Create a new node, publishXNode, that calls await shareOnX(state.finalContent);.
3. You can now update your graph's conditional logic. For example, after the human approval step, you could have the agent decide which platform to post to based on the content type or a specific instruction, and then route to either publishLinkedInNode or publishXNode.

This modular approach allows you to easily add more platforms in the future without altering the core logic of your generation and analysis agents.

Conclusion

Excellent work! You've now configured your agent to publish on a second major social media platform. By navigating the X API's authentication system and using a modern TypeScript library, you've added a powerful new capability to your project.

Key Takeaways:

• X API has multiple auth flows: For a personal bot, OAuth 1.0a is the simplest way to get user-context permissions (Read and Write). OAuth 2.0 PKCE is the modern standard for apps that serve multiple users.
• Permissions are crucial: You must explicitly set your app's permissions to "Read and Write" in the developer portal to be able to post content.
• The twitter-api-v2 library simplifies everything: It handles the complexities of signing requests, providing a clean, typed interface to the v1.1 and v2 APIs.
• Posting a tweet is a single API call: Once authenticated, client.v2.tweet({ text: '...' }) is all you need.

Preview of the next lesson:
We've tackled LinkedIn (professional, long-form) and X (concise, real-time). Next, we'll turn our attention to a visual-first platform. In the upcoming lesson, "Authenticate and post content via the Instagram Graph API," we will explore the opportunities and significant constraints of automating content for Instagram, which will require a different strategic approach.