​

Introduction

​

Retweets lookup

With the Retweets lookup endpoint, you can retrieve a list of accounts that have Retweeted a Post. For this endpoint, pagination tokens will be provided for paging through large sets of results in batches of up to 100 users. 

You can authenticate these endpoints with either OAuth 1.0a User Context, [OAuth 2.0 App-Only](https://developer.twitter.com(/resources/fundamentals/authentication#app-only-authentication-and-oauth-2-0-bearer-token), or OAuth 2.0 Authorization Code with PKCE. 

​

Retweets of Me

The Reposts of Me lookup allows you to see which of your own Posts have been shared by others.

This provides users with insight into which of their Posts are being shared and resonating with their audience, which can help facilitate more targeted interactions and content strategy adjustments.

You can authenticate these endpoints with either either OAuth 1.0a User Context or OAuth 2.0 Authorization Code with PKCE.

​

Manage Retweets

The manage Retweets endpoints enable you to Retweet or undo a Retweet of a specified Post on behalf of an authenticated account. For this endpoint group, there are two methods available POST and DELETE. The POST method allows you to Retweet a Post, and the DELETE method will enable you to undo a Retweet of a given Post.

Since you are making requests on behalf of a user, you must authenticate these endpoints with either OAuth 1.0a User Context or OAuth 2.0 Authorization Code with PKCE, and utilize the user Access Tokens associated with the user you are making the request on behalf of. You can generate this user Access Token using the 3-legged OAuth flow (OAuth 1.0a) or using the Authorization Code with PKCE grant flow) (OAuth 2.0). You can Retweet a Post from your account or an account of an authenticated user. With both endpoints, there is a user rate limit of 50 requests per 15 minutes per endpoint.

​

Quick start

​

Getting started with the Retweets lookup endpoint

This quick start guide will help you make your first request to the Retweets lookup endpoint using Postman. If you would like to see sample code in different languages, please visit our X API v2 sample code GitHub repository.

​

Prerequisites

To complete this guide, you will need to have a set of keys and tokens to authenticate your request. You can generate these keys and tokens by following these steps:

• Sign up for a developer account and receive approval.
• Create a Project and an associated developer App in the developer portal.
• Navigate to your App’s “Keys and tokens” page to generate the required credentials. Make sure to save all credentials in a secure location.

​

Steps to build a Retweets lookup request

Step one: Start with a tool or library

There are several different tools, code examples, and libraries that you can use to make a request to this endpoint, but we will use the Postman tool here to simplify the process.

To load the X API v2 Postman collection into your environment, please click on the following button:

Once you have the X API v2 collection loaded in Postman, navigate to the “Retweets” folder and select “Retweeted by.” 

Step two: Authenticate your request

To properly make a request to the X API, you need to verify that you have permission. To do so, this endpoint requires you to authenticate your request with either OAuth 2.0 App-Only, OAuth 2.0 Authorization Code with PKCE, or OAuth 1.0a User Context authentication methods.

For simplicity’s sake, we will utilize OAuth 2.0 App-Only with this request, but you will need to use one of the other authentication methods if you’d like to request private metrics or Retweets. 

To utilize OAuth 2.0 App-Only, you must add your keys and tokens, specifically theApp Access Token (also known as the App-only Bearer Token) to Postman. You can do this by selecting the environment named “X API v2” in the top-right corner of Postman and adding your keys and tokens to the “initial value” and “current value” fields (by clicking the eye icon next to the environment dropdown).

These variables will automatically be pulled into the request’s authorization tab if you’ve done this correctly.  

Step three: Specify a Post

With this endpoint, you must specify the Post ID that you want to get Retweeting users of.  You can find the ID of a Post by navigating to that Post on X and pulling the numerical code at the end of the URL. For example, the following URL’s Post ID is 1354143047324299264.

https://twitter.com/TwitterDev/status/1354143047324299264

In Postman, navigate to the “Params” tab and enter this username into the “Value” column of the id path variable (at the bottom of the section), making sure to not include any spaces before or after usernames. 

