Removing Google unverified warning from personal project that uses the YouTube Data API

I am making a personal project that is not intended for public use. The project uses YouTube Data API v3. When I run the code, I see this warning:

> Task :ApiExample.main()
2020-09-25 14:52:25.740:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
2020-09-25 14:52:25.748:INFO::jetty-6.1.26
2020-09-25 14:52:25.796:INFO::Started SocketConnector@localhost:*****
Please open the following address in your browser:

I'm not sure what a localhost is and what the number represents, so I have replaced it with asterisks just in case it is supposed to be private.

When I open the link that follows, I am prompted to login to my Google account, after which I am shown this screen.

>This app isn't verified
This app hasn't been verified by Google yet. Only proceed if you know and trust the developer.

>If you’re the developer, submit a verification request to remove this screen. Learn more

> Google hasn't reviewed this app yet and can't confirm it's authentic. Unverified apps may pose a threat to your personal data. Learn more

I don't want to go through the entire verification process, because this isn't really an "app", per se. I'm just playing around with the API to learn how it works. Is there any way to bypass the verification process so that I can practice with the API without having to have Google approve a random project that I made? I don’t want to have to login online every time I use the program.

Edit

If I understand the comments correctly, the reason why I have to login every time I run the program is because I am using OAuth 2.0 when I only need to be using an API key since my program does not need access to my particular account. This was strongly implied on the authorization credentials page, which states:

>This API supports two types of credentials. Create whichever credentials are appropriate for your project:

>OAuth 2.0: Whenever your application requests private user data, it must send an OAuth 2.0 token along with the request. Your application first sends a client ID and, possibly, a client secret to obtain a token. You can generate OAuth 2.0 credentials for web applications, service accounts, or installed applications.

>API keys: A request that does not provide an OAuth 2.0 token must send an API key. The key identifies your project and provides API access, quota, and reports.

When I first created the project, I only intended to use an API key, and not OAuth 2.0 credentials because of what it says on that page. However, the Java quickstart does not give an option to use only an API key. Rather, the demo code shown there looks like this:

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

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
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.ChannelListResponse;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Arrays;
import java.util.Collection;

public class ApiExample {
    private static final String CLIENT_SECRETS= "client_secret.json";
    private static final Collection<String> SCOPES =
        Arrays.asList("https://www.googleapis.com/auth/youtube.readonly");

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

    /**
     * Create an authorized Credential object.
     *
     * @return an authorized Credential object.
     * @throws IOException
     */
    public static Credential authorize(final NetHttpTransport httpTransport) throws IOException {
        // Load client secrets.
        InputStream in = ApiExample.class.getResourceAsStream(CLIENT_SECRETS);
        GoogleClientSecrets clientSecrets =
          GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));
        // Build flow and trigger user authorization request.
        GoogleAuthorizationCodeFlow flow =
            new GoogleAuthorizationCodeFlow.Builder(httpTransport, JSON_FACTORY, clientSecrets, SCOPES)
            .build();
        Credential credential =
            new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
        return credential;
    }

    /**
     * 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();
        Credential credential = authorize(httpTransport);
        return new YouTube.Builder(httpTransport, JSON_FACTORY, credential)
            .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 and execute the API request
        YouTube.Channels.List request = youtubeService.channels()
            .list("snippet,contentDetails,statistics");
        ChannelListResponse response = request.setId("UC_x5XG1OV2P6uZZ5FSM9Ttw").execute();
        System.out.println(response);
    }
}

In the above code sample, client_secret.json is the JSON file that contains my OAuth 2.0 credentials. So, with all this having been said, I believe I can restate my question as follows: How do I write the above code sample using just an API key, and not a JSON file that contains my OAuth 2.0 credentials?

Edit

I've replaced my main method with the following:

public static void main(String[] args)
        throws GeneralSecurityException, IOException, GoogleJsonResponseException {
    Properties properties = new Properties();
    try {
        InputStream in = ApiExample.class.getResourceAsStream("/" + "youtube.properties");
        properties.load(in);

    } catch (IOException e) {
        System.err.println("There was an error reading " + "youtube.properties" + ": " + e.getCause()
                + " : " + e.getMessage());
        System.exit(1);
    }
    YouTube youtubeService = getService();
    // Define and execute the API request
    YouTube.Channels.List request = youtubeService.channels()
            .list("snippet,contentDetails,statistics");
    String apiKey = properties.getProperty("youtube.apikey");
    request.setKey(apiKey);
    ChannelListResponse response = request.setId("UC_x5XG1OV2P6uZZ5FSM9Ttw").execute();
    System.out.println(response);

}

However I still have to log in whenever I run the code.

Edit

Whoops, I was still calling the getService() method in the above code sample. The following works:

YouTube youtubeService = new YouTube.Builder(new NetHttpTransport(), new JacksonFactory(), new HttpRequestInitializer() {
            public void initialize(HttpRequest request) throws IOException {
            }
        }).setApplicationName(APPLICATION_NAME).build();

The issue has been resolved.

If you only intend to use the Channels.list API endpoint for to obtain public channel meta-data, then there's definitely no need to employ OAuth 2.0 authorization (and the implied one-time authentication).

The YouTube.Channels.list class has this method, that allows you to set the API key provided (as private data) by Google (via its cloud console):

> setKey
>
> public YouTube.Channels.List setKey(java.lang.String key)
>
> Description copied from class: YouTubeRequest
> API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
>
> Overrides:
> setKey in class YouTubeRequest<ChannelListResponse>

You may look at the sample source file GeolocationSearch.java from Google for to see setKey in action:

// Set your developer key from the {{ Google Cloud Console }} for
// non-authenticated requests. See:
// {{ https://cloud.google.com/console }}
String apiKey = properties.getProperty("youtube.apikey");
search.setKey(apiKey);

In your case, the above piece of code will work entirely the same way. Only that you'll have to apply setKey to your request (object) variable.