did you check the Youtube API on google developers guide, check the Video Upload section? you will find something like this:

VideoEntry newEntry = new VideoEntry();

YouTubeMediaGroup mg = newEntry.getOrCreateMediaGroup();
mg.setTitle(new MediaTitle());
mg.getTitle().setPlainTextContent("My Test Movie");
mg.addCategory(new MediaCategory(YouTubeNamespace.CATEGORY_SCHEME, "Autos"));
mg.setKeywords(new MediaKeywords());
mg.getKeywords().addKeyword("cars");
mg.getKeywords().addKeyword("funny");
mg.setDescription(new MediaDescription());
mg.getDescription().setPlainTextContent("My description");
mg.setPrivate(false);
mg.addCategory(new MediaCategory(YouTubeNamespace.DEVELOPER_TAG_SCHEME, "mydevtag"));
mg.addCategory(new MediaCategory(YouTubeNamespace.DEVELOPER_TAG_SCHEME, "anotherdevtag"));

newEntry.setGeoCoordinates(new GeoRssWhere(37.0,-122.0));
// alternatively, one could specify just a descriptive string
// newEntry.setLocation("Mountain View, CA");

MediaFileSource ms = new MediaFileSource(new File("file.mov"), "video/quicktime");
newEntry.setMediaSource(ms);

String uploadUrl =
  "http://uploads.gdata.youtube.com/feeds/api/users/default/uploads";

VideoEntry createdEntry = service.insert(new URL(uploadUrl), newEntry);

Probably you will the successfully authenticate before you can upload teh video like:

YouTubeService service = new YouTubeService(clientID, developer_key);

Hope this helps

This shows how to upload a video using an HTTP request.

There are code snippets that are also available in java (and kotlin is pretty similar).

In order to see how to upload a video, go to https://developers.google.com/youtube/v3/code_samples/code_snippets, select Videos under Resource and insert under method.

If you then click on Show code and select JAVA at the top, you will get this example code:

/**
 * Sample Java code for youtube.videos.insert
 * See instructions for running these code samples locally:
 * https://developers.google.com/explorer-help/guides/code_samples#java
 */

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.InputStreamContent;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;

import com.google.api.services.youtube.YouTube;
import com.google.api.services.youtube.model.Video;
import com.google.api.services.youtube.model.VideoSnippet;
import com.google.api.services.youtube.model.VideoStatus;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;
import java.util.Collection;

public class ApiExample {
    // You need to set this value for your code to compile.
    // For example: ... DEVELOPER_KEY = "YOUR ACTUAL KEY";
    private static final String DEVELOPER_KEY = "YOUR_API_KEY";

    private static final String APPLICATION_NAME = "API code samples";
    private static final JsonFactory JSON_FACTORY = JacksonFactory.getDefaultInstance();

    /**
     * Build and return an authorized API client service.
     *
     * @return an authorized API client service
     * @throws GeneralSecurityException, IOException
     */
    public static YouTube getService() throws GeneralSecurityException, IOException {
        final NetHttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
        return new YouTube.Builder(httpTransport, JSON_FACTORY, null)
            .setApplicationName(APPLICATION_NAME)
            .build();
    }

    /**
     * Call function to create API service object. Define and
     * execute API request. Print API response.
     *
     * @throws GeneralSecurityException, IOException, GoogleJsonResponseException
     */
    public static void main(String[] args)
        throws GeneralSecurityException, IOException, GoogleJsonResponseException {
        YouTube youtubeService = getService();
        
        // Define the Video object, which will be uploaded as the request body.
        Video video = new Video();
        
        // Add the snippet object property to the Video object.
        VideoSnippet snippet = new VideoSnippet();
        snippet.setCategoryId("22");
        snippet.setDescription("Description of uploaded video.");
        snippet.setTitle("Test video upload.");
        video.setSnippet(snippet);
        
        // Add the status object property to the Video object.
        VideoStatus status = new VideoStatus();
        status.setPrivacyStatus("private");
        video.setStatus(status);

        // TODO: For this request to work, you must replace "YOUR_FILE"
        //       with a pointer to the actual file you are uploading.
        //       The maximum file size for this operation is 137438953472.
        File mediaFile = new File("YOUR_FILE");
        InputStreamContent mediaContent =
            new InputStreamContent("application/octet-stream",
                new BufferedInputStream(new FileInputStream(mediaFile)));
        mediaContent.setLength(mediaFile.length());

        // Define and execute the API request
        YouTube.Videos.Insert request = youtubeService.videos()
            .insert("snippet,status", video, mediaContent);
        Video response = request.setKey(DEVELOPER_KEY).execute();
        System.out.println(response);
    }
}

You can also look at another example java code for uploading a video to YouTube on GitHub.

Note that you will need to make a few changes to this:

Under Android, you don't have a main. You will need to (1) put that code whereever you need to and you might want to (2) do it asynchronously.

When using Kotlin, you will also (3) need to modify the syntax accordingly.

Based on your requirements, it seems you're looking for a way to use the YouTube API for personal use without going through the extensive review process required for public applications. Unfortunately, there isn't a built-in way to restrict API access to local use only in the YouTube API.

However there is be a workaround for your needs:

1. You can use the YouTube Data API v3 with OAuth 2.0 authentication for your personal Google account.
2. This method allows you to create a project in the Google Developers Console and use the API without going through the verification process, as long as you're the only user.

Here's how you can set this up:

1. Go to the Google Developers Console.
2. Create a new project.
3. Enable the YouTube Data API v3 for your project.
4. Create OAuth 2.0 credentials (Client ID and Client Secret) for a desktop application.
5. Use these credentials in your application.

First of all you need a method to handle OAuth 2.0 authentication then you just need to add a method for uploading videos.

Here's a example how you can implement a YouTubeAPI class in python to include a video upload method:

from googleapiclient.http import MediaFileUpload

class YouTubeAPI:

    def upload_video(self, file_path, title, description, category_id, privacy_status='private'):
        body = {
            'snippet': {
                'title': title,
                'description': description,
                'categoryId': category_id
            },
            'status': {
                'privacyStatus': privacy_status
            }
        }

        media = MediaFileUpload(file_path, resumable=True)

        request = self.youtube.videos().insert(
            part='snippet,status',
            body=body,
            media_body=media
        )

        response = request.execute()
        return response

Then you can add a new endpoint to handle video uploads. This setup allows you to use the YouTube API for personal use without going through the extensive review process. However, keep in mind:

1. The API quota is limited for unverified apps.
2. This should only be used for personal projects where you're the only user.
3. You'll need to handle the OAuth flow manually

Include the necessary packages:

google-api-python-client
google-auth-oauthlib
google-auth-httplib2

as long as you're the only user of the application this solution can allow you to upload videos programmatically while avoiding the extensive review process. Good luck :)