Step four: Identify and specify which fields you would like to retrieve

If you click the “Send” button after step three, you will receive the default user object fields in your response: id, name, and username.

If you would like to receive additional fields beyond id, name, and username, you will have to specify those fields in your request with the fields and/or expansions parameters.

For this exercise, we will request three additional sets of fields from different objects:

1. The additional user.created_at field in the primary user objects.
2. The associated pinned Posts’ object’s default fields for the returned users: id and text.
3. The additional  tweet.created_at field in the associated Post objects.

In Postman, navigate to the “Params” tab and add the following key:value pair to the “Query Params” table:

You should now see the following URL next to the “Send” button:

https://api.x.com/2/tweets/1354143047324299264/retweeted_by?user.fields=created_at&expansions=pinned_tweet_id&tweet.fields=created_at

Step five: Make your request and review your response

Once you have everything set up, hit the “Send” button and you will receive a similar response to the following example response:

{
  "data": [
    {
      "created_at": "2008-12-04T18:51:57.000Z",
      "id": "17874544",
      "username": "TwitterSupport",
      "name": "Twitter Support"
    },
    {
      "created_at": "2007-02-20T14:35:54.000Z",
      "id": "783214",
      "username": "Twitter",
      "name": "Twitter"
    },
    {
      "pinned_tweet_id": "1389270063807598594",
      "created_at": "2018-11-21T14:24:58.000Z",
      "id": "1065249714214457345",
      "username": "TwitterSpaces",
      "name": "Spaces"
    },
    {
      "pinned_tweet_id": "1293595870563381249",
      "created_at": "2007-05-23T06:01:13.000Z",
      "id": "6253282",
      "username": "TwitterAPI",
      "name": "Twitter API"
    }
  ],
  "includes": {
    "tweets": [
      {
        "created_at": "2021-05-03T17:26:09.000Z",
        "id": "1389270063807598594",
        "text": "now, everyone with 600 or more followers can host a Space.\n\nbased on what we've learned, these accounts are likely to have a good experience hosting because of their existing audience. before bringing the ability to create a Space to everyone, we’re focused on a few things. 🧵"
      },
      {
        "created_at": "2020-08-12T17:11:04.000Z",
        "id": "1293595870563381249",
        "text": "Twitter API v2: Early Access released\n\nToday we announced Early Access to the first endpoints of the new Twitter API!\n\n#TwitterAPI #EarlyAccess #VersionBump https://t.co/g7v3aeIbtQ"
      }
    ]
  }
}

​

Getting started with the manage Retweets endpoints

This quick start guide will help you make your first request to the manage Retweets endpoints using Postman.

If you would like to see sample code in different languages, please visit our X API v2 sample code GitHub repository. 

​

Prerequisites

To complete this guide, you will need to have a set of keys and tokens to authenticate your request. You can generate these keys and tokens by following these steps:

• Sign up for a developer account and receive approval.
• Create a Project and an associated developer App in the developer portal.
• Navigate to your App’s “Keys and tokens” page to generate the required credentials. Make sure to save all credentials in a secure location.

​

Steps to build a manage Retweets request

Step one: Start with a tool or library

There are several different tools, code examples, and libraries that you can use to make a request to this endpoint, but we are going to use the Postman tool here to simplify the process.

To load the X API v2 Postman collection into your environment, please click on the following button:

Once you have the X API v2 collection loaded in Postman, navigate to the “Retweets” folder, and select “Retweet a Post”.  

Step two: Authenticate your request

To properly make a request to the X API, you need to verify that you have permission. To do so with this endpoint, you must authenticate your request using either OAuth 1.0a User Context or OAuth 2.0 Authorization Code with PKCE.

In this example, we are going to use OAuth 1.0a User Context.

