Лучшие библиотеки для работы с VK API на C++, Java, Python и других языках

			PhotoUpload serverResponse = vk.photos().getWallUploadServer(actor).execute();
WallUploadResponse uploadResponse = vk.upload().photoWall(serverResponse.getUploadUrl(), file).execute();
List<Photo> photoList = vk.photos().saveWallPhoto(actor, uploadResponse.getPhoto())
     .server(uploadResponse.getServer())
     .hash(uploadResponse.getHash())
     .execute();

Photo photo = photoList.get(0); 
String attachId = "photo" + photo.getOwnerId() + "_" + photo.getId();
GetResponse getResponse = vk.wall().post(actor)
    .attachments(attachId)
    .execute();
		

			var clientId = 12345; // API client Id
var clientSecret = "super_secret"; // API client secret
var client = new InTouch(clientId, clientSecret);

// Authorization works only in Windows (and WinPhone) Store Apps
// otherwise you'll need to set received "access_token" manually
// using SetSessionData method.
await client.Authorize();

// Gets a list of a user's friends.
var friends = await client.Friends.Get();

if (friends.IsError == false)
{
    ShowFriendsList(friends.Data.Items.Where(friend => friend.Online));
}

client.Dispose();
		

			using (var client = new InTouch(12345, "super_secret"))
{
    await client.Authorize();

    var friends = await client.Friends.Get();
    // ...
}
		

			npm install node-vkapi --only=prod --save
		

			const VKApi = require('node-vkapi');
const VK    = new VKApi({
  app: {
    id: 1234567890,
    secret: 'app-secret-key'
  }, 
  auth: {
    login: '+79871234567', 
    pass: 'password123'
  }
});

VK.auth.user({
  scope: ['audio', 'photos', 'friends', 'wall', 'offline']
}).then(token => {
  return VK.call('wall.post', {
    owner_id: token.user_id, 
    friends_only: 0, 
    message: 'Post to wall via node-vkapi'
  }).then(res => {
    // wall.post response
    return 'https://vk.com/wall' + token.user_id + '_' + res.post_id;
  });
}).then(link => {
  // returned data from previous .then
  console.log('Post was published: ' + link);
}).catch(error => {
  // catching errors
  console.log(error);
});
		

			#include "src/api.h"
...
VK::Client api;
if(api.auth(login, pass, access_token))
{
  cout << "Auth ok" << endl;
  cout << "Access token: " << api.access_token() << endl << endl;  
  cout << api.call("wall.post", "owner_id=12345&message=Test");
}
else{
  cout << "Auth fail" << endl;
}
		

			>>> import vk
>>> session = vk.Session()
>>> api = vk.API(session)
>>> api.users.get(user_ids=1)
[{'first_name': 'Pavel', 'last_name': 'Durov', 'id': 1}]
		

			import vk_api


def main():
    """ Пример: загрузка фото """

    login, password = 'python@vk.com', 'mypassword'
    vk_session = vk_api.VkApi(login, password)

    try:
        vk_session.authorization()
    except vk_api.AuthorizationError as error_msg:
        print(error_msg)
        return

    """
        В VkUpload реализованы методы загрузки файлов в ВК.
        (Не все, если что-то понадобится - могу дописать)
    """
    upload = vk_api.VkUpload(vk_session)

    photo = upload.photo(  # Подставьте свои данные
        'D:/downloads/tube.jpg',
        album_id=200851098,
        group_id=74030368
    )

    vk_photo_url = 'https://vk.com/photo{}_{}'.format(
        photo[0]['owner_id'], photo[0]['id']
    )

    print(photo, '\nLink: ', vk_photo_url)

if __name__ == '__main__':
main()
		

			//MESSAGES
$data = $vk->request('messages.get', ['count' => 200]);

$userMap = [];
$userCache = [];

$user = new \getjump\Vk\Wrapper\User($vk);

$fetchData = function($id) use($user, &$userMap, &$userCache)
{
   if(!isset($userMap[$id]))
   {
       $userMap[$id] = sizeof($userCache);
       $userCache[] = $user->get($id)->response->get();
   }

   return $userCache[$userMap[$id]];
};

//REQUEST WILL ISSUE JUST HERE! SINCE __get overrided
$data->each(function($key, $value) use($fetchData) {
   $user = $fetchData($value->user_id);
   printf("[%s] %s <br>", $user->getName(), $value->body);
   return;
});
		

			# создаем клиент
@vk = VkontakteApi::Client.new
# и вызываем методы API
@vk.users.get(uid: 1)

# в ruby принято использовать snake_case в названиях методов,
# поэтому likes.getList становится likes.get_list
@vk.likes.get_list
# также названия методов, которые возвращают '1' или '0',
# заканчиваются на '?', а возвращаемые значения приводятся
# к true или false
@vk.is_app_user? # => false

# если ВКонтакте ожидает получить параметр в виде списка,
# разделенного запятыми, то его можно передать массивом
users = @vk.users.get(uids: [1, 2, 3])

# большинство методов возвращает структуры Hashie::Mash
# и массивы из них
users.first.uid        # => 1
users.first.first_name # => "Павел"
users.first.last_name  # => "Дуров"

