En raison du retrait de l'API Twitter 1.0 à partir du 11 juin 2013 , le script ci-dessous ne fonctionne plus.

// Create curl resource 
$ch = curl_init(); 
// Set url 
curl_setopt($ch, CURLOPT_URL, "http://twitter.com/statuses/user_timeline/myscreenname.json?count=10"); 
// Return the transfer as a string 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 
// $output contains the output string 
$output = curl_exec($ch); 
// Close curl resource to free up system resources 
curl_close($ch);

if ($output) 
{
    $tweets = json_decode($output,true);

    foreach ($tweets as $tweet)
    {
        print_r($tweet);
    }
}

Comment puis-je obtenir la user_timeline (statuts récents) avec le moins de code possible?

J'ai trouvé ceci: https://dev.twitter.com/docs/api/1.1/get/statuses/user_timeline mais j'obtiens l'erreur suivante:

"{"errors":[{"message":"Could not authenticate you","code":32}]}"

Il y a beaucoup de classes, mais après avoir essayé plusieurs, aucune ne semble fonctionner à cause de ces mises à jour sur Twitter, et certaines d'entre elles sont des classes assez avancées avec beaucoup de fonctionnalités dont je n'ai pas vraiment besoin.

Quel est le moyen le plus simple / le plus court pour obtenir les statuts utilisateur récents avec PHP?

Remarque importante: à la mi-2018, le processus d'obtention des jetons d'API Twitter est devenu beaucoup plus bureaucratique. Il m'a fallu plus d' une semaine de travail pour obtenir un ensemble de jetons d'API, et ceci pour un projet open source pour vous les gars et les filles avec plus de 1,2 million d'installations sur Packagist et 1,6 k étoiles sur Github, qui devrait théoriquement être une priorité plus élevée .

Si vous devez travailler avec l'API Twitter pour votre travail, vous devez tenir compte de ce temps d'attente potentiellement extrêmement long. Considérez également d'autres avenues de médias sociaux comme Facebook ou Instagram et fournissez ces options, car le processus de récupération de leurs jetons est instantané.

Vous souhaitez donc utiliser l'API Twitter v1.1?

Remarque: les fichiers pour ceux-ci sont sur GitHub .

La version 1.0 sera bientôt obsolète et les demandes non autorisées ne seront pas autorisées. Alors, voici un article pour vous aider à faire exactement cela, avec une classe PHP pour vous faciliter la vie.

1. Créez un compte développeur: créez- vous un compte développeur sur Twitter

Vous devez visiter le site officiel des développeurs Twitter et créer un compte développeur. Il s'agit d'une étape gratuite et nécessaire pour faire des demandes pour l'API v1.1.

2. Créer une application: créer une application sur le site des développeurs Twitter

Quoi? Vous pensiez pouvoir faire des demandes non authentifiées? Pas avec l'API v1.1 de Twitter. Vous devez visiter http://dev.twitter.com/apps et cliquer sur le bouton "Créer une application".

Sur cette page, remplissez les détails que vous souhaitez. Pour moi, cela n'avait pas d'importance, parce que je voulais juste faire une charge de demandes de blocage pour me débarrasser des adeptes du spam. Le fait est que vous allez vous procurer un ensemble de clés uniques à utiliser pour votre application.

Donc, le but de créer une application est de vous donner (et Twitter) un jeu de clés. Ceux-ci sont:

• La clé du consommateur
• Le secret du consommateur
• Le jeton d'accès
• Le secret du jeton d'accès

Il y a un peu d'informations ici sur la raison d'être de ces jetons.

3. Créez des jetons d'accès : vous en aurez besoin pour faire des demandes réussies

OAuth demande quelques jetons. Vous devez donc les générer pour vous.

Cliquez sur "créer mon jeton d'accès" en bas. Ensuite, une fois que vous faites défiler vers le bas à nouveau, vous aurez des clés nouvellement générées. Vous devez récupérer les quatre clés précédemment étiquetées de cette page pour vos appels API, alors notez-les quelque part.

4. Modifier le niveau d'accès : vous ne voulez pas en lecture seule, n'est-ce pas?

Si vous souhaitez utiliser décemment cette API, vous devrez modifier vos paramètres en lecture et écriture si vous faites autre chose que la récupération de données standard à l'aide de requêtes GET .

Choisissez l'onglet "Paramètres" en haut de la page.

Donnez à votre application un accès en lecture / écriture et appuyez sur "Mettre à jour" en bas.

Vous pouvez en savoir plus sur le modèle d'autorisation des applications que Twitter utilise ici.

5. Écrivez du code pour accéder à l'API : j'en ai fait la plupart pour vous