You must add your keys and tokens – specifically your API Key, API Secret Key, OAuth 1.0a user Access Token, and OAuth 1.0a user Access Token Secret – to Postman. You can do this by selecting the environment named “X API v2” in the top-right corner of Postman and adding your keys and tokens to the “initial value” and “current value” fields (by clicking the eye icon next to the environment dropdown).

These variables will automatically be pulled into the request’s authorization tab if you’ve done this correctly.

Step three: Specify which Post you are going to Retweet

Manage Retweets endpoints require two IDs: one for the user who wishes to Retweet or undo a Retweet and the id of the Post.

The user’s ID must correspond to the authenticating user’s ID, meaning that you must pass the Access Tokens associated with the user ID when authenticating your request.  In this case, you can specify the ID belonging to your own user. You can find your ID in two ways:

1. Using the user lookup by username endpoint, you can pass a username and receive the id field. 
2. Looking at your Access Token, you will find that the numeric part is your user ID.  

You also must specify a Post that you want to Retweet. You can find the Post ID by navigating to X.com and clicking on a Post and then looking in the URL. For example, the following URL’s Post ID is 1228393702244134912.

https://twitter.com/TwitterDev/status/1228393702244134912

In Postman, navigate to the “Params” tab, and enter your ID into the “Value” column of the id path variable. and enter the ID of the Post you wish to Retweet as the value for thetweet_id parameter. Be sure not to include any spaces before or after any ID.

If you click the “Send” button, you will receive a response object containing the status of the relationship:

• If you receive a “retweeted”: true, then the id is successfully Retweeting the tweet_id.  

Step four: Make your request and review your response

Once you have everything set up, hit the “Send” button and you will receive the following response:

{
    "data": {
        "retweeted": true
    }
}

If you receive a "retweeted": true has successfully Retweeted the tweet_id

If you wish to undo a Retweet by the same user you can use the request entitled “Undo a Retweet”, which is also found in the “Retweets” folder of the X API v2 collection loaded in Postman. The id should be your user ID and source_tweet_id should be the Post ID to undo the Retweet of. You will not have to add this as a JSON body so you will want to make sure that you add in the requisite query params for id and source_tweet_id. 

On a successful undoing of a Retweet, you will receive a similar response to the following example:

{
  "data": {
    "retweeted": false
  }
}

​

Retweets of Me

The Reposts of Me lookup allows you to see which of your own Posts have been shared by others.

This provides users with insight into which of their Posts are being shared and resonating with their audience, which can help facilitate more targeted interactions and content strategy adjustments.

​

Authentication

Since you are making requests on behalf of a user, you must authenticate these endpoints with either OAuth 1.0a User Context or OAuth 2.0 Authorization Code with PKCE, and utilize the user Access Tokens associated with the user you are making the request on behalf of. You can generate this user Access Token using the 3-legged OAuth flow (OAuth 1.0a) or using the Authorization Code with PKCE grant flow (OAuth 2.0).

​

Making a request

Once a user has authenticated with your app, you can call the Retweets of Me API on behalf of user as shown below:

curl 'https://api.x.com/2/users/reposts_of_me' --header 'Authorization: ••••••'

If the request is successful, you should see the JSON response as shown below:

{
   "data": [
       {
           "text": "ever wanted to discover trends.. before they’re trends?\n\nsign up to Premium+ to access Radar\n\nhttps://t.co/7a3JzBb855 https://t.co/rwNogVs0Wi",
           "edit_history_tweet_ids": [
               "1848781937210802364"
           ],
           "id": "1848781937210802364"
       },
       {
           "text": "want to be mysterious so bad but also love oversharing on x dot com",
           "edit_history_tweet_ids": [
               "1847990559081648620"
           ],
           "id": "1847990559081648620"
       },
       {
           "text": "post",
           "edit_history_tweet_ids": [
               "1847990269125226937"
           ],
           "id": "1847990269125226937"
       },
       {
           "text": "posting is just journaling with an audience",
           "edit_history_tweet_ids": [
               "1847429017932026009"
           ],
           "id": "1847429017932026009"
       },
   ],
   "meta": {
       "result_count": 4,
       "next_token": "7140dibdnow9c7btw481s8m561gat797rboud5r80xvzm"
   }
}

