VK PHP SDK

https://github.com/vkcom/vk-php-sdk
Admin
A PHP library for VK API interaction, including OAuth 2.0 authorization and various API methods,...
Tokens:11,967
Snippets:39
Trust Score:8.3
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install vk-php-sdk using Composer

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Install the VK PHP SDK using Composer by running the provided command in your terminal. This is the standard method for managing PHP dependencies.

```sh
composer require vkcom/vk-php-sdk
```

--------------------------------

### Start Listening to VK Long Poll Events

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Initializes and starts the Long Poll event listener using VKCallbackApiLongPollExecutor. Requires VK API client, access token, group ID, a handler instance, and a wait period. Can optionally start listening from a specific event timestamp.

```php
$vk = new \VK\Client\VKApiClient();
$access_token = 'asdj4iht2i4ntokqngoiqn3ripogqr';
$group_id = 159895463;
$wait = 25;

$handler = new CallbackApiMyHandler();
$executor = new \VK\CallbackApi\LongPoll\VKCallbackApiLongPollExecutor($vk, $access_token, $group_id, $handler, $wait);
$executor->listen();
```

```php
$vk = new \VK\Client\VKApiClient();
$access_token = 'asdj4iht2i4ntokqngoiqn3ripogqr';
$group_id = 159895463;
$timestamp = 12;
$wait = 25;

$executor = new \VK\CallbackApi\LongPoll\VKCallbackApiLongPollExecutor($vk, $access_token, $group_id, $handler, $wait);
$executor->listen($timestamp);
```

--------------------------------

### Make API Request to users.get

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Example of making an API request to the 'users.get' method using the VK PHP SDK. Requires an access token and an array of user IDs and desired fields.

```php
$vk = new \VK\Client\VKApiClient();
$response = $vk->users()->get($access_token, [
    'user_ids'  => [1, 210700286],
    'fields'    => ['city', 'photo'],
]);
```

--------------------------------

### Initialize VK API Client with PHP

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Demonstrates how to initialize the VKApiClient in PHP. It covers basic initialization with default settings, custom API versions, and custom API versions with language settings. The examples show how to access different API categories like users, groups, messages, and wall.

```php
<?php
require 'vendor/autoload.php';

// Basic initialization with default settings (API v5.199)
$vk = new \VK\Client\VKApiClient();

// Initialize with custom API version
$vk = new \VK\Client\VKApiClient('5.199');

// Initialize with custom API version and language
$vk = new \VK\Client\VKApiClient('5.199', \VK\Client\Enums\VKLanguage::ENGLISH);

// Access different API categories
$usersApi = $vk->users();
$groupsApi = $vk->groups();
$messagesApi = $vk->messages();
$wallApi = $vk->wall();

```

--------------------------------

### Users Get API

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

This endpoint retrieves information about VK users. You can specify user IDs and the fields you want to retrieve for each user.

```APIDOC
## GET /api/users.get

### Description
Retrieves information about VK users. Allows specifying user IDs and desired fields.

### Method
GET

### Endpoint
/api/users.get

### Parameters
#### Query Parameters
- **access_token** (string) - Required - User's access token.
- **user_ids** (array) - Required - A list of user IDs to retrieve information for.
- **fields** (array) - Optional - A list of fields to retrieve for each user (e.g., 'city', 'photo').

### Request Example
```php
$vk = new \VK\Client\VKApiClient();
$response = $vk->users()->get($access_token, [
    'user_ids'  => [1, 210700286],
    'fields'    => ['city', 'photo'],
]);
```

### Response
#### Success Response (200)
- **response** (array) - An array of user objects, each containing the requested fields.

#### Response Example
```json
{
  "response": [
    {
      "id": 1,
      "first_name": "...",
      "last_name": "...",
      "city": {
        "id": 1,
        "title": "..."
      },
      "photo_50": "..."
    }
  ]
}
```
```

--------------------------------

### VK Callback API Confirmation and Event Handling

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Implements a server handler for VK's Callback API, including a confirmation method for initial setup and methods to handle incoming events like new messages. Requires secret key, group ID, and confirmation token for validation.

```php
class ServerHandler extends \VK\CallbackApi\VKCallbackApiServerHandler {
    const SECRET = 'ab12aba';
    const GROUP_ID = 123999;
    const CONFIRMATION_TOKEN = 'e67anm1';

    function confirmation(int $group_id, ?string $secret) {
        if ($secret === static::SECRET && $group_id === static::GROUP_ID) {
            echo static::CONFIRMATION_TOKEN;
        }
    }
    
    public function messageNew(int $group_id, ?string $secret, array $object) {
        echo 'ok';
    }
}

$handler = new ServerHandler();
$data = json_decode(file_get_contents('php://input'));
$handler->parse($data);
```

--------------------------------

### Get User Authorization URL (Implicit Flow)

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Generate a URL for the Implicit OAuth 2.0 Flow to get a temporary user access key. This flow is simpler as it doesn't require exchanging a code for a token.