J'ai combiné le code ci-dessus, avec quelques modifications et changements, dans une classe PHP, il est donc très simple de faire les demandes dont vous avez besoin.

Cela utilise OAuth et l' API Twitter v1.1 , et la classe que j'ai créée que vous pouvez trouver ci-dessous.

require_once('TwitterAPIExchange.php');

/** Set access tokens here - see: https://dev.twitter.com/apps/ **/
$settings = array(
    'oauth_access_token' => "YOUR_OAUTH_ACCESS_TOKEN",
    'oauth_access_token_secret' => "YOUR_OAUTH_ACCESS_TOKEN_SECRET",
    'consumer_key' => "YOUR_CONSUMER_KEY",
    'consumer_secret' => "YOUR_CONSUMER_SECRET"
);

Assurez-vous de mettre les clés que vous avez obtenues de votre application ci-dessus dans leurs espaces respectifs.

Ensuite, vous devez choisir une URL à laquelle vous souhaitez faire une demande. Twitter a sa documentation API pour vous aider à choisir quelle URL et aussi le type de demande (POST ou GET).

/** URL for REST request, see: https://dev.twitter.com/docs/api/1.1/ **/
$url = 'https://api.twitter.com/1.1/blocks/create.json';
$requestMethod = 'POST';

Dans la documentation, chaque URL indique ce que vous pouvez lui transmettre. Si nous utilisons l'URL "blocs" comme celle ci-dessus, je peux passer les paramètres POST suivants:

/** POST fields required by the URL above. See relevant docs as above **/
$postfields = array(
    'screen_name' => 'usernameToBlock', 
    'skip_status' => '1'
);

Maintenant que vous avez configuré ce que vous voulez faire avec l'API, il est temps de faire la demande réelle.

/** Perform the request and echo the response **/
$twitter = new TwitterAPIExchange($settings);
echo $twitter->buildOauth($url, $requestMethod)
             ->setPostfields($postfields)
             ->performRequest();

Et pour une demande POST , c'est tout!

Pour une demande GET , c'est un peu différent. Voici un exemple:

/** Note: Set the GET field BEFORE calling buildOauth(); **/
$url = 'https://api.twitter.com/1.1/followers/ids.json';
$getfield = '?username=J7mbo';
$requestMethod = 'GET';
$twitter = new TwitterAPIExchange($settings);
echo $twitter->setGetfield($getfield)
             ->buildOauth($url, $requestMethod)
             ->performRequest();     

Exemple de code final : pour une simple demande GET pour une liste de mes followers.

$url = 'https://api.twitter.com/1.1/followers/list.json';
$getfield = '?username=J7mbo&skip_status=1';
$requestMethod = 'GET';
$twitter = new TwitterAPIExchange($settings);
echo $twitter->setGetfield($getfield)
             ->buildOauth($url, $requestMethod)
             ->performRequest();  

