Last week, Make.com announced the removal of its Twitter integration due to new API pricing changes, leaving many users in a bind. In this post, I’ll share three effective methods to keep your X scenarios running smoothly, even after the May 30th deadline.
Introduction to the Change
Make.com recently announced the removal of the Twitter integration, now known as X, due to new API pricing and policy requirements. This change affects many users who rely on X modules within their active scenarios. The deadline for this transition is May 30th, after which any scenarios containing these modules will begin to fail.
Given the shift in X’s API policies, Make.com has recommended exploring alternative social media applications, specifically Buffer and Hootsuite. While Hootsuite is a well-known option, I found Buffer to be more user-friendly and cost-effective, making it a viable replacement for many users.
Transitioning to Buffer not only ensures continued functionality but also simplifies the posting process. Buffer’s intuitive interface allows for quick setup and easy management of social media posts across multiple channels.
Understanding the Impact
The removal of X’s integration is significant. Users who have built automations with X will need to act quickly to avoid disruptions. The new API pricing structure has limited the capabilities of the free plan, which has been reduced from 500,000 tweets per month to just 100. This change has a direct impact on how users can interact with the platform.
For many, Buffer provides a solution that not only matches the required functionality but also offers a more straightforward approach to managing social media content. Its free plan allows users to connect up to three channels and schedule posts, making it an attractive alternative.
Additionally, Buffer supports posting tweets, images, GIFs, and videos. For those who need to perform more complex actions that Buffer doesn’t support, I’ll discuss how to directly integrate with X’s API using Make.com’s native HTTP modules.
Option 1: Buffer Integration
Buffer is an excellent choice for those looking to replace their X modules. Its pricing is competitive, offering a free plan that supports three channels. In contrast, Hootsuite’s lowest plan starts at $99 per month, which can be a significant jump for users on a budget.
Setting up Buffer is straightforward. After creating an account, you can easily connect to your X account and start posting. The process involves authorizing Buffer to access your X account and confirming the account you want to sync.
How to Set Up Buffer
To get started with Buffer, follow these simple steps:
- Create a Buffer account and log in.
- Navigate to the dashboard and click on “Connect to Channel.”
- Select Twitter and authorize the app.
- Confirm the account you wish to sync.
Once connected, you can create posts directly from Buffer’s interface. For instance, you can type your message, attach images, and share it instantly. This process is seamless and allows for efficient management of your social media presence.
After setting up Buffer, you need to integrate it into your existing Make.com scenarios. This involves adding a Buffer module to replace the X modules within your scenario.
To do this, right-click on your scenario, add a module, and type in “Buffer.” This will allow you to create a status update. You’ll then need to set up the connection, which involves an OAuth pop-up for Buffer. Once authorized, you can copy the relevant variables from your X module into the Buffer module.
For text posts, simply input the text from your X module. If you’re attaching media, ensure that you provide a publicly accessible URL for the image. This differs from the X API, where media had to be uploaded separately.
Testing Buffer Integration
Once I set up Buffer, testing the integration is essential to ensure everything is functioning correctly. I started by creating a test post directly from Buffer’s dashboard. It’s a simple process where you can enter your message, attach any media, and share it immediately.
After sharing the test post, I checked my X account to confirm the post appeared as expected. If the post doesn’t show up, it indicates an issue with the integration that needs troubleshooting. Common problems might include authorization errors or issues with the media URLs.
To verify the integration, I also used Make.com to trigger a post through the Buffer module. I ensured that the variables from the X module were correctly mapped to the Buffer module. After running the scenario, I checked my X account again for the test message.
Exploring Buffer’s Pricing
Buffer offers a competitive pricing structure that makes it accessible for various users. The free plan allows you to manage three social channels and schedule up to ten posts per month. This is a great option for small businesses or individual users looking to maintain a social media presence without incurring costs.
For those needing more, Buffer’s paid plans start at $15 per month for the Essentials plan. This plan includes more features, such as additional channels and advanced scheduling options. The Team plan, priced at $65 per month, allows for collaboration among team members, making it suitable for agencies or larger organizations.
In comparison, Hootsuite’s pricing starts at $99 per month, which is significantly higher. Buffer’s free plan and lower entry-level pricing make it an attractive alternative for users transitioning from X.
Buffer’s focus on scheduling and user-friendliness enhances its appeal. Users can plan posts daily, weekly, or even monthly, ensuring a consistent flow of content across their social channels. This flexibility is particularly beneficial for busy professionals who may not have the time to post in real-time.
Option 2: Direct X API Integration
For users who require more advanced features not supported by Buffer, direct integration with X’s API is an option. This approach allows for greater control over the data and actions performed on the platform. However, it does require a deeper understanding of APIs and authentication processes.
The direct integration process involves using Make.com’s native HTTP modules to interact with X’s API. This method enables users to access various endpoints, including those for posting tweets, retrieving user data, and managing media uploads.
Setting Up the OAuth2 Flow
Setting up the OAuth2 flow for direct API integration is crucial. The process involves several steps to generate the necessary access tokens. First, I built an authentication URL using my client ID and other required parameters. This URL directs users to authorize access to their X accounts.
Once the user grants permission, the system generates an authorization code that I can exchange for access and refresh tokens. These tokens are essential for making API calls on behalf of the user.
To ensure security, I implemented state verification during the OAuth2 flow. This step prevents unauthorized access by ensuring that the request originates from the expected source. After verifying the state, I fetch the tokens and store them securely for future API requests.
With the tokens in hand, I can now make API calls to post tweets or manage other aspects of the user’s account. This method offers flexibility and access to advanced features, although it requires careful handling of sensitive information like client secrets and tokens.
Implementing this direct integration allows for a more customized experience. While Buffer is great for general use, direct API access gives me the ability to tailor interactions based on specific needs. This could include automating complex workflows or integrating with other applications seamlessly.
Deconstructed OAuth2: Step by Step
I created an automation that breaks down the OAuth2 flow to connect with X’s API directly. This process involves several steps to generate the necessary access tokens. First, I built an authentication URL using my client ID and other required parameters.
The authentication URL directs users to authorize access to their X accounts. Once the user grants permission, the system generates an authorization code that I can exchange for access and refresh tokens. These tokens are essential for making API calls on behalf of the user.
Constructing the Authentication URL
To build the authentication URL, I needed a few variables:
- Client ID: This is associated with the app I set up in the X developer portal.
- Token Generation Webhook: This webhook triggers a scenario I created in Make, which generates the access token.
- State Verification: A unique identifier that ensures the request originates from the expected source.
- Client Secret: A sensitive value that I input securely to avoid exposure in my blueprints.
After setting up these variables, I saved them into a data store for future reference.
Generating the Access Token
Once the user authorizes the app, I receive an OAuth code. The next step is to fetch the access token using that code. This process involves hitting the token generation endpoint with the appropriate headers and parameters.
I pass in the authorization header, which combines the client ID and client secret. The request also includes the authorization code, grant type, and redirect URI. After executing this request, I receive both the access token and refresh token.
Handling Token Refreshing
Access tokens have a limited lifespan, which means I need to handle refreshing them. If the access token expires, I use the refresh token to generate a new access token. This involves creating a request to the token endpoint, specifying the refresh token and client ID.
To manage errors, I implemented a track that checks for unauthorized responses. If I receive a 401 error, the automation automatically triggers the refresh token flow.
Option 3: Using n8n
For those looking for a more straightforward approach, I recommend using n8n. It offers seamless integration with X’s API and supports the PKCE variation of OAuth2 natively. This means you can set up your workflows much faster without the complexities of manual token management.
Creating a new workflow in n8n is simple. You start by adding a Twitter module, where you can easily connect your X account by pasting your client ID and client secret.
Setting Up n8n Workflows
Here’s how to set up a basic workflow in n8n:
- Create a new workflow and add a Webhook trigger.
- Connect a Twitter module to create a tweet.
- Authorize your account by clicking on the connect button.
- Use the generated credentials to set up the module.
This workflow allows you to post tweets directly, making it efficient and user-friendly. The integration supports various operations like retweeting, deleting tweets, and more, all accessible through the native module.
Integrating Make.com with n8n
If you already have Make.com scenarios, you can trigger n8n workflows using HTTP requests. This gives you the flexibility to handle more complex operations while still utilizing the strengths of both platforms.
For instance, you can set up an HTTP module in Make.com to call your n8n webhook. This allows you to pass data seamlessly between the two systems, enabling a robust automation process.
This combination of tools provides a comprehensive solution for managing your X scenarios efficiently. Whether you choose to work directly with the API or leverage n8n’s capabilities, you can maintain your social media presence without disruption.