```php
$oauth = new VKOAuthVKOAuth();
$client_id = 1234567;
$redirect_uri = 'https://example.com/vk';
$display = VKOAuthVKOAuthDisplay::PAGE;
$scope = [VKOAuthScopesVKOAuthUserScope::WALL, VKOAuthScopesVKOAuthUserScope::GROUPS];
$state = 'secret_state_code';
$revoke_auth = true;

$browser_url = $oauth->getAuthorizeUrl(VKOAuthVKOAuthResponseType::TOKEN, $client_id, $redirect_uri, $display, $scope, $state, null, $revoke_auth);
```

--------------------------------

### Get User Authorization URL (Code Flow)

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Generate a URL to initiate the OAuth 2.0 Authorization Code Flow for obtaining a user access key. This involves specifying client ID, redirect URI, display type, scopes, and a state parameter.

```php
$oauth = new VKOAuthVKOAuth();
$client_id = 1234567;
$redirect_uri = 'https://example.com/vk';
$display = VKOAuthVKOAuthDisplay::PAGE;
$scope = [VKOAuthScopesVKOAuthUserScope::WALL, VKOAuthScopesVKOAuthUserScope::GROUPS];
$state = 'secret_state_code';

$browser_url = $oauth->getAuthorizeUrl(VKOAuthVKOAuthResponseType::CODE, $client_id, $redirect_uri, $display, $scope, $state);
```

--------------------------------

### Get Community Access Key using VK OAuth

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Generates a URL to obtain a community access key for VK. Requires client ID, redirect URI, display settings, scope, state, and group IDs. The access token is returned as a fragment parameter upon successful authorization.

```php
$oauth = new \VK\OAuth\VKOAuth();
$client_id = 1234567;
$redirect_uri = 'https://example.com/vk';
$display = \VK\OAuth\VKOAuthDisplay::PAGE;
$scope = [\VK\OAuth\Scopes\VKOAuthGroupScope::MESSAGES];
$state = 'secret_state_code';
$groups_ids = [1, 2];

$browser_url = $oauth->getAuthorizeUrl(\VK\OAuth\VKOAuthResponseType::TOKEN, $client_id, $redirect_uri, $display, $scope, $state, $groups_ids);
```

--------------------------------

### Upload Photo to Private Message using VK API

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Demonstrates uploading a photo to a private message using the VK PHP SDK. Involves three steps: getting the upload server address, uploading the photo, and saving the photo to the VK servers. Requires an access token.

```php
$vk = new \VK\Client\VKApiClient();
$address = $vk->photos()->getMessagesUploadServer('{access_token}');

$vk = new \VK\Client\VKApiClient();
$photo = $vk->getRequest()->upload($address['upload_url'], 'photo', 'photo.jpg');

$vk = new \VK\Client\VKApiClient();
$response_save_photo = $vk->photos()->saveMessagesPhoto($access_token, [
    'server' => $photo['server'],
    'photo'  => $photo['photo'],
    'hash'   => $photo['hash'],
]);
```

--------------------------------

### Refresh VK Access Tokens with PHP SDK

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

This PHP code snippet demonstrates how to refresh expired access tokens using the VK PHP SDK. It utilizes the `User` class and `RefreshTokensParams` to obtain new tokens and updates session variables. It also shows how to retrieve user information with the new token and includes error handling for authentication and client-side issues. The example concludes with a demonstration of logging out and revoking tokens.

```php
<?php
use VK\OAuth\User\User;
use VK\OAuth\User\DTO\RefreshTokensParams;
use VK\OAuth\User\DTO\LogoutParams;

$oauth = new User();
$clientId = 1234567;
$deviceId = 'device_id_from_initial_auth';
$refreshToken = 'stored_refresh_token';

try {
    // Refresh access token
    $refreshParams = new RefreshTokensParams($clientId, $refreshToken, $deviceId);
    $newTokens = $oauth->refreshTokens($refreshParams);

    $newAccessToken = $newTokens['access_token'];
    $newRefreshToken = $newTokens['refresh_token'];
    $expiresIn = $newTokens['expires_in']; // Token lifetime in seconds

    // Update stored tokens
    $_SESSION['vk_access_token'] = $newAccessToken;
    $_SESSION['vk_refresh_token'] = $newRefreshToken;
    $_SESSION['vk_token_expires'] = time() + $expiresIn;

    echo "Tokens refreshed successfully!\n";
    echo "New access token valid for {$expiresIn} seconds\n";

    // Get user info with new token
    $userInfoParams = new LogoutParams($newAccessToken, $clientId);
    $userInfo = $oauth->getUserInfo($userInfoParams);

    echo "User email: {$userInfo['email']}\n";
    echo "User name: {$userInfo['first_name']} {$userInfo['last_name']}\n";

} catch (\VK\Exceptions\VKOAuthException $e) {
    error_log("Token refresh failed: {$e->getMessage()}");
    // Refresh token expired or invalid - need full re-authentication
    // Redirect user to authorization flow
} catch (\VK\Exceptions\VKClientException $e) {
    error_log("Client error: {$e->getMessage()}");
}

// Logout and revoke tokens when user logs out
try {
    $logoutParams = new LogoutParams($newAccessToken, $clientId);

    // Invalidate all tokens
    $oauth->logout($logoutParams);

    // Or just revoke specific scopes
    $oauth->revoke($logoutParams);

    // Clear stored tokens
    unset($_SESSION['vk_access_token']);
    unset($_SESSION['vk_refresh_token']);

    echo "User logged out successfully\n";

} catch (Exception $e) {
    error_log("Logout error: {$e->getMessage()}");
}

```