J'ai mis ces fichiers sur GitHub avec crédit à @ laquovic10 et @rivers! J'espère que quelqu'un le trouve utile; Je sais que je l'ai fait (je l'ai utilisé pour le blocage en bloc dans une boucle).

En outre, pour ceux sous Windows qui ont des problèmes avec les certificats SSL, consultez cet article . Cette bibliothèque utilise cURL sous le capot, vous devez donc vous assurer que vos certificats cURL sont probablement configurés. Google est aussi votre ami.

Accédez à dev.twitter.com et créez une application . Cela vous fournira les informations d'identification dont vous avez besoin. Voici une implémentation que j'ai récemment écrite avec PHP et cURL .

<?php
    function buildBaseString($baseURI, $method, $params) {
        $r = array();
        ksort($params);
        foreach($params as $key=>$value){
            $r[] = "$key=" . rawurlencode($value);
        }
        return $method."&" . rawurlencode($baseURI) . '&' . rawurlencode(implode('&', $r));
    }

    function buildAuthorizationHeader($oauth) {
        $r = 'Authorization: OAuth ';
        $values = array();
        foreach($oauth as $key=>$value)
            $values[] = "$key=\"" . rawurlencode($value) . "\"";
        $r .= implode(', ', $values);
        return $r;
    }

    $url = "https://api.twitter.com/1.1/statuses/user_timeline.json";

    $oauth_access_token = "YOURVALUE";
    $oauth_access_token_secret = "YOURVALUE";
    $consumer_key = "YOURVALUE";
    $consumer_secret = "YOURVALUE";

    $oauth = array( 'oauth_consumer_key' => $consumer_key,
                    'oauth_nonce' => time(),
                    'oauth_signature_method' => 'HMAC-SHA1',
                    'oauth_token' => $oauth_access_token,
                    'oauth_timestamp' => time(),
                    'oauth_version' => '1.0');

    $base_info = buildBaseString($url, 'GET', $oauth);
    $composite_key = rawurlencode($consumer_secret) . '&' . rawurlencode($oauth_access_token_secret);
    $oauth_signature = base64_encode(hash_hmac('sha1', $base_info, $composite_key, true));
    $oauth['oauth_signature'] = $oauth_signature;

    // Make requests
    $header = array(buildAuthorizationHeader($oauth), 'Expect:');
    $options = array( CURLOPT_HTTPHEADER => $header,
                      //CURLOPT_POSTFIELDS => $postfields,
                      CURLOPT_HEADER => false,
                      CURLOPT_URL => $url,
                      CURLOPT_RETURNTRANSFER => true,
                      CURLOPT_SSL_VERIFYPEER => false);

    $feed = curl_init();
    curl_setopt_array($feed, $options);
    $json = curl_exec($feed);
    curl_close($feed);

    $twitter_data = json_decode($json);

//print it out
print_r ($twitter_data);

?>

Cela peut être exécuté à partir de la ligne de commande:

$ php <name of PHP script>.php

Le code collé par Rivers est super. Merci beaucoup! Je suis nouveau ici et je ne peux pas commenter, je voudrais juste répondre à la question de javiervd (Comment définiriez-vous le nom d'écran et compter avec cette approche?), Car j'ai perdu beaucoup de temps pour le comprendre en dehors.

Vous devez ajouter les paramètres à la fois à l' URL et au processus de création de signature. Créer une signature est l'article qui m'a aidé. Voici mon code:

$oauth = array(
           'screen_name' => 'DwightHoward',
           'count' => 2,
           'oauth_consumer_key' => $consumer_key,
           'oauth_nonce' => time(),
           'oauth_signature_method' => 'HMAC-SHA1',
           'oauth_token' => $oauth_access_token,
           'oauth_timestamp' => time(),
           'oauth_version' => '1.0'
         );

$options = array(
             CURLOPT_HTTPHEADER => $header,
             //CURLOPT_POSTFIELDS => $postfields,
             CURLOPT_HEADER => false,
             CURLOPT_URL => $url . '?screen_name=DwightHoward&count=2',
             CURLOPT_RETURNTRANSFER => true, CURLOPT_SSL_VERIFYPEER => false
           );

Comme indiqué dans d'autres réponses, créez une application Twitter pour obtenir le jeton, la clé et le secret. En utilisant le code ci-dessous, vous pouvez modifier les paramètres de la demande d'un endroit et éviter les fautes de frappe et les erreurs similaires (changer le $requesttableau dans la returnTweet()fonction).

function buildBaseString($baseURI, $method, $params) {
    $r = array();
    ksort($params);
    foreach($params as $key=>$value){
        $r[] = "$key=" . rawurlencode($value);
    }
    return $method."&" . rawurlencode($baseURI) . '&' . rawurlencode(implode('&', $r));
}

function buildAuthorizationHeader($oauth) {
    $r = 'Authorization: OAuth ';
    $values = array();
    foreach($oauth as $key=>$value)
        $values[] = "$key=\"" . rawurlencode($value) . "\"";
    $r .= implode(', ', $values);
    return $r;
}

function returnTweet(){
    $oauth_access_token         = "x";
    $oauth_access_token_secret  = "x";
    $consumer_key               = "x";
    $consumer_secret            = "x";

    $twitter_timeline           = "user_timeline";  //  mentions_timeline / user_timeline / home_timeline / retweets_of_me

    //  create request
        $request = array(
            'screen_name'       => 'budidino',
            'count'             => '3'
        );

    $oauth = array(
        'oauth_consumer_key'        => $consumer_key,
        'oauth_nonce'               => time(),
        'oauth_signature_method'    => 'HMAC-SHA1',
        'oauth_token'               => $oauth_access_token,
        'oauth_timestamp'           => time(),
        'oauth_version'             => '1.0'
    );

    //  merge request and oauth to one array
        $oauth = array_merge($oauth, $request);

    //  do some magic
        $base_info              = buildBaseString("https://api.twitter.com/1.1/statuses/$twitter_timeline.json", 'GET', $oauth);
        $composite_key          = rawurlencode($consumer_secret) . '&' . rawurlencode($oauth_access_token_secret);
        $oauth_signature            = base64_encode(hash_hmac('sha1', $base_info, $composite_key, true));
        $oauth['oauth_signature']   = $oauth_signature;

    //  make request
        $header = array(buildAuthorizationHeader($oauth), 'Expect:');
        $options = array( CURLOPT_HTTPHEADER => $header,
                          CURLOPT_HEADER => false,
                          CURLOPT_URL => "https://api.twitter.com/1.1/statuses/$twitter_timeline.json?". http_build_query($request),
                          CURLOPT_RETURNTRANSFER => true,
                          CURLOPT_SSL_VERIFYPEER => false);

        $feed = curl_init();
        curl_setopt_array($feed, $options);
        $json = curl_exec($feed);
        curl_close($feed);

    return json_decode($json, true);
}

puis appelez returnTweet()

Merci Kris!

Cela a fonctionné pour moi sans utiliser de paramètres dans la requête, chaque fois que j'utilisais plus d'un paramètre, cela me montrait l'erreur: 32 Impossible de vous authentifier.

Le problème pour moi était dans le codage esperluette. Donc dans votre code où c'est la ligne suivante

$url .= "?".http_build_query($query);

J'ai ajouté la ligne suivante ci-dessous:

$url=str_replace("&","&",$url);

Et cela a fonctionné en utilisant deux ou plusieurs paramètres comme nom_écran et nombre.

Le code entier ressemble à ceci:

$token = 'YOUR TOKEN';
$token_secret = 'TOKEN SECRET';
$consumer_key = 'YOUR KEY';
$consumer_secret = 'KEY SECRET';

$host = 'api.twitter.com';
$method = 'GET';
$path = '/1.1/statuses/user_timeline.json'; // api call path

$query = array( // query parameters
    'screen_name' => 'twitterapi',
    'count' => '2'
);

$oauth = array(
    'oauth_consumer_key' => $consumer_key,
    'oauth_token' => $token,
    'oauth_nonce' => (string)mt_rand(), // a stronger nonce is recommended
    'oauth_timestamp' => time(),
    'oauth_signature_method' => 'HMAC-SHA1',
    'oauth_version' => '1.0'
);

$oauth = array_map("rawurlencode", $oauth); // must be encoded before sorting
$query = array_map("rawurlencode", $query);

$arr = array_merge($oauth, $query); // combine the values THEN sort

asort($arr); // secondary sort (value)
ksort($arr); // primary sort (key)

// http_build_query automatically encodes, but our parameters
// are already encoded, and must be by this point, so we undo
// the encoding step
$querystring = urldecode(http_build_query($arr, '', '&'));

$url = "https://$host$path";

// mash everything together for the text to hash
$base_string = $method."&".rawurlencode($url)."&".rawurlencode($querystring);

// same with the key
$key = rawurlencode($consumer_secret)."&".rawurlencode($token_secret);

// generate the hash
$signature = rawurlencode(base64_encode(hash_hmac('sha1', $base_string, $key, true)));

// this time we're using a normal GET query, and we're only encoding the query params
// (without the oauth params)
$url .= "?".http_build_query($query);
$url=str_replace("&","&",$url); //Patch by @Frewuill

$oauth['oauth_signature'] = $signature; // don't want to abandon all that work!
ksort($oauth); // probably not necessary, but twitter's demo does it

// also not necessary, but twitter's demo does this too
function add_quotes($str) { return '"'.$str.'"'; }
$oauth = array_map("add_quotes", $oauth);

// this is the full value of the Authorization line
$auth = "OAuth " . urldecode(http_build_query($oauth, '', ', '));

// if you're doing post, you need to skip the GET building above
// and instead supply query parameters to CURLOPT_POSTFIELDS
$options = array( CURLOPT_HTTPHEADER => array("Authorization: $auth"),
                  //CURLOPT_POSTFIELDS => $postfields,
                  CURLOPT_HEADER => false,
                  CURLOPT_URL => $url,
                  CURLOPT_RETURNTRANSFER => true,
                  CURLOPT_SSL_VERIFYPEER => false);

// do our business
$feed = curl_init();
curl_setopt_array($feed, $options);
$json = curl_exec($feed);
curl_close($feed);

$twitter_data = json_decode($json);

J'espère que cela aide quelqu'un avec le même problème que moi.

Cette question m'a beaucoup aidé mais ne m'a pas permis de comprendre ce qui doit arriver. Ce billet de blog a fait un travail incroyable pour me guider à travers cela.

Voici les bits importants en un seul endroit:

• Comme indiqué ci-dessus, vous DEVEZ signer vos demandes d'API 1.1. Si vous faites quelque chose comme obtenir des statuts publics, vous voudrez une clé d'application plutôt qu'une clé d'utilisateur. Le lien complet vers la page que vous souhaitez est: https://dev.twitter.com/apps
• Vous devez hacher TOUS les paramètres, les deux oauth ET les paramètres get (ou paramètres POST) ensemble.
• Vous devez TRIER les paramètres avant de les réduire à la forme encodée en URL qui est hachée.
• Vous devez encoder certaines choses plusieurs fois - par exemple, vous créez une chaîne de requête à partir des valeurs encodées par l'url des paramètres, puis vous encodez l'URL THAT et concaténez avec le type de méthode et l'URL.

Je sympathise avec tous les maux de tête, alors voici du code pour tout résumer:

$token = 'YOUR TOKEN';
$token_secret = 'TOKEN SECRET';
$consumer_key = 'YOUR KEY';
$consumer_secret = 'KEY SECRET';

$host = 'api.twitter.com';
$method = 'GET';
$path = '/1.1/statuses/user_timeline.json'; // api call path

$query = array( // query parameters
    'screen_name' => 'twitterapi',
    'count' => '2'
);

$oauth = array(
    'oauth_consumer_key' => $consumer_key,
    'oauth_token' => $token,
    'oauth_nonce' => (string)mt_rand(), // a stronger nonce is recommended
    'oauth_timestamp' => time(),
    'oauth_signature_method' => 'HMAC-SHA1',
    'oauth_version' => '1.0'
);

$oauth = array_map("rawurlencode", $oauth); // must be encoded before sorting
$query = array_map("rawurlencode", $query);

$arr = array_merge($oauth, $query); // combine the values THEN sort

asort($arr); // secondary sort (value)
ksort($arr); // primary sort (key)

// http_build_query automatically encodes, but our parameters
// are already encoded, and must be by this point, so we undo
// the encoding step
$querystring = urldecode(http_build_query($arr, '', '&'));

$url = "https://$host$path";

// mash everything together for the text to hash
$base_string = $method."&".rawurlencode($url)."&".rawurlencode($querystring);

// same with the key
$key = rawurlencode($consumer_secret)."&".rawurlencode($token_secret);

// generate the hash
$signature = rawurlencode(base64_encode(hash_hmac('sha1', $base_string, $key, true)));

// this time we're using a normal GET query, and we're only encoding the query params
// (without the oauth params)
$url .= "?".http_build_query($query);

$oauth['oauth_signature'] = $signature; // don't want to abandon all that work!
ksort($oauth); // probably not necessary, but twitter's demo does it

// also not necessary, but twitter's demo does this too
function add_quotes($str) { return '"'.$str.'"'; }
$oauth = array_map("add_quotes", $oauth);

// this is the full value of the Authorization line
$auth = "OAuth " . urldecode(http_build_query($oauth, '', ', '));

// if you're doing post, you need to skip the GET building above
// and instead supply query parameters to CURLOPT_POSTFIELDS
$options = array( CURLOPT_HTTPHEADER => array("Authorization: $auth"),
                  //CURLOPT_POSTFIELDS => $postfields,
                  CURLOPT_HEADER => false,
                  CURLOPT_URL => $url,
                  CURLOPT_RETURNTRANSFER => true,
                  CURLOPT_SSL_VERIFYPEER => false);

// do our business
$feed = curl_init();
curl_setopt_array($feed, $options);
$json = curl_exec($feed);
curl_close($feed);

$twitter_data = json_decode($json);

Si la bibliothèque PHP OAuth est installée, vous n'avez pas à vous soucier de former la demande vous-même.

$oauth = new OAuth($consumer_key, $consumer_secret, OAUTH_SIG_METHOD_HMACSHA1, OAUTH_AUTH_TYPE_URI);
$oauth->setToken($access_token, $access_secret);

$oauth->fetch("https://api.twitter.com/1.1/statuses/user_timeline.json");
$twitter_data = json_decode($oauth->getLastResponse());

print_r($twitter_data);

Pour plus d'informations, consultez la documentation ou leur exemple . Vous pouvez utiliser pecl install oauthpour obtenir la bibliothèque.

Tout d'abord, je voulais remercier jimbo et ( sa bibliothèque simple post / twitter-api-php).

Si vous allez utiliser l' API GET search / tweets avec la bibliothèque PHP "twitter-api-php" (TwitterAPIExchange.php):

Tout d'abord, il vous suffit de commenter la zone de code "Effectuer une requête POST et faire écho à la réponse".

Utilisez simplement le code "Effectuer une requête GET et faire écho à la réponse" et faire écho à la réponse et modifier ces deux lignes:

$url = 'https://api.twitter.com/1.1/followers/ids.json';
$getfield = '?screen_name=J7mbo';

à

$url = 'https://api.twitter.com/1.1/search/tweets.json';
$getfield = '?q=J7mbo';

(Changez screen_nameen q, c'est tout :)

Vous aurez besoin d'un pour créer une "application" sur Twitter (et vous avez besoin d'un compte Twitter pour ce faire).

Ensuite, vous devez utiliser OAuth pour faire une demande autorisée à Twitter .

Vous pouvez utiliser la ressource GET statuses / user_timeline pour obtenir une liste des tweets récents.

Voici une brève pour obtenir un nombre spécifié de tweets de votre chronologie. Il fait essentiellement la même chose que les autres exemples, mais avec moins de code.

Remplissez simplement les touches et ajustez $countà votre guise:

$url = 'https://api.twitter.com/1.1/statuses/user_timeline.json';
$count = '10';

$oauth = array('count' => $count,
               'oauth_consumer_key' => '[CONSUMER KEY]',
               'oauth_nonce' => md5(mt_rand()),
               'oauth_signature_method' => 'HMAC-SHA1',
               'oauth_timestamp' => time(),
               'oauth_token' => '[ACCESS TOKEN]',
               'oauth_version' => '1.0');

$oauth['oauth_signature'] = base64_encode(hash_hmac('sha1', 'GET&' . rawurlencode($url) . '&' . rawurlencode(implode('&', array_map(function ($v, $k) { return $k . '=' . $v; }, $oauth, array_keys($oauth)))), '[CONSUMER SECRET]&[ACCESS TOKEN SECRET]', true));

$twitterData = json_decode(file_get_contents($url . '?count=' . $count, false, stream_context_create(array('http' => array('method' => 'GET',
                                                                                                                           'header' => 'Authorization: OAuth ' 
                                                                                                                                       . implode(', ', array_map(function ($v, $k) { return $k . '="' . rawurlencode($v) . '"'; }, $oauth, array_keys($oauth))))))));

Celui-ci utilise des fonctions anonymes et file_get_contentsau lieu de la bibliothèque cURL. Notez l'utilisation d'un nonce haché MD5. Tout le monde semble time()accepter le nonce, cependant, la plupart des exemples sur le Web concernant OAuth utilisent une sorte de chaîne cryptée (comme celle-ci: http://www.sitepoint.com/understanding-oauth-1/ ). Cela a plus de sens pour moi aussi.

Remarque supplémentaire: vous avez besoin de PHP 5.3+ pour les fonctions anonymes (au cas où votre serveur / ordinateur se trouve dans une grotte de la guerre froide et que vous ne pouvez pas le mettre à niveau).

A partir de leur générateur de signature , vous pouvez générer des curlcommandes de la forme:

curl --get 'https://api.twitter.com/1.1/statuses/user_timeline.json' --data 'count=2&screen_name=twitterapi' --header 'Authorization: OAuth oauth_consumer_key="YOUR_KEY", oauth_nonce="YOUR_NONCE", oauth_signature="YOUR-SIG", oauth_signature_method="HMAC-SHA1", oauth_timestamp="TIMESTAMP", oauth_token="YOUR-TOKEN", oauth_version="1.0"' --verbose

$connection = new TwitterOAuth(CONSUMER_KEY, CONSUMER_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET);

$timelines = $connection->get('statuses/user_timeline', array('screen_name' => 'NSE_NIFTY', 'count' => 100, 'include_rts' => 1));

Merci à ce fil, et surtout budidino parce que son code est ce qui l'a ramené chez moi. Je voulais juste contribuer à la façon de récupérer les données JSON d'une demande. Apportez des modifications à la partie "// create request" du tableau de requêtes du code pour effectuer différentes requêtes. En fin de compte, cela produira le JSON sur l'écran du navigateur

<?php
    function buildBaseString($baseURI, $method, $params) {
    $r = array();
    ksort($params);
    foreach($params as $key=>$value){
        $r[] = "$key=" . rawurlencode($value);
    }
    return $method."&" . rawurlencode($baseURI) . '&' . rawurlencode(implode('&', $r));
}

function buildAuthorizationHeader($oauth) {
    $r = 'Authorization: OAuth ';
    $values = array();
    foreach($oauth as $key=>$value)
        $values[] = "$key=\"" . rawurlencode($value) . "\"";
    $r .= implode(', ', $values);
    return $r;
}

function returnTweet(){
    $oauth_access_token         = "2602299919-lP6mgkqAMVwvHM1L0Cplw8idxJzvuZoQRzyMkOx";
    $oauth_access_token_secret  = "wGWny2kz67hGdnLe3Uuy63YZs4nIGs8wQtCU7KnOT5brS";
    $consumer_key               = "zAzJRrPOj5BvOsK5QhscKogVQ";
    $consumer_secret            = "Uag0ujVJomqPbfdoR2UAWbRYhjzgoU9jeo7qfZHCxR6a6ozcu1";

    $twitter_timeline           = "user_timeline";  //  mentions_timeline / user_timeline / home_timeline / retweets_of_me

    //  create request
        $request = array(
            'screen_name'       => 'burownrice',
            'count'             => '3'
        );

    $oauth = array(
        'oauth_consumer_key'        => $consumer_key,
        'oauth_nonce'               => time(),
        'oauth_signature_method'    => 'HMAC-SHA1',
        'oauth_token'               => $oauth_access_token,
        'oauth_timestamp'           => time(),
        'oauth_version'             => '1.0'
    );

    //  merge request and oauth to one array
        $oauth = array_merge($oauth, $request);

    //  do some magic
        $base_info              = buildBaseString("https://api.twitter.com/1.1/statuses/$twitter_timeline.json", 'GET', $oauth);
        $composite_key          = rawurlencode($consumer_secret) . '&' . rawurlencode($oauth_access_token_secret);
        $oauth_signature            = base64_encode(hash_hmac('sha1', $base_info, $composite_key, true));
        $oauth['oauth_signature']   = $oauth_signature;

    //  make request
        $header = array(buildAuthorizationHeader($oauth), 'Expect:');
        $options = array( CURLOPT_HTTPHEADER => $header,
                          CURLOPT_HEADER => false,
                          CURLOPT_URL => "https://api.twitter.com/1.1/statuses/$twitter_timeline.json?". http_build_query($request),
                          CURLOPT_RETURNTRANSFER => true,
                          CURLOPT_SSL_VERIFYPEER => false);

        $feed = curl_init();
        curl_setopt_array($feed, $options);
        $json = curl_exec($feed);
        curl_close($feed);

    return $json;
}

$tweet = returnTweet();
echo $tweet;

?>

Si c'est utile pour n'importe qui ... Dans mon blog, j'ai implémenté le code PHP suivant afin de récupérer les derniers tweets, d'extraire leurs données les plus pertinentes puis de les enregistrer dans une base de données MySQL. Cela fonctionne parce que je l'ai dans mon blog.

La table "tweets" où les stocker:

CREATE TABLE IF NOT EXISTS `tweets` (
  `tweet_id` int(11) NOT NULL auto_increment,
  `id_tweet` bigint(20) NOT NULL,
  `text_tweet` char(144) NOT NULL,
  `datetime_tweet` datetime NOT NULL,
  `dayofweek_tweet` char(3) NOT NULL,
  `GMT_tweet` char(5) NOT NULL,
  `shorturl_tweet` char(23) NOT NULL,
  PRIMARY KEY  (`tweet_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=83 ;

get_tweets.php:

<?php
function buildBaseString($baseURI, $method, $params) {
    $r= array();
    ksort($params);
    foreach($params as $key=>$value){
        $r[]= "$key=".rawurlencode($value);
    }
    return $method."&".rawurlencode($baseURI).'&'.rawurlencode(implode('&', $r));
}

function buildAuthorizationHeader($oauth) {
    $r= 'Authorization: OAuth ';
    $values= array();
    foreach($oauth as $key=>$value) {
        $values[]= "$key=\"".rawurlencode($value)."\"";
    }
    $r.= implode(', ', $values);
    return $r;
}

function returnTweets($last_id) {
    $oauth_access_token         = "2687912757-vbyfJA483SEyj2HJ2K346aVMxtOIgVbsY4Edrsw";
    $oauth_access_token_secret  = "nIruzmR0bXqC3has4fTf8KAq4pgOceiuKqjklhroENU4W";
    $api_key                    = "ieDSTFH8QHHPafg7H0whQB9GaY";
    $api_secret                 = "mgm8wVS9YP93IJmTQtsmR8ZJADDNdlTca5kCizMkC7O7gFDS1j";
    $twitter_timeline           = "user_timeline";  //[mentions_timeline/user_timeline/home_timeline/retweets_of_me]
    //create request
    $request= array(
        'screen_name'       => 'runs_ES',
        'count'             => '3',
        'exclude_replies'   => 'true'
        );
    if (!is_null($last_id)) { //Add to the request if it exits a last_id
        $request['since_id']= $max_id;
    }
    $oauth = array(
        'oauth_consumer_key'        => $api_key,
        'oauth_nonce'               => time(),
        'oauth_signature_method'    => 'HMAC-SHA1',
        'oauth_token'               => $oauth_access_token,
        'oauth_timestamp'           => time(),
        'oauth_version'             => '1.0'
        );
    //merge request and oauth to one array
    $oauth= array_merge($oauth, $request);
    //do some magic
    $base_info=                 buildBaseString("https://api.twitter.com/1.1/statuses/$twitter_timeline.json", 'GET', $oauth);
    $composite_key=             rawurlencode($api_secret).'&'.rawurlencode($oauth_access_token_secret);
    $oauth_signature=           base64_encode(hash_hmac('sha1', $base_info, $composite_key, true));
    $oauth['oauth_signature']=  $oauth_signature;
    //make request
    $header= array(buildAuthorizationHeader($oauth), 'Expect:');
    $options= array(CURLOPT_HTTPHEADER => $header,
                    CURLOPT_HEADER => false,
                    CURLOPT_URL => "https://api.twitter.com/1.1/statuses/$twitter_timeline.json?". http_build_query($request),
                    CURLOPT_RETURNTRANSFER => true,
                    CURLOPT_SSL_VERIFYPEER => false);
    $feed= curl_init();
    curl_setopt_array($feed, $options);
    $json= curl_exec($feed);
    curl_close($feed);
    return $json;
}

function parse_tweettext($tweet_text) {
    $text= substr($tweet_text, 0, -23);
    $short_url= substr($tweet_text, -23, 23);
    return array ('text'=>$text, 'short_url'=> $short_url);
}

function parse_tweetdatetime($tweetdatetime) {
    //Thu Aug 21 21:57:26 +0000 2014 Sun Mon Tue Wed Thu Fri Sat
    $months= array('Jan'=>'01', 'Feb'=>'02', 'Mar'=>'03', 'Apr'=>'04', 'May'=>'05', 'Jun'=>'06', 
                    'Jul'=>'07', 'Aug'=>'08', 'Sep'=>'09', 'Oct'=>'10', 'Nov'=>'11', 'Dec'=>'12');
    $GMT= substr($tweetdatetime, -10, 5);
    $year= substr($tweetdatetime, -4, 4);
    $month_str= substr($tweetdatetime, 4, 3);
    $month= $months[$month_str];
    $day= substr($tweetdatetime, 8, 2); 
    $dayofweek= substr($tweetdatetime, 0, 3);
    $time= substr($tweetdatetime, 11, 8);
    $date= $year.'-'.$month.'-'.$day;
    $datetime= $date.' '.$time;
    return array('datetime'=>$datetime, 'dayofweek'=>$dayofweek, 'GMT'=>$GMT);
    //datetime: "YYYY-MM-DD HH:MM:SS", dayofweek: Mon, Tue..., GMT: +####
}

//First check in the database the last id tweet:
$query= "SELECT MAX(tweets.id_tweet) AS id_last FROM tweets;";
$result= exec_query($query);
$row= mysql_fetch_object($result);
if ($result!= 0 && mysql_num_rows($result)) { //if error in query or not results
    $last_id= $row->id_last;
}
else {
    $last_id= null;
}

$json= returnTweets($last_id);
$tweets= json_decode($json, TRUE);

foreach ($tweets as $tweet) {
    $tweet_id= $tweet['id'];
    if (!empty($tweet_id)) { //if array is not empty
        $tweet_parsetext= parse_tweettext($tweet['text']);
        $tweet_text= utf8_encode($tweet_parsetext['text']);
        $tweet_shorturl= $tweet_parsetext['short_url'];
        $tweet_parsedt= parse_tweetdatetime($tweet['created_at']);
        $tweet_datetime= $tweet_parsedt['datetime'];
        $tweet_dayofweek= $tweet_parsedt['dayofweek'];
        $tweet_GMT= $tweet_parsedt['GMT'];
        //Insert the tweet into the database:
        $fields = array(
            'id_tweet' => $tweet_id,
            'text_tweet' => $tweet_text,
            'datetime_tweet' => $tweet_datetime,
            'dayofweek_tweet' => $tweet_dayofweek,
            'GMT_tweet' => $tweet_GMT,
            'shorturl_tweet' => $tweet_shorturl
            );
        $new_id= mysql_insert('tweets', $fields);
    }
} //end of foreach
?>

La fonction pour enregistrer les tweets:

function mysql_insert($table, $inserts) {
    $keys = array_keys($inserts);
    exec_query("START TRANSACTION;");
    $query= 'INSERT INTO `'.$table.'` (`'.implode('`,`', $keys).'`) VALUES (\''.implode('\',\'', $inserts).'\')';
    exec_query($query);
    $id= mysql_insert_id();
    if (mysql_error()) {
        exec_query("ROLLBACK;");
        die("Error: $query");
    }
    else {
        exec_query("COMMIT;");
    }
    return $id;
}