Twitter allows automated accounts to be created from Settings, but there is no reliable way to identify these automated accounts with the API.

So, I suggest that it would be best if a flag could be added to the User object to indicate whether a user is automated or not, and if the object could be configured with information about the user who has set up automation.

v2 API to access/update user Profile data.

Granulating oAuth access permissions like below

• Read Permission [All / Individual]
  • Profile Picture
  • Profile Banner
  • Profile Info
• Write Permission [All / Individual]
  • Profile Picture
  • Profile Banner
  • Profile Info
• Notify Permission [All / Individual]
  • Profile Picture Change
  • Profile Banner Change
  • Profile Info Change

We see Profile Picture, Profile Banner, Profile Info are 'Top Social Accepts' of Twitter with more lasting time than 'statuses' or 'tweets'

This empowers Twitter users, Twitter Developers and Data/Trend analysts in creating innovative Apps/Services around Twitter.

The context_annotations field in tweets has extreme potential for us developers and researchers to understand the interests of a user, build communities, improve recommendation algorithms, etc, etc.
As far as I understand, an entity has a unique id and can belong to one or many domains (please correct me if I'm wrong). I think an endpoint to get information about a specific entity would be very useful.

Eg: GET /2/context_annotations/entity/:id would return a JSON with the fields:

{
    "id": "XXXX", 
    "name": "XXXX", 
    "description": "XXXX", 
    "domains": [
         {
             "id": "XXXX",
             "name": "XXXX", 
             "description": "XXXX"
         }
    ] 
}

Could be future proof for things like associated_users or something like that. Thought about receiving some opinions and feedback before opening a formal request (as per the indications in README).

Hi there.
Short: Asking for twitter OAuth2 api to provide a log-in/authentication scope only.

Long: Twitter is an awesome network of people (and other entities). I'm trying to build a cool new service providing special functionalities only to twitter users. And to do that, I tried to rely on Twitter's OAuth2 APIs to authenticate the twitter users using the new proposed service. For now, my service doesn't require any privileges from the twitter authenticated user other than to just recognize the twitter user in my system. I tried looking for a minimal login only scope for authentication but couldn't find any. The closest that I found for this was the users.read or offline.access. These are minimal, but the consent notification presented to the twitter users is still somewhat cryptic and probably discourage users from continuing with the authentication flow.
For example:
'offline.access' msg: "Stay connected to your account until you revoke access."
'users.read' msg: "Any account you can view, including protected accounts."

Google and Github as examples provide identity scope only authentication model. Can twitter API provide similar functionality?

Thanks

Hey everyone,
This topic has been discussed on numerous occasions with regards to v2.0 but there hasn't been much progress on it, making it a major block for many to switch from v1.1 to v2. So I would really like to get a discussion going here, to get some input from you before submitting a proposal.

The core of the issue, is that result-set returned by the endpoint GET /2/users is missing the latest tweet information which was available in v1.1.
My understanding is that v2.0 does this for performance reason (and perhaps to save on the payload size ), however consumers of the API who need this information would actually need to make O(n+1) calls contrasted with O(1) using v1.1.
For example, if you wanted to display 100 users, in the past, you make 1 call to v1.1 and display the info.
In v2, you would have to use GET /2/users then make 100 calls to GET 2/users/:id/tweets (with max_results=5 to avoid fetching unnecessary tweets), so you end up with 101 calls, and 500 tweets.
In other words, the performance impact on v2 would be much larger to get the same data, not only you make more calls, but 80% of the fetched tweets would be discarded.

Why is the latest tweet important? A lot of data is available in the latest tweet that cannot be obtained from the profile, for example the language, the date user last tweeted, the text of their latest tweet, all of which are very important to many Twitter apps.

I believe some middle ground can be reached if we keep in mind that optimizations was the objective of removing the Tweet object, while at the same time offer a solution that wouldn't require API consumers to bombard the API with O(n+1) requests.

My initial thought would be to add an additional field (latest_tweet_id) to user.fields (similar to pinned_tweet_id) to have this field returned in the result set. Having latest_tweet_id part of expansions would be great and makes this an O(1) operation.
But if that causes a performance concerns, API consumers can live with just having the id and then make a second call to tweets lookup GET /2/tweets (https://developer.twitter.com/en/docs/twitter-api/tweets/lookup/api-reference/get-tweets) making the cost of this process O(2) calls which is much better than O(n+1), and should have negligible impact on payload size.
Additional restrictions can be added to restrict who can use latest_tweet_id, e.g. only users with elevated access etc.

Would love to hear if anyone else here has other ideas
Thanks

Created based on https://twittercommunity.com/t/how-to-get-tags-of-a-media-in-a-tweet/185614/3

Sometimes Twitter users don't feature handles in the text, but rather tag the attached media with handles. There wasn't a way to access those handles via API with v1.1, and unfortunately it seems there isn't a way still with v2. This is very important relational information which can help many use-cases.

Example: college athletes prospects traditionally announce their commitment to a college via Twitter. The announcements are often cryptic and only contain terse text such as "1000% committed" and similar. It's a great helping hand when they bother tagging the handle of the college program or college football team on the attached media. This helps identifying which college program they were committed to.

• https://twitter.com/WonderKid__/status/1623095593366085634
• https://twitter.com/justinwood_/status/1626275168157851650

It'd be even better if the AI based entity extraction was more accessible / better, but I don't ask for that. Just for exposing this relation data of the tagging.

Hi amazing developers,

Twitter API v2.0 seems to have no way of knowing that a particular tweet has been liked or retweeted by an authenticated user.

Due to the unavailability of this flag, the following UI expressions cannot be used in third-party apps when just using Twitter API v2.0.

Hi,

I am an academic researcher and there is so much ongoing research about analyzing networks of connected users. I created my Twitter developer account to get follower lists of a set of social media influencers but it seems that my data-gathering exercise will take a few months because of rate limits. I have a list of 2000 influencers and each one has millions of followers.

Seems like getting tweets have much higher rate limits and that would be lots of data. Getting follower ids (to analyze overlap between follower sets) seems like a much shorter request in terms of MBs of data but the rate limits are more strict for this.

Would it be an acceptable request to ask for higher rate limits for downloading followers' data?

Thanks so much for reading.

Best Regards

Hi, sorry, I missed the "please create an issue" line.

I've made a PR suggesting implementing a multi delete endpoing similar to GET /2/tweets/ but for DELETE, with the other option being easing the rate limit on DELETE /2/tweets/:id so that people can quickly delete large swathes of their timeline as they currently can(50requests /15m is rather low given it was previously an unlimited call).

Happy to discuss it here if folk would prefer.

This one is maybe hard to change but I face difficulties because we currently have this kind of data when calling an endpoint returning a list of tweet and asking for user information :

  {
  data:[
        {
           // tweet 1
        },
        {
           // tweet 2
        }
     ],
  includes:{
        users:[
           {
              // user 1
           },
           {
              // user 2
           }
        ]
  }

As the user information is outside of the Tweet object, the mapping is not easy to do when deserializing it.

Better result would be something like :

{
  data:[
  {
    // tweet 1
    // user 1
  },
  {
    // tweet 2
    // user 2
  }
}

Am I alone to face that ?

Related feedback

Hi amazing developers,

Is there a way to programmatically get rate limits for Twitter API v2.0 endpoints?

If not, I feel that it would be more convenient for developers to be able to programmatically retrieve metadata such as usage and rate limits for each endpoint.

Thank you!

Context

Twitter API version : v2

Endpoint : GET /2/dm_events

Library : Tweepy library

I want to retrieve the tweets from direct messages sent by participants.
Below my code :

tweepy.Paginator(
    client.get_direct_message_events,
    max_results=100,
    limit=3,
    expansions=[
        "sender_id", "referenced_tweets.id", "participant_ids"
    ],
    user_fields=[
        "id", "username", "name"
    ],
    dm_event_fields=[
        "id", "created_at", "dm_conversation_id", "attachments",
        "participant_ids", "sender_id", "referenced_tweets"
    ],
    tweet_fields=[
        "id", "author_id", "created_at", "entities"
    ]
)

The issue

I specify that the following issue is not present on Twitter API v1 (I checked).

When a participant sends a tweet link, it can be shows in two ways :

1. The link is displayed and shows a preview (if not sensitve) and this is included as referenced tweet :

{
    "dm_conversation_id": "123456789-987654321",
    "created_at": "2022-12-11T00:05:23.000Z",
    "referenced_tweets": [
        {
            "id": "160003..."
        }
    ],
    "sender_id": "123456789",
    "text": "(...) https://t.co/dl... (...)",
    "id": "160172982...",
    "event_type": "MessageCreate"
}

2. Sometimes the link is displayed twice and no tweet is found whereas a tweet URL is present:

{
    "created_at": "2022-12-11T00:12:18.000Z",
    "id": "123456789",
    "text": "(...) https://t.co/Cq... https://t.co/7z... (...)",
    "sender_id": "133712...",
    "event_type": "MessageCreate",
    "dm_conversation_id": "123456789-987654321"
}

The aim of this proposal is to have more of a one-to-one correspondence between the Twitter Topics and the entities of context domain 131 Unified Twitter Taxonomy.

As of now, the Twitter Topics feature is powered using the Unified Twitter Taxonomy context domain. However some Topics (e.g. "Viral Tweets") do not figure among the entities of that domain in the API, even though they have an id that identifies the Topic page URL (https://twitter.com/i/topics/1284234742661963776).

Is it possible to synchronize both?

Hi,

As title said, can we have profile_banner_url return in API v2 users lookup?

I saw many people asking for it too. See: https://twittercommunity.com/t/profile-banner-url/155807

It is really painful that when I use the user lookup endpoint, I can't know if the user is following me or not.
What do you think about adding two new fields in the API response, i.e :

{
"followed": false,
"following": true
}

Related Feedback

Please bring the search operators min_replies, min_retweets, and min_faves to the new V2 API so that you can filter out tweets from the result that do not have any engagements.

In our use case, it will significantly bring down the number of requests required for the same result.

Currently, the max_results parameter cannot be smaller than 10. Sometimes it would be convenient to specify a smaller value, even max_results=1.

Add a checklist to ensure that PRs conform to the process and principles.

On the Twitter forums last year, I asked if there would be functionality added to API v2 that could provide the tier of the calling application.

As a developer of a product that uses the Twitter API,
I would like the application to be able to retrieve the tier/version and permissions configured for it,
so that I could use the appropriate endpoints, parameters, and search operators.

For example, a command using a search endpoint should use the endpoint and parameter validation rules for that endpoint for each search offering.

Standard v1.1
Premium v1.1
Enterprise

Additionally, it would be desirable to discover the permissions granted, whether OAuth 1.0a based (Read, Read/Write, Read/Write/Direct Messages) or OAuth 2.0 w/PKCE based (for scopes). I know that x-access-level is included in the headers (at least for OAuth 1.0a calls) but I don't know if something similar is available for scopes.

If an application using OAuth 2.0 w/PKCE allows a user to select which scopes, knowing the allowed scopes would allow the developer to restrict commands which would knowingly fail, such as trying to create a Tweet when the user only consented to tweet.read and users.read scopes. Likewise, if an application using OAuth 1.0 would require Read/Write, it would be better to prevent the user from performing any call API calls that would create, update, or delete a resource.

Thank you,
thedavecarroll
Primary developer for BluebirdPS.

OAuth 2.0 does not provide email information, so you must use OAuth 1.0 a when implementing "Log in using Twitter."

This is something I've seen many times on Twitter Community asking for.
This is a major barrier to adopting OAuth 2.0.