--------------------------------

### Get Community Authorization URL (Code Flow)

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Generate a URL for the OAuth 2.0 Authorization Code Flow to obtain a community access key. This is similar to the user flow but includes specific group scopes and an optional group IDs parameter.

```php
$oauth = new VKOAuthVKOAuth();
$client_id = 1234567;
$redirect_uri = 'https://example.com/vk';
$display = VKOAuthVKOAuthDisplay::PAGE;
$scope = [VKOAuthScopesVKOAuthGroupScope::MESSAGES];
$state = 'secret_state_code';
$groups_ids = [1, 2];

$browser_url = $oauth->getAuthorizeUrl(VKOAuthVKOAuthResponseType::CODE, $client_id, $redirect_uri, $display, $scope, $state, $groups_ids);
```

--------------------------------

### Upload Photos to Messages with VK PHP SDK

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Uploads photos to VK messages by first getting an upload server URL, then uploading the file, and finally saving the photo. It demonstrates sending a single photo and then sending multiple photos in one message. Handles potential API exceptions during the process.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token';

try {
    // Step 1: Get upload server URL
    $uploadServer = $vk->photos()->getMessagesUploadServer($accessToken, [
        'peer_id' => 123456 // Optional: specify recipient
    ]);

    $uploadUrl = $uploadServer['upload_url'];

    // Step 2: Upload photo file to server
    $photoPath = '/path/to/your/photo.jpg';
    $uploadResponse = $vk->getRequest()->upload($uploadUrl, 'photo', $photoPath);

    // $uploadResponse contains: server, photo, hash

    // Step 3: Save uploaded photo
    $savedPhoto = $vk->photos()->saveMessagesPhoto($accessToken, [
        'server' => $uploadResponse['server'],
        'photo' => $uploadResponse['photo'],
        'hash' => $uploadResponse['hash']
    ]);

    $photo = $savedPhoto[0];
    $photoAttachment = "photo{$photo['owner_id']}_{$photo['id']}";

    // Step 4: Send message with uploaded photo
    $vk->messages()->send($accessToken, [
        'user_id' => 123456,
        'message' => 'Here is your photo!',
        'attachment' => $photoAttachment,
        'random_id' => random_int(0, PHP_INT_MAX)
    ]);

    echo "Photo uploaded and sent successfully!
";
    echo "Photo attachment: {$photoAttachment}
";

    // Upload multiple photos
    $photoPaths = ['/path/to/photo1.jpg', '/path/to/photo2.jpg', '/path/to/photo3.jpg'];
    $attachments = [];

    foreach ($photoPaths as $path) {
        $uploadServer = $vk->photos()->getMessagesUploadServer($accessToken);
        $upload = $vk->getRequest()->upload($uploadServer['upload_url'], 'photo', $path);
        $saved = $vk->photos()->saveMessagesPhoto($accessToken, [
            'server' => $upload['server'],
            'photo' => $upload['photo'],
            'hash' => $upload['hash']
        ]);

        $p = $saved[0];
        $attachments[] = "photo{$p['owner_id']}_{$p['id']}";
    }

    // Send all photos in one message
    $vk->messages()->send($accessToken, [
        'user_id' => 123456,
        'message' => 'Multiple photos!',
        'attachment' => implode(',', $attachments),
        'random_id' => random_int(0, PHP_INT_MAX)
    ]);

} catch (VKExceptionsVKApiException $e) {
    error_log("Photo upload error: {$e->getMessage()}");
}