# если метод, возвращающий массив, вызывается с блоком,
# то блок будет выполнен для каждого элемента,
# и метод вернет обработанный массив
fields = [:first_name, :last_name, :screen_name]
@vk.friends.get(uid: 2, fields: fields) do |friend|
 "#{friend.first_name} '#{friend.screen_name}' #{friend.last_name}"
end
# => ["Павел 'durov' Дуров"]
		

			use AnyEvent;
use AnyEvent::VK;
use Data::Dumper;

my $vk = AnyEvent::VK->new(
    app_id    => 'Your APP ID',
    email     => 'Email/Mobile of user',
    password  => 'User Password',
    scope     => 'Application permissions',
);
# or
my $vk = AnyEvent::VK->new(
    app_id    => 'Your APP ID',
    email     => 'Email/Mobile of user',
    password  => 'User Password',
    scope     => 'Application permissions',

    token     => 'Your access_token',
    expires   => 'Token expires timestamp',
    user_id   => 'user_id',
);

my $cv = AE::cv; $cv->begin;
$vk->auth(sub {
    my $success = shift;
    if ($success) {
        my ($token, $expires_in, $user_id) = @_;

        $vk->request('users.get', {
            user_ids => '1',
            fields => 'bdate,sex,city,verified',
        }, sub {
            my $response = shift;
            if ($response) {
                my $meta = shift;
                say Dumper($response);
            } else {
                my $meta = shift;
                warn 'Request failed';
                say Dumper($meta);
            }
            $cv->end;
        });
    } else {
        my ($stage, $headers, $body, $cookie) = @_;
        warn 'Auth failed';
        say Dumper(@_);
    }
    $cv->end;
});

$cv->recv;
		

			request.executeWithListener(new VKRequestListener() {
   @Override
   public void onComplete(VKResponse response) {
       //Do complete stuff
   }
   @Override
   public void onError(VKError error) {
       //Do error stuff
   }
   @Override
   public void onProgress(VKRequest.VKProgressType progressType,
                                    long bytesLoaded,
                                    long bytesTotal)
   {
       //I don't really believe in progress
   }
   @Override
   public void attemptFailed(VKRequest request, int attemptNumber, int totalAttempts) {
       //More luck next time
   }
});
		

			private void GetUserInfoButton_Click(object sender, RoutedEventArgs e)
{          
    VKRequest.Dispatch<List<VKUser>>(
        new VKRequestParameters(
            "users.get",
            "fields", "photo_200, city, country"),
            (res) =>
                {
                    if (res.ResultCode == VKResultCode.Succeeded)
                    {
                        VKExecute.ExecuteOnUIThread(() =>
                            {
                                var user = res.Data[0];

                                userImage.Source = new BitmapImage(new Uri(user.photo_200, UriKind.Absolute));

                                userInfo.Text = user.first_name + " " + user.last_name;
                            });
                    }
                });            
}
		

			[audioReq executeWithResultBlock:^(VKResponse *response) {
       NSLog(@"Json result: %@", response.json);
   } errorBlock:^(NSError * error) {
   if (error.code != VK_API_ERROR) {
       [error.vkError.request repeat];
   } else {
       NSLog(@"VK error: %@", error);
   }
}];
		

			extern crate vkrs;

use std::{env, io};
use vkrs::*;

fn main() {
    let api = api::Client::new();
    let oauth = api.auth(
        env::var("VK_APP_ID").unwrap(),
        env::var("VK_APP_SECRET").unwrap());

    let auth_uri = oauth.auth_uri(auth::Permission::Audio).unwrap();
    // Or if you want to get permissions for specific request:
    // let auth_uri = oauth.auth_uri_for::<audio::Search>();
    println!("Go to {} and enter code below...", auth_uri);

    let inp = io::stdin();
    let code = {
        let mut buf = String::new();
        inp.read_line(&mut buf).unwrap();
        buf
    };

    // You may want to save this token for future use to avoid asking user
    // to authorize the app on each run.
    let token = oauth.request_token(code.trim()).unwrap();

    // The access token is JSON serializable with serde, so you can do it this way:
    // File::create(TOKEN_FILE).ok().map(|mut f| serde_json::to_writer(&mut f, &token).ok()).unwrap();
    //
    // And then you can load it again:
    // let token: auth::AccessToken = File::open(TOKEN_FILE).ok().and_then(|mut f| serde_json::from_reader(&mut f).ok()).unwrap();

    let songs = api.get(Some(&token),
        audio::Search::new()
            .q("Poets Of The Fall")
            .performer_only(true)
            .count(200))
        .unwrap();

    for song in &songs.items {
        println!("{:?}", song);
    }
}
		

			package main

import (
    "github.com/urShadow/go-vk-api"
    "log"
    "strconv"
)

func main() {
    api := vk.New("ru")
    // set http proxy
    //api.Proxy = "localhost:8080"

    err := api.Init("TOKEN")

    if err != nil {
        log.Fatalln(err)
    }

    api.OnNewMessage(func(msg *vk.LPMessage) {
        if msg.Flags&vk.FlagMessageOutBox == 0 {
            if msg.Text == "/hello" {
                api.Messages.Send(vk.RequestParams{
                    "peer_id":          strconv.FormatInt(msg.FromID, 10),
                    "message":          "Hello!",
                    "forward_messages": strconv.FormatInt(msg.ID, 10),
                })
            }
        }
    })

    api.RunLongPoll()
}