First, you need to access the Google PageSpeed Insights API to fetch performance data. Sign up for a Google Cloud account if you haven't already, and create a project. In the Google Cloud Console, enable the PageSpeed Insights API, and create an API key that you'll use to authenticate your requests.

Use a programming language like Python to send HTTP requests to the PageSpeed Insights API. The API requires parameters such as the URL of the page you want to analyze and the strategy (mobile or desktop). Parse the JSON response to extract the necessary performance metrics.

```python
import requests

api_key = 'YOUR_API_KEY'
url = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed'
params = {
'url': 'https://example.com',
'strategy': 'mobile',
'key': api_key
}

response = requests.get(url, params=params)
data = response.json()
```

Once you have the data, transform and organize it into a format suitable for loading into Snowflake. For instance, you might want to extract specific metrics like First Contentful Paint, Speed Index, and Time to Interactive, and store them in a structured format like a CSV or JSON file.

```python
import json

metrics = {
'URL': params['url'],
'First Contentful Paint': data['lighthouseResult']['audits']['first-contentful-paint']['displayValue'],
'Speed Index': data['lighthouseResult']['audits']['speed-index']['displayValue'],
'Time to Interactive': data['lighthouseResult']['audits']['interactive']['displayValue']
}

with open('pagespeed_data.json', 'w') as f:
json.dump(metrics, f)
```

Create a Snowflake account if you do not have one, and set up your environment. Create a warehouse and a database to store your PageSpeed Insights data. Use the Snowflake web interface or SnowSQL CLI to create a suitable table schema that will hold your data.

```sql
CREATE TABLE pagespeed_metrics (
url STRING,
first_contentful_paint STRING,
speed_index STRING,
time_to_interactive STRING
);
```

Use SnowSQL, the command-line interface provided by Snowflake, to load the data into your Snowflake table. First, upload the JSON or CSV file to a Snowflake stage, then use the `COPY INTO` command to load the data into your table.

```bash
snowsql -a -u -p -q "PUT file://path/to/pagespeed_data.json @%pagespeed_metrics"
```

```sql
COPY INTO pagespeed_metrics
FROM @%pagespeed_metrics/pagespeed_data.json
FILE_FORMAT = (TYPE = 'JSON');
```

After loading the data, verify its integrity by querying the Snowflake table. Ensure the data matches what you extracted from the PageSpeed Insights API. Perform checks to confirm the accuracy of the metrics and the structure of the table.

```sql
SELECT * FROM pagespeed_metrics;
```

To keep your data up-to-date, consider automating the process using a scheduling tool like cron (for Linux) or Task Scheduler (for Windows). Write a script that fetches, transforms, and loads the data into Snowflake at regular intervals, such as daily or weekly.

```bash
# Example cron job that runs the script every day at midnight
0 0 * * * /usr/bin/python3 /path/to/your_script.py
```

This guide provides a direct method to move data from Google PageSpeed Insights to Snowflake without relying on third-party connectors or integrations, using only API requests, data transformation, and Snowflake's native capabilities.