```

--------------------------------

### Initialize VKApiClient

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Create a VKApiClient object for interacting with the VK API. You can initialize it with default settings or specify a custom API version and language.

```php
$vk = new VKClientVKApiClient();
```

```php
$vk = new VKApiClient('5.199');
```

```php
$vk = new VKApiClient('5.199', VKClientEnumsVKLanguage::ENGLISH);
```

--------------------------------

### Post to VK Wall with PHP SDK

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Enables creating and managing wall posts on user profiles or community pages. Supports text posts, posts with attachments, scheduling, cross-posting, and creating comments. Requires an access token and relevant IDs.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token_here';

try {
    // Simple text post to user's wall
    $response = $vk->wall()->post($accessToken, [
        'owner_id' => 123456, // Your user ID
        'message' => 'Hello from VK PHP SDK! 🚀',
        'from_group' => 0
    ]);

    $postId = $response['post_id'];
    echo "Posted successfully! Post ID: {$postId}\n";

    // Post to community wall with attachments
    $response = $vk->wall()->post($accessToken, [
        'owner_id' => -987654321, // Negative for community
        'message' => 'Check out this awesome content!',
        'attachments' => [
            'photo-987654321_456239017',
            'https://example.com/article'
        ],
        'services' => 'twitter', // Cross-post to Twitter
        'signed' => 1, // Show author signature
        'mark_as_ads' => 0
    ]);

    // Schedule a post for later
    $futureTimestamp = strtotime('+2 hours');
    $response = $vk->wall()->post($accessToken, [
        'owner_id' => 123456,
        'message' => 'This post is scheduled!',
        'publish_date' => $futureTimestamp
    ]);

    // Create a comment on a wall post
    $commentResponse = $vk->wall()->createComment($accessToken, [
        'owner_id' => 123456,
        'post_id' => 42,
        'message' => 'Great post!',
        'attachments' => ['photo123456_789012345']
    ]);

    echo "Comment ID: {$commentResponse['comment_id']}\n";

    // Get wall posts
    $posts = $vk->wall()->get($accessToken, [
        'owner_id' => 123456,
        'count' => 10,
        'filter' => 'owner'
    ]);

    foreach ($posts['items'] as $post) {
        echo "Post {$post['id']}: {$post['text']}\n";
        echo "Likes: {$post['likes']['count']}, Comments: {$post['comments']['count']}\n";
    }

} catch (VKExceptionsVKApiException $e) {
    error_log("Wall API Error: {$e->getMessage()}");
}

```

--------------------------------

### Retrieve VK User Information with PHP SDK

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Fetches detailed information about VK users, including profile data, photos, and online status. Supports single user, multiple users, and search functionalities. Requires an access token and user IDs or search criteria.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token_here';

try {
    // Get single user by ID
    $response = $vk->users()->get($accessToken, [
        'user_ids' => [1],
        'fields' => ['city', 'photo_100', 'photo_200', 'online', 'sex', 'bdate', 'country']
    ]);

    $user = $response[0];
    echo "Name: {$user['first_name']} {$user['last_name']}\n";
    echo "Photo: {$user['photo_100']}\n";
    echo "Online: " . ($user['online'] ? 'Yes' : 'No') . "\n";

    // Get multiple users at once
    $response = $vk->users()->get($accessToken, [
        'user_ids' => [1, 210700286, 123456],
        'fields' => ['city', 'photo_200', 'online', 'followers_count']
    ]);

    foreach ($response as $user) {
        echo "{$user['first_name']} {$user['last_name']} - {$user['city']['title']}\n";
    }

    // Search for users
    $searchResults = $vk->users()->search($accessToken, [
        'q' => 'John Smith',
        'count' => 20,
        'fields' => ['photo_100', 'city', 'country'],
        'city' => 1, // Moscow
        'age_from' => 18,
        'age_to' => 30,
        'has_photo' => true
    ]);

    foreach ($searchResults['items'] as $user) {
        echo "Found: {$user['first_name']} {$user['last_name']}\n";
    }

} catch (VKExceptionsVKApiException $e) {
    error_log("API Error [{$e->getCode()}]: {$e->getMessage()}");
} catch (VKExceptionsVKClientException $e) {
    error_log("Client Error: {$e->getMessage()}");
}

```

--------------------------------

### Upload Video to VK using PHP

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Uploads a video file to VK with specified metadata and posts it to the user's wall. Requires the VK PHP SDK and a valid access token. It first retrieves an upload URL, then uploads the file, and finally posts a message with the video attachment.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token';

try {
    // Step 1: Initialize video upload and get upload URL
    $videoInfo = $vk->video()->save($accessToken, [
        'name' => 'My Awesome Video',
        'description' => 'This is a demonstration video uploaded via VK PHP SDK',
        'is_private' => 0, // Public video
        'wallpost' => 1, // Post to wall after upload
        'group_id' => 987654321 // Optional: upload to group
    ]);

    $uploadUrl = $videoInfo['upload_url'];
    $videoId = $videoInfo['video_id'];
    $ownerId = $videoInfo['owner_id'];

    echo "Upload URL obtained. Video ID: {$videoId}\n";

    // Step 2: Upload video file
    $videoPath = '/path/to/your/video.mp4';
    $uploadResponse = $vk->getRequest()->upload($uploadUrl, 'video_file', $videoPath);

    echo "Video uploaded successfully!\n";
    echo "Video attachment: video{$ownerId}_{$videoId}\n";
    echo "Note: Video is being processed by VK servers...\n";

    // Video will be processed on VK servers
    // You can use the video attachment in posts after processing
    $videoAttachment = "video{$ownerId}_{$videoId}";

    // Wait a bit for processing, then post with video
    sleep(30);

    $vk->wall()->post($accessToken, [
        'owner_id' => $ownerId,
        'message' => 'Check out my new video!',
        'attachments' => [$videoAttachment]
    ]);

    // Get video details
    $videos = $vk->video()->get($accessToken, [
        'owner_id' => $ownerId,
        'videos' => ["{$ownerId}_{$videoId}"]
    ]);

    $video = $videos['items'][0];
    echo "Video title: {$video['title']}\n";
    echo "Duration: {$video['duration']} seconds\n";
    echo "Views: {$video['views']}\n";

} catch (VKExceptionsVKApiException $e) {
    error_log("Video upload error: {$e->getMessage()}");
}

```