​

Integration guide

This page contains information on several tools and key concepts that you should be aware of as you integrate the Retweet endpoints into your system. We’ve broken the page into a couple of different sections:

• Helpful tools
• Key Concepts
• Authentication
• Developer portal, Projects, and Apps
• Rate limits
• Fields and expansions

​

Helpful tools

Before we dive into some key concepts that will help you integrate this endpoint, we recommend that you become familiar with:

​

Postman

Postman is a great tool that you can use to test out an endpoint. Each Postman request includes every path and body parameter to help you quickly understand what is available to you. To learn more about our Postman collections, please visit our “Using Postman” page. 

​

Code samples

Interested in getting set up with this endpoint with some code in your preferred coding language? We’ve got a handful of different code samples available that you can use as a starting point on our Github page.

​

Third-party libraries

Take advantage of one of our communities’ third-party libraries to help you get started. You can find a library that works with the v2 endpoints by looking for the proper version tag.  

​

Key concepts

​

Authentication

All X API v2 endpoints require for you to authenticate your requests with a set of credentials, also known as keys and tokens.

You can use either OAuth 1.0a User Context or OAuth 2.0 Bearer Token to authenticate your requests to the Retweets lookup endpoint. 

The manage Retweets endpoints require the use of OAuth 1.0a User Context, which means that you must use a set of API keys and user access tokens to make a successful request. The access tokens must be associated with the user that you are making the request on behalf of. If you would like to generate a set of access tokens for another user, they must authorize or authenticate your App using the 3-legged OAuth flow.

Please note that OAuth 1.0a can be tricky to use. If you are not familiar with this authentication method, we recommend that you use a library to properly authenticate your requests.

Please note

If you are requesting the following fields, OAuth 1.0a User Context is required: 

• tweet.fields.non_public_metrics
• tweet.fields.promoted_metrics
• tweet.fields.organic_metrics
• media.fields.non_public_metrics
• media.fields.promoted_metrics
• media.fields.organic_metrics

​

Developer portal, Projects, and developer Apps

To retrieve a set of authentication credentials that will work with the X API v2 endpoints, you must sign up for a developer account, set up a Project within that account, and created a developer App within that Project. You can then find your keys and tokens within your developer App.   

​

Rate limits

Every day, many thousands of developers make requests to the X API. To help manage the sheer volume of these requests, rate limits are placed on each endpoint that limits the number of requests that you can make on behalf of your app or on behalf of an authenticated user.

The manage Retweets endpoints are limited to 50 requests per 15 min (per user). Additionally, for the POST endpoint, you are limited to 300 requests per 3-hour window (per user, per app). 

With the Retweets lookup endpoint, you are limited to 75 requests per 15-min window. Additionally, only the 100 most recent Retweeting users will be returned by this endpoint.

​

Fields and expansions

The X API v2 allows users to select exactly which data they want to return from the API using a set of tools called fields and expansions. The expansion parameter allows you to expand objects referenced in the payload. For example, this endpoint allows you to pull the following expansions:

• attachments.poll_ids
• attachments.media_keys
• author_id, entities.mentions.username
• geo.place_id
• in_reply_to_user_id,
• referenced_tweets.id,
• referenced_tweets.id.author_id

The fields parameter allows you to select exactly which fields within the different data objects you would like to receive. These endpoints delivers Post objects primarily. By default, the Post object returns the id and text fields. To receive additional fields such as tweet.created_at or tweet.entities, you will have to specifically request those using a fields parameter. Some important fields that you may want to consider using in your integration are our poll data, metrics, Post annotations, and conversation ID fields.

We’ve added a guide on how to use fields and expansions together to our X API v2 data dictionary.

​

Comparing X API’s Retweets endpoints

Retweets lookup

The v2 Retweets lookup endpoint will replace the standard v1.1 GET statuses/retweets/:id and v1.1 GET statuses/retweets/:ids endpoints.

