# 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))
}
```