--------------------------------

### Upload Video File using VK API

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Shows how to upload a video file using the VK PHP SDK. This process includes obtaining a video upload server address and then uploading the file. Requires an access token and the video file path.

```php
$vk = new \VK\Client\VKApiClient();
$address = $vk->video()->save($access_token, [
    'name' => 'My video',
]);

$vk = new \VK\Client\VKApiClient();
$video = $vk->getRequest()->upload($address['upload_url'], 'video_file', 'video.mp4');
```

--------------------------------

### Community Access Key Authorization

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

This section explains how to obtain a community access key using the VK OAuth flow. It details the parameters required for the `getAuthorizeUrl` method and the expected format of the redirect URL with the access token fragment.

```APIDOC
## GET /oauth/authorize

### Description
Obtains a community access key for the VK application.

### Method
GET

### Endpoint
/oauth/authorize

### Parameters
#### Query Parameters
- **client_id** (int) - Required - Your application's Client ID.
- **redirect_uri** (string) - Required - The URL to redirect the user to after authorization.
- **display** (string) - Optional - The display mode for the authorization page (e.g., PAGE).
- **scope** (array) - Required - A list of permissions to request (e.g., VK\OAuth\Scopes\VKOAuthGroupScope::MESSAGES).
- **state** (string) - Optional - A string to maintain state between the request and callback.
- **group_ids** (array) - Required - A list of community IDs for which to obtain access.
- **response_type** (string) - Required - The type of response, typically VK\OAuth\VKOAuthResponseType::TOKEN for access token.

### Request Example
```php
$oauth = new \VK\OAuth\VKOAuth();
$client_id = 1234567;
$redirect_uri = 'https://example.com/vk';
$display = \VK\OAuth\VKOAuthDisplay::PAGE;
$scope = [\VK\OAuth\Scopes\VKOAuthGroupScope::MESSAGES];
$state = 'secret_state_code';
$groups_ids = [1, 2];

$browser_url = $oauth->getAuthorizeUrl(\\VK\\OAuth\\VKOAuthResponseType::TOKEN, $client_id, $redirect_uri, $display, $scope, $state, $groups_ids);
```

### Response
#### Success Response (302 Redirect)
The user's browser will be redirected to the specified `redirect_uri` with the access token as a fragment parameter.

#### Response Example (Fragment)
```sh
https://example.com#access_token_XXXXXX=533bacf01e11f55b536a565b57531ad114461ae8736d6506a3&expires_in=86400
```

**Notes:**
- `access_token_XXXXXX` is the community access token where XXXXXX is the community identifier.
- `expires_in` is the lifetime of the access token in seconds.

```

--------------------------------

### Exchange Code for Access Token

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

After obtaining an authorization code via the redirect, use this method to exchange it for an access token. This requires the client ID, client secret, redirect URI, and the received code.

```php
$oauth = new VKOAuthVKOAuth();
$client_id = 1234567;
$client_secret = 'SDAScasd'
$redirect_uri = 'https://example.com/vk';
$code = 'CODE';

$response = $oauth->getAccessToken($client_id, $client_secret, $redirect_uri, $code);
$access_token = $response['access_token'];
```

--------------------------------

### Manage VK Groups using PHP

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Provides functionalities to retrieve group information by ID or user ID, list group members, check membership status, and configure Long Poll settings. Requires the VK PHP SDK and a valid access token. Input parameters include group IDs, user IDs, and desired fields for retrieval.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token';