The following tables compare the standard v1.1 and X API v2 Retweets endpoints:

​

Manage Retweets

The following tables compare the standard v1.1 and X API v2 undo Retweet endpoint:

Retweet a Post

​

Undo a Retweet

The following tables compare the standard v1.1 and X API v2 undo Retweet endpoint:

Other migration resources

Retweets lookup: Standard v1.1 to X API v2

Manage Retweets: Standard v1.1 to X API v2

X API migration hub

Retweets

​

Retweets lookup: Standard v1.1 compared to X API v2

If you have been working with the standard v1.1 v1.1 GET statuses/retweets/:id, v1.1 GET statuses/retweets/:ids, the goal of this guide is to help you understand the similarities and differences between the standard v1.1 and X API v2 Retweets lookup endpoints.

• Similarities
  • Authentiation
  • Users per request limits
• Differences

  • Endpoint URLs

  • Request limitations

  • App and Project requirements

  • Response data format

  • Request parameters

​

Similarities

Authentication

Both the standard v1.1 and X API v2 Retweets lookup endpoints (v1.1 GET statuses/retweets/:id and v1.1 GET statuses/retweeters/:ids) use OAuth 1.0a User Context or OAuth 2.0 Bearer Token.

Users per request limits

For both v1.1 and v2 GET endpoints the max number of users that will be returned by the Retweets lookup endpoint is 100 users. For the v2 Retweets lookup endpoint, there is no pagination token being passed, by default we give out 100 users and that’s the max that is returned.

​

Differences

Endpoint URLs

• Standard v1.1 endpoints:
  • https://api.x.com/1.1/statuses/retweets/:id.json (Returns a collection of the 100 most recent Retweets of the Post specified by the id parameter)
  • https://api.x.com/1.1/statuses/retweeters/ids.json (Returns a collection of up to 100 user IDs belonging to users who have Retweeted the Post specified by the id parameter)
• X API v2 endpoint:
  • https://api.x.com/2/tweets/:id/retweeted_by (Returns a list of accounts who have Retweeted a given Post)

App and Project requirements

The X API v2 endpoints require that you use credentials from a developer App that is associated with a Project when authenticating your requests. All X API v1.1 endpoints can use credentials from standalone Apps or Apps associated with a project.

Response data format

One of the biggest differences between standard v1.1 and X API v2 endpoint versions is how you select which fields return in your payload.

For the standard endpoints, you receive many of the response fields by default, and then have the option to use parameters to identify which fields or sets of fields should return in the payload.

The X API v2 version only delivers the user id , name, and username fields by default. To request any additional fields or objects, you wil need to use the fields and expansions parameters. Any user fields that you request from this endpoint will return in the primary user object. Any expanded Post object and fields will return in an includes object within your response. You can then match any expanded objects back to the user object by matching the IDs located in both the user and the expanded Post object. 

We encourage you to read more about these new parameters in their respective guides, or by reading our guide on how to use fields and expansions. 

We have also put together a data format migration guide which can help you map standard v1.1 fields to the newer v2 fields. This guide will also provide you the specific expansion and field parameter that you will need to pass with your v2 request to return specific fields.   

In addition to the changes in how you request certain fields, X API v2 is also introducing new JSON designs for the objects returned by the APIs, including Post and user objects.

• At the JSON root level, the standard endpoints return Post objects in a statuses array, while X API v2 returns a data array. 
• Instead of referring to Retweeted and Quoted “statuses”, X API v2 JSON refers to Retweeted and Quoted Tweets. Many legacy and deprecated fields, such as contributors and user.translator_type are being removed. 
• Instead of using both favorites (in Post object) and favourites (in user object), X API v2 uses the term like. 
• X is adopting the convention that JSON values with no value (for example, null) are not written to the payload. Post and user attributes are only included if they have a non-null values.   

We also introduced a new set of fields to the Post object including the following:

