Begin by creating a Google Cloud Platform (GCP) project if you haven't already. Enable the Firestore API for your project. Set up a Firestore database in either Native or Datastore mode, depending on your requirements. Note down the project ID and service account credentials, as you'll need these to interact with Firestore.

To access the Pexels API, you need an API key. Sign up at the Pexels website and navigate to the API section to generate your API key. This key will authorize your requests to the Pexels API.

Install the necessary development tools and libraries. You’ll need a programming environment like Node.js or Python. For Node.js, install Firebase Admin SDK (`npm install firebase-admin`) and an HTTP client like Axios (`npm install axios`). For Python, use libraries like `requests` for HTTP requests and `firebase-admin` for Firestore interaction.

Write a script to make an HTTP GET request to the Pexels API. Use your API key to authenticate the request. Specify the endpoint and parameters to fetch the desired data, such as photos, videos, or collections. Parse the JSON response to extract the relevant data.

```javascript
const axios = require('axios');

const fetchPexelsData = async () => {
const response = await axios.get('https://api.pexels.com/v1/photos', {
headers: {
Authorization: 'YOUR_PEXELS_API_KEY'
}
});
return response.data;
};
```

Initialize the Firebase Admin SDK in your script to interact with Firestore. Use the service account credentials obtained from the Google Cloud Console to authenticate.

```javascript
const admin = require('firebase-admin');
const serviceAccount = require('./path/to/serviceAccountKey.json');

admin.initializeApp({
credential: admin.credential.cert(serviceAccount)
});

const db = admin.firestore();
```

Format the data retrieved from the Pexels API to fit the Firestore document model. Consider how you want to structure your collections and documents. Ensure that the data types align with Firestore’s supported data types.

```javascript
const transformData = (data) => {
return data.photos.map(photo => ({
id: photo.id,
url: photo.url,
photographer: photo.photographer,
src: photo.src
}));
};
```

Use Firestore’s API to write the transformed data into your database. Choose appropriate collection and document paths to store the data. Handle errors and ensure that data is written correctly.

```javascript
const uploadToFirestore = async (photos) => {
const collectionRef = db.collection('pexelsPhotos');
for (const photo of photos) {
await collectionRef.doc(String(photo.id)).set(photo);
}
};

const main = async () => {
const pexelsData = await fetchPexelsData();
const transformedData = transformData(pexelsData);
await uploadToFirestore(transformedData);
};

main().catch(console.error);
```

By following these steps, you can successfully move data from the Pexels API to Google Firestore without using third-party connectors or integrations.