try {
    // Get group information
    $groups = $vk->groups()->getById($accessToken, [
        'group_ids' => ['apiclub', '1'], // Can use screen_name or ID
        'fields' => ['members_count', 'description', 'status', 'city', 'country', 'place']
    ]);

    foreach ($groups as $group) {
        echo "Group: {$group['name']}\n";
        echo "Members: {$group['members_count']}\n";
        echo "Description: {$group['description']}\n";
    }

    // Get user's groups
    $userGroups = $vk->groups()->get($accessToken, [
        'user_id' => 123456,
        'extended' => 1,
        'fields' => ['members_count', 'activity'],
        'count' => 50
    ]);

    foreach ($userGroups['items'] as $group) {
        echo "{$group['name']} - {$group['members_count']} members\n";
    }

    // Get group members
    $members = $vk->groups()->getMembers($accessToken, [
        'group_id' => 1,
        'count' => 100,
        'fields' => ['photo_100', 'city', 'online'],
        'sort' => 'id_asc'
    ]);

    echo "Total members: {$members['count']}\n";
    foreach ($members['items'] as $member) {
        echo "Member: {$member['first_name']} {$member['last_name']}\n";
    }

    // Check if user is group member
    $isMember = $vk->groups()->isMember($accessToken, [
        'group_id' => '1',
        'user_id' => 123456
    ]);

    echo $isMember ? "User is a member\n" : "User is not a member\n";

    // Configure Long Poll settings for group
    $vk->groups()->setLongPollSettings($accessToken, [
        'group_id' => 987654321,
        'enabled' => 1,
        'api_version' => '5.199',
        'message_new' => 1,
        'message_reply' => 1,
        'message_edit' => 1,
        'wall_post_new' => 1,
        'wall_repost' => 1,
        'photo_new' => 1,
        'video_new' => 1,
        'group_join' => 1,
        'group_leave' => 1
    ]);

    echo "Long Poll configured successfully\n";

} catch (VKExceptionsVKApiException $e) {
    error_log("Groups API error: {$e->getMessage()}");
}

```

--------------------------------

### Video Save API

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

This endpoint retrieves a video upload server address. You can specify parameters like the video name before uploading the video file.

```APIDOC
## POST /api/video.save

### Description
Retrieves a server address for uploading video files. Allows specifying video details beforehand.

### Method
POST

### Endpoint
/api/video.save

### Parameters
#### Request Body
- **access_token** (string) - Required - User's access token.
- **name** (string) - Optional - The name of the video.

### Request Example
```php
$vk = new \VK\Client\VKApiClient();
$address = $vk->video()->save($access_token, [
    'name' => 'My video',
]);
```

### Response
#### Success Response (200)
- **response** (object) - An object containing the `upload_url` for the video.

#### Response Example
```json
{
  "response": {
    "upload_url": "https://video.vk.com/upload/your_unique_id/hash_value"
  }
}
```
```

--------------------------------

### OAuth 2.0 User Authorization - Authorization Code Flow in PHP

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Details the two-step process for OAuth 2.0 user authorization using the Authorization Code Flow in PHP. This flow is recommended for server-side applications to generate long-lived access tokens. It includes generating the authorization URL and handling the callback to exchange the authorization code for access and refresh tokens.

```php
<?php
use VK\OAuth\User\User;
use VK\OAuth\User\DTO\AuthorizeUrlParams;
use VK\OAuth\User\DTO\TokensParams;
use VK\OAuth\User\Scopes;

// Step 1: Generate authorization URL
$clientId = 1234567;
$clientSecret = 'your_client_secret';
$redirectUri = 'https://yourdomain.com/oauth/callback';
$state = bin2hex(random_bytes(16)); // Random state for CSRF protection
$verifier = bin2hex(random_bytes(43)); // PKCE code verifier

$oauth = new User();
$authParams = (new AuthorizeUrlParams(
    $clientId,
    $verifier,
    $redirectUri,
    $state
))->setScope([Scopes::EMAIL, Scopes::PHONE, Scopes::WALL, Scopes::FRIENDS]);

$authUrl = $oauth->getAuthorizeUrl($authParams);

// Redirect user to: $authUrl
// User will authorize and be redirected back to your redirect_uri

// Step 2: Handle callback and exchange code for tokens
// After redirect, you'll receive: code, device_id, and state parameters
$code = $_GET['code'];
$deviceId = $_GET['device_id'];
$receivedState = $_GET['state'];

// Verify state matches
if ($receivedState !== $state) {
    throw new Exception('Invalid state parameter - possible CSRF attack');
}

// Exchange authorization code for tokens
$tokenParams = new TokensParams($clientId, $verifier, $redirectUri, $code, $deviceId);
try {
    $tokens = $oauth->getTokens($tokenParams);

    $accessToken = $tokens['access_token'];   // Use for API requests
    $refreshToken = $tokens['refresh_token']; // Store securely for token refresh
    $idToken = $tokens['id_token'];           // JWT with user info
    $tokenType = $tokens['token_type'];       // "Bearer"

    // Store tokens securely (database, session, etc.)
    $_SESSION['vk_access_token'] = $accessToken;
    $_SESSION['vk_refresh_token'] = $refreshToken;

} catch (VK\Exceptions\VKOAuthException $e) {
    error_log("OAuth error: " . $e->getMessage());
    // Handle authorization error
}