• A conversation_id field
• Two new annotations fields, including context and entities
• Several new metrics fields 
• A new reply_setting field, which shows you who can reply to a given Post

Request parameters

The following standard v1.1 request parameters accepted two request query parameters (user_id or screen_name). The X API v2 only accepts the numerical user ID, and it must be passed as part of the endpoint path.

​

Manage Retweets: Standard v1.1 compared to X API v2

If you have been working with the standard v1.1 POST statuses/retweet/:id, and POST statuses/unretweet/:id  endpoints, the goal of this guide is to help you understand the similarities and differences between the standard and X API v2 Retweets endpoints.

• Similarities
  • Authentication
• Differences
  • Endpoint URLs and HTTP methods
  • Request limitations
  • App and Project requirements
  • Request parameters

​

Similarities

Authentication

Both the standard v1.1 and X API v2 manage Retweets (POST statuses/retweet/:id, and POST statuses/unretweet/:id) endpoints use OAuth 1.0a User Context. Therefore, if you were previously using one of the standard v1.1 Retweets lookup endpoints, you can continue using the same authentication method if you migrate to the X API v2 version. 

​

Differences

Endpoint URLs and HTTP methods

• Standard v1.1 endpoints:
  • https://api.x.com/1.1/statuses/retweet/:id.json (Retweets a Post. Returns the original Post with Retweet details embedded)
  • https://api.x.com/1.1/statuses/unretweet/:id.json (Undo a Retweet. Returns the original Post with Retweet details embedded)
• X API v2 endpoint:
  • https://api.x.com/2/tweets/:id/retweets (Retweets a given Post)
  • https://api.x.com/2/users/:id/retweets/:source\_tweet\_id (Undo a Retweet of a given Post) 

App and Project requirements

The X API v2 endpoints require that you use credentials from a developer App that is associated to a Project when authenticating your requests. All X API v1.1 endpoints can use credentials from standalone Apps or Apps associated with a Project.

Request parameters

The following standard v1.1 request parameters accepted two request query parameters (user_id or screen_name). The X API v2 only accepts the numerical user ID, and it must be passed as part of the endpoint path.

Please note that the Standard v1.1 parameters are passed as query parameters, whereas the X API v2 parameters are passed as body parameters for the POST endpoint or path parameters for the DELETE endpoint.

Also, an id of the user Retweeting a Post is not required when using the standard v1.1 endpoints since the Access Tokens passed with OAuth 1.0a User Context infer which user is initiating the Retweet/undoing a Retweet. 

​

API reference index

For the complete API reference, select an endpoint from the list:  

​

Retweets lookup

​

Manage Retweets

​

GET /2/tweets/:id/retweeted_by

Allows you to get information about who has Retweeted a Tweet.

​

Endpoint URL

https://api.x.com/2/tweets/:id/retweeted_by

​

Authentication and rate limits

​

OAuth 2.0 scopes required by this endpoint

​

Path parameters

​

Query parameters

​

Example code with offical SDKs

• TypeScript (Default fields)
• TypeScript (Optional fields)
• Java (Default fields)
• Java (Optional fields)

(async () => {
  try {
    const getRetweetingUsers =
      await twitterClient.users.tweetsIdRetweetingUsers(
        //The ID of the Tweet for which to return results
        "1354143047324299264"
      );
    console.dir(getRetweetingUsers, {
      depth: null,
    });
  } catch (error) {
    console.log(error);
  }
})();

​

Example responses

• Default fields
• Optional fields

{
  "data": [
    {
      "id": "1065249714214457345",
      "name": "Spaces",
      "username": "TwitterSpaces"
    },
    {
      "id": "783214",
      "name": "Twitter",
      "username": "Twitter"
    },
    {
      "id": "1526228120",
      "name": "Twitter Data",
      "username": "TwitterData"
    }
  ],
  "meta": {
    "result_count": 3
  }
}

​

Response fields

​

POST /2/users/:id/retweets

Causes the user ID identified in the path parameter to Retweet the target Tweet.

​

