# REST APIs & Upload
StreamTube adheres to the WordPress REST API standards, facilitating seamless integration and extension with third-party applications. Developers can leverage the REST API to build custom applications.
For comprehensive instructions, please refer to the official WordPress REST API Handbook:
***
1. [API Endpoints](#authentication)
2. [Authentication](#authentication)
1. [Application Passwords](#bearer-token)
2. [Bearer Access Token](#bearer-token)
3. [List Videos](#list-videos)
4. [Get Video](#get-video)
5. [Update Video](#id-6.-delete-video)
6. [Delete Video](#id-6.-delete-video)
7. [Upload Video](#upload-video)
***
#### 1. API Endpoints
* Blog Posts:
* Videos:
* Upload:
***
#### 2. Authentication
***
#### 2.a) Application Passwords:
To learn more about Basic Authentication, visits
**Create An App Password**
* Go to your frontend Dashboard.
* Navigate to the **Account** section.
* Select **App Password**.
* In the "**App name**" field, enter a descriptive name for the application you'll be using this password with.
* Click the "**Add New Application Password**" button.
* Save the generated password in a secure location. It will not be displayed again.
**Manage App Passwords via REST API**
* Retrieve a Application Password
* Create a Application Password
* Delete a Application Password
***
#### 2.b) Bearer Access Token
You can also authenticate using a Bearer Token.
Install and activate the "JWT Authentication for WP REST API" plugin: Refer to the plugin page for more details.
**Generate an Access Token:**
* Access your frontend Dashboard.
* Go to **Account** and select **Access Token**.
* Enter your password and click "**Create a token**" button.
* Remember to save the generated token in a safe place, as it will not be shown again.
Generate an Access Token from Dashboard
```
// Generate an access token using command line
$ curl -X POST "https://domain.com.com/wp-json/jwt-auth/v1/token" \
-H "Content-Type: application/json" \
-d '{"username": "my_user", "password": "my_wp_password"}'
```
***
#### 3. List Videos
**GET**
General Arguments:
***
#### 4. Get Video
**GET** [https://domain.com/wp-json/wp/v2/video/{videoId}](https://domain.com/wp-json/wp/v2/video)
General Arguments:
***
#### 5. Update Video
**POST** [https://domain.com/wp-json/wp/v2/video/{videoId}](https://domain.com/wp-json/wp/v2/video)
General Arguments
***
#### 6. Delete Video
**DELETE** [https://domain.com/wp-json/wp/v2/video/{videoId}](https://domain.com/wp-json/wp/v2/video)
General Arguments
***
#### 7. Upload Video
**POST**
**Bash**
```
// Upload with App Password Authentication (Basic Auth)
$ curl 'https://domain.com/wp-json/streamtube/v1/upload' \
--user 'my_user:my_app_password' \
--form "file=@path/file.mp4;type=video/mp4"
```
```
// Upload with Bearer Token Authentication
$ curl 'https://domain.com/wp-json/streamtube/v1/upload' \
--header 'Authorization: Bearer YOUR_JWT_TOKEN' \
--form "file=@path/file.mp4;type=video/mp4"
```
**Python**
```python
import requests
url = 'https://domain.com/wp-json/streamtube/v1/upload'
headers = {'Authorization': 'Bearer YOUR_JWT_TOKEN'}
files = {'file': ('file.mp4', open('path/file.mp4', 'rb'), 'video/mp4')}
try:
response = requests.post(url, headers=headers, files=files)
response.raise_for_status() # Raise an exception for bad status codes
print(response.text) # Or response.json() if the response is JSON
except requests.exceptions.RequestException as e:
print(f"Error: {e}")
```
**Javascript**
```javascript
const url = 'https://domain.com/wp-json/streamtube/v1/upload';
const token = 'YOUR_JWT_TOKEN';
const filePath = 'path/file.mp4'; // Adapt to your environment
async function uploadFile() {
try {
const formData = new FormData();
const response = await fetch(filePath);
const blob = await response.blob();
formData.append('file', blob, 'file.mp4');
const uploadResponse = await fetch(url, {
method: 'POST',
headers: {
Authorization: `Bearer ${token}`,
},
body: formData,
});
if (!uploadResponse.ok) {
throw new Error(`HTTP error! status: ${uploadResponse.status}`);
}
const data = await uploadResponse.text(); // or uploadResponse.json()
console.log(data);
} catch (error) {
console.error('Error:', error);
}
}
uploadFile();
```
**PHP**
```php
curl_file_create($filePath, 'video/mp4', 'file.mp4'),
));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
if (curl_errno($ch)) {
echo 'Curl error: ' . curl_error($ch);
} else {
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($http_code >= 200 && $http_code < 300) {
echo $response; // or json_decode($response, true);
} else {
echo "HTTP error: " . $http_code . "\n";
}
}
curl_close($ch);
?>
```
**Go**
```go
package main
import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
)
func main() {
url := "https://domain.com/wp-json/streamtube/v1/upload"
token := "YOUR_JWT_TOKEN"
filePath := "path/file.mp4"
file, err := os.Open(filePath)
if err != nil {
fmt.Println("Error opening file:", err)
return
}
defer file.Close()
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("file", "file.mp4")
if err != nil {
fmt.Println("Error creating form file:", err)
return
}
_, err = io.Copy(part, file)
err = writer.Close()
if err != nil {
fmt.Println("Error closing writer:", err)
return
}
req, err := http.NewRequest("POST", url, body)
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", writer.FormDataContentType())
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
bodyResp, err := io.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response:", err)
return
}
fmt.Println(string(bodyResp))
}
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://phpface.gitbook.io/streamtube/for-developers/rest-apis-and-upload.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