```

--------------------------------

### Send Messages with VK PHP SDK

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Send private messages to users or group chats. Supports simple text messages, messages with keyboards, broadcast messages to multiple users, and messages with attachments. Includes error handling for API exceptions. Requires the 'messages' permission.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_group_access_token'; // Requires messages permission

try {
    // Send simple message to user
    $response = $vk->messages()->send($accessToken, [
        'user_id' => 123456,
        'message' => 'Hello! This is a message from our bot.',
        'random_id' => random_int(0, PHP_INT_MAX) // Required for deduplication
    ]);

    $messageId = $response;
    echo "Message sent! ID: {$messageId}
";

    // Send message with keyboard
    $keyboard = [
        'one_time' => false,
        'buttons' => [
            [
                ['action' => ['type' => 'text', 'label' => 'Button 1']],
                ['action' => ['type' => 'text', 'label' => 'Button 2']]
            ],
            [
                ['action' => ['type' => 'text', 'label' => 'Help', 'payload' => '{"command":"help"}']]
            ]
        ]
    ];

    $response = $vk->messages()->send($accessToken, [
        'peer_id' => 123456,
        'message' => 'Choose an option:',
        'keyboard' => json_encode($keyboard),
        'random_id' => random_int(0, PHP_INT_MAX)
    ]);

    // Send message to multiple users
    $userIds = [123456, 789012, 345678];
    foreach ($userIds as $userId) {
        $vk->messages()->send($accessToken, [
            'user_id' => $userId,
            'message' => 'Broadcast message to all users!',
            'random_id' => random_int(0, PHP_INT_MAX)
        ]);
    }

    // Send message with attachment
    $response = $vk->messages()->send($accessToken, [
        'user_id' => 123456,
        'message' => 'Check out this photo!',
        'attachment' => 'photo123456_789012345',
        'random_id' => random_int(0, PHP_INT_MAX)
    ]);

    // Get conversation history
    $history = $vk->messages()->getHistory($accessToken, [
        'user_id' => 123456,
        'count' => 20,
        'rev' => 0 // 0 for chronological order
    ]);

    foreach ($history['items'] as $message) {
        echo "From user {$message['from_id']}: {$message['text']}
";
    }

} catch (VKExceptionsApiVKApiMessagesDenySendException $e) {
    error_log("User denied messages from community");
} catch (VKExceptionsVKApiException $e) {
    error_log("Message error: {$e->getMessage()}");
}

```

--------------------------------

### PHP VK API Error Handling with Specific Exceptions

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

Handles various VK API errors by catching specific exception classes like VKApiAccessException, VKApiAuthException, and VKApiFloodException. It logs errors and provides user-friendly messages. Generic API and client exceptions are also caught.

```php
<?php
$vk = new VKClientVKApiClient();
$accessToken = 'your_access_token';

try {
    // Attempt API call
    $response = $vk->wall()->post($accessToken, [
        'owner_id' => 123456,
        'message' => 'Test post'
    ]);

    echo "Success! Post ID: {$response['post_id']}\n";

} catch (VKExceptionsApiVKApiAccessException $e) {
    // Access denied errors
    error_log("Access denied: {$e->getMessage()}");
    echo "Error: You don't have permission to perform this action.\n";

} catch (VKExceptionsApiVKApiAuthException $e) {
    // Authentication errors - token invalid or expired
    error_log("Auth error: {$e->getMessage()}");
    echo "Error: Authentication failed. Please login again.\n";
    // Redirect to OAuth flow

} catch (VKExceptionsApiVKApiFloodException $e) {
    // Rate limiting errors
    error_log("Flood control: {$e->getMessage()}");
    echo "Error: Too many requests. Please try again later.\n";
    sleep(5); // Wait before retry

} catch (VKExceptionsApiVKApiNotFoundException $e) {
    // Resource not found
    error_log("Not found: {$e->getMessage()}");
    echo "Error: The requested resource was not found.\n";

} catch (VKExceptionsApiVKApiWallAccessPostException $e) {
    // Specific wall access error
    error_log("Wall access denied: {$e->getMessage()}");
    echo "Error: Cannot post to this wall.\n";

} catch (VKExceptionsVKApiException $e) {
    // Generic API errors
    $errorCode = $e->getCode();
    $errorMessage = $e->getMessage();
    error_log("VK API Error [{$errorCode}]: {$errorMessage}");

    // Handle specific error codes
    switch ($errorCode) {
        case 5: // User authorization failed
            echo "Please re-authenticate\n";
            break;
        case 6: // Too many requests per second
            echo "Rate limited. Retrying...\n";
            sleep(1);
            break;
        case 10: // Internal server error
            echo "VK server error. Try again later.\n";
            break;
        case 14: // Captcha needed
            $captchaSid = $e->getCaptchaSid();
            $captchaImg = $e->getCaptchaImg();
            echo "Captcha required: {$captchaImg}\n";
            break;
        default:
            echo "API Error: {$errorMessage}\n";
    }

} catch (VKExceptionsVKClientException $e) {
    // Network or client-side errors
    error_log("Client error: {$e->getMessage()}");
    echo "Error: Network problem or invalid request.\n";

} catch (Exception $e) {
    // Catch-all for unexpected errors
    error_log("Unexpected error: {$e->getMessage()}");
    echo "An unexpected error occurred.\n";
}

```

--------------------------------

### PHP Function to Retry VK API Calls on Flood Exception

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