Endpoint URL

https://api.x.com/2/users/:id/retweets

​

Authentication and rate limits

​

OAuth 2.0 scopes required by this endpoint

​

Path parameters

​

JSON body parameters

​

Example code with offical SDKs

• TypeScript
• Java

(async () => {
  try {
    const createRetweet = await twitterClient.tweets.usersIdRetweets(
      //The ID of the user that is requesting to retweet the tweet
      "2244994945",
      {
        //The ID of the tweet the user is requesting to retweet
        tweet_id: "1228393702244134912",
      }
    );
    console.dir(createRetweet, {
      depth: null,
    });
  } catch (error) {
    console.log(error);
  }
})();

​

Example responses

• Successful response

{
  "data": {
    "retweeted": true
  }
}

​

Response fields

​

DELETE /2/users/:id/retweets/:source_tweet_id

Allows a user or authenticated user ID to remove the Retweet of a Tweet.

The request succeeds with no action when the user sends a request to a user they’re not Retweeting the Tweet or have already removed the Retweet of.

Run in Postman ❯

Try a live request ❯

Build request with API Explorer ❯

​

Endpoint URL

https://api.x.com/2/users/:id/retweets/:source_tweet_id

​

Authentication and rate limits

​

OAuth 2.0 scopes required by this endpoint

​

Path parameters

​

Example code with offical SDKs

• TypeScript
• Java

(async () => {
  try {
    const deleteRetweet = await twitterClient.tweets.usersIdUnretweets(
      //The ID of the user that is requesting to unretweet the tweet
      "2244994945",

      //The ID of the tweet that the user is requesting to unretweet
      "1228393702244134912"
    );
    console.dir(deleteRetweet, {
      depth: null,
    });
  } catch (error) {
    console.log(error);
  }
})();

​

Example responses

• Successful response

{
  "data": {
    "retweeted": false
  }
}

​

Response fields

​

GET /2/tweets/:id/retweets

Returns the Retweets for a given Tweet ID.

Run in Postman ❯

​

Endpoint URL

https://api.x.com/2/tweets/:id/retweets

​

Authentication and rate limits

​

OAuth 2.0 scopes required by this endpoint

​

Path parameters

​

Query parameters

​

Example code with offical SDKs

• TypeScript (Default fields)
• Java (Default fields)

(async () => {
  try {
    const lookupretweetsById = await twitterClient.tweets.findRetweetById(
      //The ID of the Tweet
      "1460323737035677698"
    );
    console.dir(lookupretweetsById, {
      depth: null,
    });
  } catch (error) {
    console.log(error);
  }
})();

​

Example responses

• Default fields
• Optional fields

{
  "data": [
    {
      "edit_history_tweet_ids": [
        "1706293551514931251"
      ],
      "id": "1706293551514931251",
      "text": "RT @XDevelopers: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new fea…"
    },
    {
      "edit_history_tweet_ids": [
        "1657506338052743169"
      ],
      "id": "1657506338052743169",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    },
    {
      "edit_history_tweet_ids": [
        "1641016683220418560"
      ],
      "id": "1641016683220418560",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    },
    {
      "edit_history_tweet_ids": [
        "1637003395897733120"
      ],
      "id": "1637003395897733120",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    },
    {
      "edit_history_tweet_ids": [
        "1614245925911683072"
      ],
      "id": "1614245925911683072",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    },
    {
      "edit_history_tweet_ids": [
        "1587709165937598465"
      ],
      "id": "1587709165937598465",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    },
    {
      "edit_history_tweet_ids": [
        "1578651764202799104"
      ],
      "id": "1578651764202799104",
      "text": "RT @TwitterDev: Introducing a new era for the Twitter Developer Platform! nn📣The Twitter API v2 is now the primary API and full of new feat…"
    }
  ],
  "meta": {
    "result_count": 7,
    "next_token": "7140dibdnow9c7btw423i3t92aywva1nbjjzcn5nqwd2s"
  }
}

​

Response fields