A helper function that wraps API calls in a loop to automatically retry them when a VKApiFloodException occurs. It allows configuring the maximum number of attempts and the delay between retries.

```php
// Helper function for retrying failed requests
function retryApiCall(callable $apiCall, $maxAttempts = 3, $delaySeconds = 2) {
    $attempt = 0;

    while ($attempt < $maxAttempts) {
        try {
            return $apiCall();
        } catch (VKExceptionsApiVKApiFloodException $e) {
            $attempt++;
            if ($attempt >= $maxAttempts) {
                throw $e;
            }
            error_log("Retry attempt {$attempt}/{$maxAttempts} after flood control");
            sleep($delaySeconds);
        }
    }
}

// Usage example
$result = retryApiCall(function() use ($vk, $accessToken) {
    return $vk->users()->get($accessToken, ['user_ids' => [1]]);
});

```

--------------------------------

### PHP Long Poll Event Listener for VK Groups

Source: https://context7.com/vkcom/vk-php-sdk/llms.txt

This PHP code snippet demonstrates how to create a listener for VK Long Poll events. It utilizes the VK PHP SDK to handle incoming events such as new messages, wall posts, and group join requests. The handler can be extended to implement custom logic for each event, including sending replies back to users. Dependencies include the VK PHP SDK (via Composer) and a valid group access token.

```php
<?php
require 'vendor/autoload.php';

// Create custom handler by extending VKCallbackApiHandler
class MyBotHandler extends \VK\CallbackApi\VKCallbackApiHandler {

    public function messageNew($group_id, $secret, $object) {
        $message = $object['message'];
        $userId = $message['from_id'];
        $text = $message['text'];

        echo "New message from user {$userId}: {$text}\n";

        // Respond to specific commands
        if (strtolower($text) === 'hello') {
            $this->sendReply($userId, "Hello! How can I help you?");
        } elseif (strtolower($text) === 'help') {
            $this->sendReply($userId, "Available commands: hello, help, info");
        }
    }

    public function wallPostNew($group_id, $secret, $object) {
        echo "New wall post in group {$group_id}\n";
        echo "Post text: {$object['text']}\n";
        echo "Posted by: {$object['from_id']}\n";
    }

    public function groupJoin($group_id, $secret, $object) {
        $userId = $object['user_id'];
        echo "User {$userId} joined the group!\n";
        // Welcome new member
        $this->sendReply($userId, "Welcome to our community! 👋");
    }

    public function photoNew($group_id, $secret, $object) {
        echo "New photo uploaded: {$object['id']}\n";
    }

    private function sendReply($userId, $message) {
        global $vk, $accessToken;
        try {
            $vk->messages()->send($accessToken, [
                'user_id' => $userId,
                'message' => $message,
                'random_id' => random_int(0, PHP_INT_MAX)
            ]);
        } catch (Exception $e) {
            error_log("Failed to send reply: {$e->getMessage()}");
        }
    }
}

// Initialize VK client and Long Poll executor
$vk = new \VK\Client\VKApiClient();
$accessToken = 'your_group_access_token';
$groupId = 987654321;
$wait = 25; // Seconds to wait for events

$handler = new MyBotHandler();
$executor = new \VK\CallbackApi\VKCallbackApiLongPollExecutor(
    $vk,
    $accessToken,
    $groupId,
    $handler,
    $wait
);

// Start listening (runs indefinitely)
echo "Bot started. Listening for events...\n";
try {
    while (true) {
        $lastTs = $executor->listen();
        echo "Processed events up to timestamp: {$lastTs}\n";

        // Optional: add small delay to prevent high CPU usage
        usleep(100000); // 0.1 second
    }
} catch (\VK\Exceptions\VKApiException $e) {
    error_log("Long Poll error: {$e->getMessage()}");
} catch (Exception $e) {
    error_log("Fatal error: {$e->getMessage()}");
}

```

--------------------------------

### VK Long Poll Event Handling with Custom Handler

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Defines a custom handler class by extending VKCallbackApiHandler to process specific events like new messages or wall posts. Event data is passed as an object to the corresponding methods.

```php
class CallbackApiMyHandler extends \VK\CallbackApi\VKCallbackApiHandler {
    public function messageNew($object) {
        echo 'New message: ' . $object['body'];
    }
    
    public function wallPostNew($object) {
        echo 'New wall post: ' . $object['text'];
    }
}
```

--------------------------------

### Configure Long Poll Settings for VK Group

Source: https://github.com/vkcom/vk-php-sdk/blob/master/README.md

Enables Long Poll for a VK group and specifies which events to track. Requires an access token and group ID. Events like 'message_new' and 'wall_post_new' can be enabled.

```php
$vk = new \VK\Client\VKApiClient();
$vk->groups()->setLongPollSettings($access_token, [
  'group_id'      => 159895463,
  'enabled'       => 1,
  'message_new'   => 1,
  'wall_post_new' => 1,
]);
```
Tokens:
Raw