Video upload

Normal

small_t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

thumbnail_t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

t02cw29ka-u04jtt0jcg3-549047173ac2-512.jpeg

Artem Matinian

Tutorials

When considering building your project or website, you went through several languages and eventually settled for PHP. It’s a great language, easy to pick up and it can help you build your own project within minutes. 

&nbsp;
 

However, with all the great things that come with PHP, there are also some challenges. For example, how do you upload videos with PHP, while also making sure that users have a good experience while uploading and streaming these videos?

&nbsp;
 

You are probably already aware of some of these challenges, otherwise, you wouldn’t be reading this article. 😄

## How to upload a video: A step-by-step guide

For the sake of this example, let’s stick to the basics and build a very simple video uploader on an existing PHP server. The workflow is quite simple:

&nbsp;
 
1. Your PHP server shows the user a file selector.
2. The file selector lets the user pick a file from their device.
3. The selected file is delivered in a multi-part form to the PHP server.
4. The PHP server then uploads the video to [api.video](http://api.video/) for transcoding, hosting, and delivery.

&nbsp;
 
Now, let’s start with creating a simple PHP server . You can skip the Preparation if you already have PHP implementation set up.

## Preparation

### 1. Sign up to api.video for free

[Let’s create a free account with api.video.](https://dashboard.api.video/register) We’ll handle the video transcoding, hosting, and delivery for your viewers.

### 2. Install PHP

You can skip this step if you have PHP already installed. If not, you can find instructions in the [PHP official installation guide](https://www.php.net/manual/en/install.php).
&nbsp;
 
Alternatively, you can use MAMP to create a local server environment. Visit the [official MAMP website](https://www.mamp.info/en/windows/) for more information.

### 3. Install Composer

In order to get all the respective libraries for the use case we are building here, you’ll need a package manager. Let’s install Composer, a simple package manager for PHP. Check out the instructions on how to download and install Composer [here](https://getcomposer.org/doc/00-intro.md).

### 4. Create a PHP server folder

1. Let’s a new folder for the app. Choose any name for the project.
2. Create a new file called `server.php` inside that folder.

&nbsp;
 

Now that you’re all set, let’s begin with the process.

## Create the video uploader frontend

We’ll start by setting up the PHP server and the multipart form.

&nbsp;
 

1. The server will receive a request: we will check that the request type is [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET).
2. We will also check that and that the URL that the user is hitting is `/`. This means that the user landed on the main page.
3. The multipart type form is necessary if the user uploads a file through the form. Give the form a `name` and an `id`. We’ll use it later on.


&nbsp;
 
Copy this script into your `server.php` file:

Now let’s do a quick test run! 

&nbsp;
 

1. Open your `cmd` or `terminal` 
2. Navigate to the PHP folder you've stored the project in

3. Run the PHP server (this command will run the file server.php on your local machine on port 8000)

4. Navigate to localhost:8000 on your browser

large_Screenshot 2023-11-13 at 21.30.51.png

medium_Screenshot 2023-11-13 at 21.30.51.png

small_Screenshot 2023-11-13 at 21.30.51.png

thumbnail_Screenshot 2023-11-13 at 21.30.51.png

Screenshot 2023-11-13 at 21.30.51.png

large_Screenshot 2023-11-13 at 21.31.45.png

medium_Screenshot 2023-11-13 at 21.31.45.png

small_Screenshot 2023-11-13 at 21.31.45.png

thumbnail_Screenshot 2023-11-13 at 21.31.45.png

Screenshot 2023-11-13 at 21.31.45.png

If this is the first time you are working with PHP, then congratulations - you’ve just created your first PHP website!

## Create the backend

Now that the frontend part is done, let’s set up the backend. The backend’s job is to:

&nbsp;
 

1. Receive the videos from the frontend
2. Send the videos over to [api.video](http://api.video) in order to make sure your users have the best experience while uploading and streaming.

### Configure file uploads in PHP

Let’s enable file uploading, and configure the size of the files your users can upload. To configure this, we need to find the `php.ini` in your implementation.

&nbsp;
 

1. In your terminal, type:

This should give you the following output:

Navigate to the php.ini file, and change or add these following values:

You can choose smaller or larger values than 150M. Now let’s save it.

### Receive the video files

Before the file is sent to [api.video](http://api.video), it has to be stored locally. This is only temporary and you can delete the file after your server uploads it to api.video.

This is the workflow we’ll follow:

&nbsp;
 

1. First, we create a new “endpoint” that accepts `POST` requests to an `/upload` endpoint. Remember our multipart form? It is actually already set up to submit the file to `/upload`. Multipart form are set to `POST` by default. So, we will create an `if` statement to handle that.
2. Once a `POST` request will hit this endpoint, it will pass in the file. We pick it up and save it in a `/uploads/` directory in the PHP server folder. Let’s create the `/uploads` folder inside the PHP project folder:

Now edit the server.php file and add this code we just described:

With this code, we take the file name and store it in the `/uploads` folder with the [move_uploaded_file](https://www.php.net/manual/en/function.move-uploaded-file.php) function.

&nbsp;
 

Awesome! Now we have a cool server that can ask the user for a file. Let’s run the server again to test it. Start the PHP server again:

Navigate to localhost:8000 and this time, select a file to upload and click on Upload Video. After the file is uploaded, you should see it in the /uploads folder in your PHP server project.

thumbnail_Screenshot 2023-11-13 at 21.56.23.png

Screenshot 2023-11-13 at 21.56.23.png

## Upload the videos to api.video

You’re more than half-way done, great job! 

&nbsp;
 

Now, you only need to add a small thing to all the mix. After uploading the video to your PHP server, you can just give your users public access to this file, and let them play it, right? 

&nbsp;
 

Not quite. There’s a lot of science behind delivering a video. While it can be delivered directly from your PHP server, your users may see issues with the playback: long loading times, and even issues with loading the video at all. It comes down to transcoding the video to different qualities, hosting the video on a scalable environment and having a good enough CDN that will deliver the video fast. You also need a capable player that will have all the options that your users need, without having to pour vast amount of money and resources into expensive services.

&nbsp;
 

With around ten simple lines of code, you can make sure your users have the best experience while watching and uploading their videos.

### Add api.video to your code

Now that you have an api.video account, grab your [API key from the dashboard](https://dashboard.api.video/apikeys) and paste it in as the value of `$apiKey` in the `server.php`:

Notice that we are also initializing the api.video client library. So, we need to run the Composer in order to get these libraries inside the server’s main folder.

&nbsp;
 

1. Let’s make sure that Composer is installed.
2. Open the terminal again and run these commands:

3. After the packages are installed, run the PHP server again:

## Deliver the videos

Let’s try upload a new video in your `localhost` environment. 

&nbsp;
 

Since we implemented api.video in the code, uploading a video will give you a response with different parameters, including the assets. The assets are actually the video you just uploaded in different streaming formats (HLS and mp4). You’ll notice that you also have an `iframe` parameter, which is your video embedded in an `iframe`. Let’s display the video as soon as it is ready. We’ll add a bit more code to retrieve the status of the video, so once it’s ready, we can display it in the `iframe`.

&nbsp;
 

Let’s add a status request to our code:

We’ve added a `while` loop that checks the video status. If the video is playable (which means that api.video finished transcoding it), we can take the `iframe` asset, embed it, and display it to the users. This part is handled in echo `$response->getAssets()->getIframe()`.

&nbsp;
 

Now save your code, upload a new video via `localhost`, and enjoy the show! 😊

How to upload a video file in PHP

large_Upload with PHP.jpg

medium_Upload with PHP.jpg

small_Upload with PHP.jpg

thumbnail_Upload with PHP.jpg

Upload with PHP.jpg

screen-shot-2021-01-26-at-11-48-47-am.jpg

Erikka Innes

Product updates

api.video is proud to announce a brand new PHP client for our video API. Our old PHP SDK will be deprecated. You can continue to use it, but it will no longer be updated. Instead, the new PHP client will stay up-to-date with all our new feature releases. 

Like our other clients, it's autogenerated and handles authentication for you, including refreshing your access token when needed. It also handles paginated responses and chunked uploads for large files. A unique aspect of this client is that it is also [PSR-18](https://www.php-fig.org/psr/psr-18/) compliant. This makes it more reusable as it reduces the number of dependencies and lowers the likelihood of version conflicts.

You can install our new client with:
```composer require api-video/php-api-client```

And the entire client is available in the GitHub repository here: 
[https://github.com/apivideo/php-api-client](https://github.com/apivideo/php-api-client)

In addition to the documentation we have at docs.api.video, you can find client-specific documentation in the GitHub repository. If you are looking up parameters, we recommend that you refer to the content provided in the client respository first. Some information may be tweaked to make it easier to create and use the client. There's a docs page for each part of the API here: [https://github.com/apivideo/php-api-client/tree/main/docs/Api](https://github.com/apivideo/php-api-client/tree/main/docs/Api) 

PHP is fast, flexible and widely used in web applications. We hope you'll enjoy using our new client to code your video projects! 



api.video announces a new PHP client

large_php.png

medium_php.png

small_php.png

thumbnail_php.png

php.png

Delegated Upload

Python

api.video offers delegated uploads! For uploading video, this means you can create an authorization token, and choose how long your authorization token lasts, anywhere from a few seconds (this might be a bit extreme) to forever. The value in using a delegated upload token is that you don't expose your api key, authorization token, or refresh token. All you need is the delegated token you create. You can create tokens for users if you want them to be able to do uploads and you can delete tokens at any time if they are compromised, or no longer needed.

## How does a delegated video upload differ from a regular video upload?
Glad you asked! There are a few differences. If you use the regular upload endpoint, you must: 
* Use the authorization token you retrieve with your API key.
* Create a video container with any details you want to provide about your video.
* Upload your video into the video container you created. 

If you use the delegated video upload endpoint, you must:
* Create a delegated token for use with the delegated upload endpoint.
* Upload your video - api.video creates the container for you. You don't provide more detail than the file title. 

You can use the delegated token for as many uploads as you like, or delete the token if you don't need it any longer. You can add details about your video later using the update a video endpoint. 

## The Authorization Flow for Delegated Uploads 
You use your api key to authenticate and get a token. Then, you use your token to request a delegated token. The delegated token may be used for uploads through the delegated upload endpoint only. What's great about it, is if you want you can create and give this token to someone else to make uploads with. You can give the delegated token an expiry time, or let it last forever. Don't worry, you can also delete tokens if one of then is compromised, or if you don't need it any longer. 

## What's in this tutorial
We'll go over a code sample for: 

* Uploading a Video Under 200 MiB with a Delegated Token
* Uploading a Video 200 MiB or greater with a Delegated Token 

## Delegated upload for video under 200 MiB
<a title="RRZEicons, CC BY-SA 3.0 https://creativecommons.org/licenses/by-sa/, via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File:Upload.svg"><img width="256" alt="Upload" src="https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Upload.svg/256px-Upload.svg.png"></a><br>
If you have a video under 200 MiB, upload is fairly straightforward. Here's the code sample: 

### Walkthrough - Delegated Upload for a Video Under 200 MiB

The start of this you're probably familiar with by now if you've tried the other tutorials. You're going to add the requests library, grab your API key (you can use sandbox or production, the difference being that for sandbox all video will be watermarked), and authenticate so you can get a token. 

### Retrieve a delegated token for video upload

Use your access token to set up the bearer auth header you'll need to retrieve a delegated token. For the body of your request, you need to add a value for the **ttl** field. TTL stands for time-to-live. In this walkthrough, we are setting ttl equal to 0, which means the token will last forever. You can set the token to other lengths of time in seconds. 

After you've set the payload, send your request, then retrieve the delegated token from the response. Armed with your shiny new token, you're ready to upload your video! 

### Upload your video that's under 200 MiB

To upload with the token, you need to send with the application/vnd.api.video+json header. Then the token is sent as a query field. The payload will be your video file, opened in binary. The title of your uploaded file will be the same name as the title of the file you send. 

## Delegated upload for video 200 MiB and bigger

This section shows you how to complete a chunked video upload. Because some of the code is the same as what was in the walkthrough directly preceding this one, we'll post the code sample, then focus in on what's different. 

After you get your delegated token, there are a few differences in the code to be aware of. Our read_in_chunks function stays the same, but for the upload function, notice that we set a videoId variable. This is because we are going to need to retrieve the videoId. 

Because api.video creates the video container for you on a delegated upload, you don't know what videoId you're uploading to. This is fine if you're uploading a complete video, but if you're sending your video in chunks, you need to tell the server what video container you want to send the chunks to. When you send your first upload request for a chunked video, include the Content-Range header (the only header you'll need) and then retrieve the response from your request. 

Get the videoId from the response, and in subsequent requests, you include the videoId. Like so: 

As you can see here, we use a few different tools from the requests library to make the subsequent requests. Your token for authenticating is a query parameter. The videoId goes in the body of your request. And you attach your file chunk as a file. 

If you change the name of the file in your requests (the spot where it says "file name here") then your file will be named to match that. Use the same title in both places for "file name here" in the code. The file you open for upload won't be referenced, because in a chunked upload, the request doesn't get the name of the file, it just has a chunk of the file attached each time. So it's a little different than a regular upload. 

There's only one step left for your chunked upload, and that's to use the function: 

Ta-da! You've done it! You've uploaded a video or a chunked video... or at least read all about it. In future posts, we'll go over how to manage your tokens. 

## Posts you may also like...
* [Upload a Video with the api.video API Using a Public URL (Python)](https://api.video/blog/tutorials/upload-a-video-with-the-api-video-api-using-a-public-url-python/)
* [Upload a Video From Your Computer with the api.video API (Python)](https://api.video/blog/tutorials/upload-a-video-from-your-computer-with-the-api-video-api-python/)
* [Upload a Big Video File Using Python](https://api.video/blog/tutorials/upload-a-big-video-file-using-python/)

Delegated uploads for videos large and small

medium_uploadbar.jpg

small_uploadbar.jpg

thumbnail_uploadbar.jpg

uploadbar.jpg

Android

thibault_rond.png

Thibault Beyou

Kotlin

This article is about how to easily add an upload mechanism from [api.video](https://api.video) to your Android application with a specific component from the Android API client and the Android video uploader called the UploadService.

In your Android application, if you use the `upload` API with the [Android API client](https://github.com/apivideo/api.video-android-client) or the [Android video uploader](https://github.com/apivideo/api.video-android-uploader), you might have noticed that it is not a piece of cake. Here are the main reasons why:

- **NetworkOnMainThreadException**: on the modern Android version, you must not perform network calls on the main thread; otherwise your application will crash with an `android.os.NetworkOnMainThreadException` . As `upload` is a synchronous API, you must call it from a Thread.
- **Background**: performing long-running tasks in your Activity is forbidden, so if the user sends your application to the background while an upload is in progress, the system might kill the process at some point and the file will never be uploaded
- **Upload management**: with the `upload` API you can't just cancel a running upload, you can't efficiently perform multiple uploads unless you have implemented it in a separate Thread.

At some point, you will have to implement the `upload` API in a dedicated Thread or an [Executor](https://developer.android.com/reference/java/util/concurrent/Executor) or, even better with [Kotlin coroutines](https://kotlinlang.org/docs/coroutines-overview.html). It might be a lengthy task if you are not familiar with these components. A Thread won't be able to handle uploads when the application is in the background. If you are already familiar with Android Services, you know that implementing a Service is a good solution for this kind of issue. Let's have a deeper look at this component.

## 1. Android Service

According to Android [documentation](https://developer.android.com/guide/components/services):

"A [Service](https://developer.android.com/reference/android/app/Service) is an [application component](https://developer.android.com/guide/components/fundamentals#Components) that can **perform long-running operations in the background**. It does not provide a user interface. Once started, a **service might continue running for some time, even after the user switches to another application**. Additionally, a component can bind to a service to interact with it and perform interprocess communication (IPC). For example, **a service can handle network transactions**, play music, perform file I/O, or interact with a content provider from the background."

Nice!

There is another interesting part about the service:

"When a service is running, it can notify the user of events using [snack bar notifications](https://developer.android.com/develop/ui/views/notifications/snackbar)
 or [status bar notifications](https://developer.android.com/develop/ui/views/notifications/build-notification)."

For a type of service called Foreground Service, your service must display a notification. The notification can look like a text, but it can also be an audio player.

When you start looking for Service notifications, they are everywhere.

untitled.png

Why am I talking about notifications? Because it would be nice to have a notification showing the upload's progress. Right? Like this:

untitled-1.png

So, if your application requires uploading files to [api.video](https://api.video/), the solution would be to call the `upload` API from an Android Service.

I have an excellent news for you: **the [Android API client](https://github.com/apivideo/api.video-android-client) and the [Android video uploader](https://github.com/apivideo/api.video-android-uploader) comes with a fully customizable Service whose purpose is to upload files, called UploadService.**

## 2. api.video UploadService

The UploadService is the easiest way to upload video files to [api.video](http://api.video) on Android.
It supports:

- upload with video id
- upload with upload token
- progressive upload
- progress notification of the upload of the current file
- success notification
- error notification
- multiple uploads: it uploads files from an internal queue
- cancel the upload of a specific file or all files

Here is a small video to show how it’s used in the [‣ example](https://github.com/apivideo/api.video-android-uploader/tree/main/examples/service):

### UploadService notification customization

The UploadService comes with many levels of notification customization:

- Notification color and icon
- Notification messages
- Notification itself. You can choose not to display progress or to display the name of the file currently being uploaded. For example, notifications could have a Stop button.

To customize the UploadService, the first step is to extend the UploadService:

If you have a closer look at the UploadService constructor, you will notice that you can change the notification icon and color with:

To have more controls over the notification, you can override `onUploadProgressNotification`, `onUploadErrorNotification`, `onUploadStartedNotification`, `onUploadCancelledNotification`, `onUploadSuccessNotification`, `onLastUploadNotification`.

There is a solution for each of your requirements!

### Implementation

As with every service, you have to declare it in the `AndroidManifest.xml`

As the UploadService is a Foreground Service (a special type of service), you also have to add:

Nice. We are almost done. You have to start it and bind it. Fortunately, there is a static API to simplify its usage:

As startService binds your application to the UploadService, you must call UploadService.unbindService when your application is put to background.

Once you have access to the service, you can call upload API for a video id

## Conclusion

With the UploadService, uploading a video to [api.video](http://api.video) has never been this easy! For a complete example with the UploadService, check out the [‣ example](https://github.com/apivideo/api.video-android-uploader/tree/main/examples/service).

And we're done! To start building right now, check out our **[docs](https://docs.api.video/)**
and **[sign up for a free account](https://dashboard.api.video/register)**

Upload videos on your Android app with an Android Service

large_blog-thibault-article.png

medium_blog-thibault-article.png

small_blog-thibault-article.png

thumbnail_blog-thibault-article.png

blog-thibault-article.png

How to easily upload videos on your Android app with an Android Service?

Video list

medium_screen-shot-2021-01-26-at-11-48-47-am.jpg

small_screen-shot-2021-01-26-at-11-48-47-am.jpg

thumbnail_screen-shot-2021-01-26-at-11-48-47-am.jpg

Today we'll learn how to grab video data from api.video, add it to a database, then use that information to create an infinite wall of videos that you can keep scrolling through.

large_infinitevideos.jpg

medium_infinitevideos.jpg

small_infinitevideos.jpg

thumbnail_infinitevideos.jpg

infinitevideos.jpg

For this project, we're going to also use Laravel 8. 

## Prerequisites

* api.video account - [Register here](https://dashboard.api.video/register)
* [Laravel 8](https://laravel.com/docs/8.x/installation) installed
* Project repository - [https://github.com/apivideo/api.video-php-client/tree/main/examples/laravel/infinite_scroll](https://github.com/apivideo/api.video-php-client/tree/main/examples/laravel/infinite_scroll)
* api.video [PHP client](https://github.com/apivideo/api.video-php-client) 
* Symfony HTTP client - `composer require symfony/http-client` 
* composer - [https://getcomposer.org/](https://getcomposer.org/)

## What you'll be doing
You have three tasks for this project: 
1. Retrieve your data from api.video
2. Add your data to your database
3. Set up your page to show the videos in an infinite scroll 

## Retrieve your data
You need to collect some data from api.video about the videos you're going to use. To keep it simple, for this walkthrough I'm just retrieving videos tagged 'holiday' and keeping the title, video ID, and MP4 link for each one. You can retain any information you might want to use or display, the most important thing is the MP4 link. 

For this part of the project, I didn't use Laravel 8, I just set up a php file with my code and used composer. 

After you run the code, you'll have a list of all videos from your account that you tagged **holiday** in a .csv file. Save the file, we'll use it for the next part of our project.

## Set up your project
Now it's time to set up our Laravel 8 project. We'll need this before we can do anything with our database. These instructions are for Macs.

1. Make a new project by opening a terminal in the place where you want to store your project by typing `laravel new holiday`. 

2. Install the api.video PHP client. `composer require api-video/php-api-client`

3. Install the Symfony HTTP client. `composer require symfony/http-client`

4. Go into your project and find the .env file. For the section that starts **DB_** delete every **DB_** item except for **DB_CONNECTION**. Set **DB_CONNECTION** to sqlite. `DB_CONNECTION=sqlite`

5. Create a database table for the .csv file we made. `php artisan make:migration create_holidays_table`

6. Go into your project in the database folder and open the migrations folder. There should be a .php file with a timestamp at the start followed by the name of the table you just created in the terminal. Open this file and paste in this code:

7. Migrate your new table. `php artisan:migrate` 

8. Now we're going to create two models. The first is for handling infinite scroll. `php artisan make:model Model/InfiniteScroll` 

9. After you've made this model, go find it in your project and paste in this code: 



10. The second model we're going to make is for setting up our Holidays table contents. `php artisan make:model Model/Holiday`

11. Navigate to your new Holiday model and paste in this code:



12. Let's create a seeder that we can use to populate our new table using our .csv file. `php artisan make:seeder HolidaySeeder` 

13. Take your .csv file and place in the data folder for your database. 

14. Go to the seeders folder and open your HolidaySeeder.php file. Paste in this code:

15. Now we can run our seeder! `php artisan db:seed --class=HolidaySeeder` This should populate your database with the information from your .csv file. We're ready to set up our page to display our video collection. 

## Display videos
In this section we'll set up routes, a controller, and the page that will display videos whose links are retrieved from our database. 

1. We're going to add a new route, but before we do that, navigate to RouteServiceProvider.php. Scroll down to the line that reads `protected $namespace = 'App\\Http\\Controllers';` - it's probably commented out. Remove the commenting so it is active again. 

2. Navigate to routes\web.php. Add a new route `
Route::get('/load-more-data', 'VideoController@InfiniteScroll' );`

3. Make a new controller. `php artisan make:controller VideoController` 

4. Navigate to Controllers and open your VideoController file. Paste in this code:

5. Now let's set up our blade file. Navigate to views and craete a new blade file called **holidayView.blade.php**. Open the new file and paste this in: 

6. If you don't have a **data.blade.php** file, create one in the same folder as your other blade files. Open **data.blade.php** and paste in this code: 

## Run your project

Open a terminal in your project and type `php artisan serve`. You should be able to see a list of scrolling videos! 

If you have any questions about this tutorial, or would like to share what you've built, please join our [community forum](https://community.api.video/). 

Create an infinite scrolling wall of videos with Laravel 8

Create an infinite scrolling wall of holiday videos with Laravel 8

large_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

medium_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

small_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

thumbnail_create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

create-an-infinite-scrolling-wall-of-holiday-videos-with-laravel-8.jpg

api.video offers a PHP client to make it easier for you to upload your videos. Today we'll walk through how to do this. You can always hop on over to the GitHub repository if you'd prefer to learn about the client that way too - [api.video PHP client](https://github.com/apivideo/php-api-client).

## Prerequisites

For this project, you'll need these things: 

* Composer - if you don't have it set up, go here to learn about it and get it installed - getcomposer.org
* An api.video account - you can sign up [here](https://dashboard.api.video/register).

## Installation

You'll need to install a few things using Composer:

* The api.video PHP client - `composer require api-video/php-api-client`
* Symfony HTTP client - `composer require symfony/http-client`
* nyholm/psr7 - `composer require nyholm/psr7`

You can type **composer update** to make sure everything is pulled into your project and configured. 

## Code sample

Here is the code sample for uploading a file. You need to change **'yourAPIkey'** to your key that you retrieve from the api.video dashboard after you create an account. Place the video you want to upload in the same folder as your code sample. For the sake of simplicity, this code sample hardcodes the title of the video - change **VIDEO_TO_UPLOAD.mp4** to the title of your video file.

### Import the client
In the first part of the code, you import the parts of the api.video PHP client you'll need. The client is more efficient when you import the endpoints you need for your code, instead of everything. You also need the HttpClient from Symfony for this implementation. So it will look like this:

## Initialize the client 
Next you initialize the client for use in your API calls. 

## Create your video payload 
The next part of the code includes a video creation payload. This is a cool part of the PHP client. You can add all the metadata you'd like for your video here. Later, you're able to update your code as well. Consult the [Create a video](https://docs.api.video/reference/api/Videos#create-a-video-object) endpoint in our API reference documentation for available parameters. You capitalize them when adding them into your payload. So title becomes `setTitle` as shown in the code sample. Any parameters in camel case that you want to use would change a bit. For example, the docs have mp4Support, but if you are using the PHP client, you would write it as `setMp4support`. 

When you send multiple parameters, the code would look like this: 

`$payload = (new VideoCreationPayload())
    ->setTitle('My cool video');
$payload->setTags(['tag 1', 'tag 2']);`

When you're done setting up your payload, then you use the client to send this information to api.video servers and create your video container.

## Upload the video
In the last part of the video, you retrieve the video ID for the container you made and upload your video into the container. You can only upload into a container once, but you can change its metadata later if you wish. You can see whether it worked by reading the echoed response in the terminal.

## Conclusion
Now you know the basics of uploading a video with the api.video PHP client! You can check whether your upload worked by going into your dashboard and looking in the videos section. You should see it there. If you get a note that it's still processing, give it a bit of time to get the video ready, especially for big videos. 

If you have any questions or suggestion, please share them on our [community forum](https://community.api.video/). If you haven't created your api.video account yet, you can do that in just a few moments by follwoing [this link](https://dashboard.api.video/register). Happy building! 

Upload a video with the api.video PHP client

small_denise-jans-lq6rcifgjou-unsplash.jpg

thumbnail_denise-jans-lq6rcifgjou-unsplash.jpg

denise-jans-lq6rcifgjou-unsplash.jpg

video create

The first step to displaying your video online is getting it uploaded. Today we'll go over how to upload a video using Laravel 8 with api.video's PHP Client. Before we dive in, let's go over what we'll be doing when we upload a video. 

Uploading a video is a two step process. First, we create a container for the video and retrieve the video ID. Then, we upload a video into the container by referencing the ID. You can only upload a video to a container once, but you can modify details about the video at any time after that. Our uploader will let you add a title, description and list whether you want to have the video be public or private and whether you want to offer an MP4 link of the video for download. 

## What you'll need 
To get started, make sure you have these things:

* Account with api.video - you can sign up [here](https://dashboard.api.video/register)
* Laravel 8 - you can use other versions, but some things work differently
* NPM and node.js - you install these when you set up Laravel 
* Composer - you'll need this installed 
* [api.video PHP client](https://github.com/apivideo/php-api-client)
* Project repository - [https://github.com/apivideo/php-api-client/tree/main/examples/laravel/video_upload](https://github.com/apivideo/php-api-client/tree/main/examples/laravel/video_upload)

You can also review the API reference documentation for the endpoints used in this project: 
* [Create a video](https://docs.api.video/reference/api/Videos#create-a-video-object)
* [Upload a video](https://docs.api.video/reference/api/Videos#upload-a-video)

## Create your project
The first thing you'll need is a Laravel 8 project to work with. Here's what I did:

1. In a terminal make a new project by typing: **laravel new fileuploader** or similar project name.
2. Open your project folder, you'll need to install a few things.  
3. You'll need to add the api.video PHP client, so at the terminal type: **composer require api-video/php-api-client** 
4. You'll also need the symfony http client, at the terminal type: 
**composer require symfony/http-client**
5. And the last thing to add is nyholm/psr7:
**composer require nyholm/psr7**

You can type **composer update** to make sure everything is pulled in to your project and configured.
 
## Create a controller
We will need a controller for our video uploader, so let's go ahead and do that now. In the terminal in your project folder type: 

**php artisan make:controller UploadController** 

This will automatically create what we need to start building the controller. 

## Set up the home page with an upload form
For this walkthrough, we're using the home page to create an upload form. So in your views folder, go into **home.blade.php** and create the form. I selected to allow the user to add basic details about their project. I'm also using bootstrap, so the basic form looks like this: 

Image of upload form showing available fields

large_viduploadphp.png

medium_viduploadphp.png

small_viduploadphp.png

thumbnail_viduploadphp.png

viduploadphp.png

And here is the code that creates this form: 

We pull in the bootstrap details up top under the Scripts and Styles sections. Then for our form, we have all the form data sent in a POST request to the '/upload' route. (We'll need to create that route in a moment.) 

The form is straightforward - we list the type of data as text for the name of the file and the description of the file. For choosing whether the file will be public or offer an MP4 for download, we use a radio button, so the type is radio. For the video, we choose type file and then we set up our submit button. Bootstrap styles everything for us, so we're all set here. Now we need to handle the route. 

## Set up the /upload route
Open your **web.php** file and add a new route: 

**Route::post('/upload', 'UploadController@upload');** 

This route indicates that when submit is clicked in the form, it should go to /upload and carry out the upload instructions listed for the UploadController. 

We don't have that set up yet, so let's do that next. Also, the other routes are added into the project, you can see everything if you download the repository.

## Set up your UploadController
Our controller takes the details provided by the form, then uploads the content to api.video. Behind the scenes, we're going to need our api.video API key, so let's make sure we handle it securely. 

1. Go to your .env file. In the top section, you'll see items to do with your app. At the bottom of the list of items beginning **APP_** you'll see **APP_APIVIDEO=yourapikey**. Replace **yourapikey** with your key (retrieve it from your api.video dashboard). Don't add quotes. 
2. Open **RouteServiceProvider.php**.
3. In the file, take the commenting **\\** off of the line **protected $namespace = 'App\\Http\\Controllers';**. This returns the use of the automatic namespace, which is handy.
4. Open **UploadController.php**. 
5. Add this code: 


In our code, we set up the api.video client and collect the information from the request object that comes in from the form. We check if the data for the radio buttons is set and if it is, we add it to our payload for upload. Then we send the data and redirect the user to a page that says 'Success!' 

## Conclusion
These are the basics for uploading a video to api.video. You can try using different styles or set ups if you want to allow users to add more metadata on upload. If you have any questions or suggestions, please share them on our [community forum](https://community.api.video/). Thanks for reading! 



Upload a video with Laravel

Laravel is a great framework for building web applications. It does a lot of the heavy lifting for you, so you can focus your development efforts on the more unique elements of your application. Because there are multiple versions of Laravel and many of the packages you'll use with it have their own updates, it can sometimes get tricky to troubleshoot. There are many troubleshooting suggestions online, and this quick article aims to help sift those for the best tips. 

## Check your version of Laravel
One issue you will encounter is matching your version of Laravel to the advice you find online. This guide may work for other versions of Laravel, but is intended for Laravel 8. When troubleshooting, make sure you are conscious of what version you have and what version the tips you find are for.

## Bootstrap isn't working in my Laravel project
You must properly install Bootstrap for your Laravel project in order to add it to your files. If you find that Bootstrap styling isn't appearing on your HTML pages as expected, this section may be for you.

### How to install Bootstrap 4 for Laravel
To install Bootstrap 4 for your Laravel project, you do these things: 

1. At the command line, type `composer require laravel/ui`.
2. At the command line, type `php artisan ui bootstrap` if you just want Bootstrap for your project but don't plan to do any authentication. If you want to handle authentication in your project with bootstrap, then type `php artisan ui bootstrap --auth`. 
3. You'll also need to make sure npm is installed, so at the command line, type `npm install`.
4. Finally, at the command line run `npm run dev`.  

Some problems that might arise are having packages that aren't up to date, or issues with installing Laravel Mix. You can search online for how to handle packages that aren't up to date if there's a special issue. For the Laravel Mix issue, simply run `npm run dev` again. It often solves the issue.

### How to add Bootstrap 4 to your blade files 
To add Bootstrap 4 into your **blade.php** files, you use mustache quotes {{}} to reference the Bootstrap content you'll need. It looks like this: 

You may see the choice where you just reference a link to a public distribution, but blade files work differently. You need to use the mustache quotes version to add the files.

### Bootstrap still isn't working 
You'll see a note on installation that you don't have the most recent version of popperjs. If you want to update that to see if it corrects your issue, you can use the following command: 

`npm i @popperjs/core` 

## I don't see the changes I made to SASS and JS
If you don't see changes implemented in your application after updating something in SASS or JS files, the issue might be that you didn't run `npm run dev` again. Every time you change content here, you must use this command. If you don't want to do that and want to continually see your changes while you're making them, you can use `npm run watch`. This command will start regularly checking your files and recompiling every time it detects new changes. 

## I made changes to my application and they're not reflected on my server
If you made changes that are not just updates to the views, you may need to restart your server. You can do that like this: 

1. Press **Control + C** at the same time.
2. Type in the terminal in your project folder `php artisan serve`. 

## I installed a new library 
If you install a new library with Composer, you need to make sure you pull in all the new changes that causes. In the terminal type: 

`composer update` 

## I made changes to my database schema 
If you change your database schema or add something new, you need to run a migration. This is pretty simple, type: 

`php artisan migrate:fresh`

## My application isn't accessing my public folder correctly
To make sure your application accesses your public folder, which is where you'll often store assets, you need to create symbolic links for your application: 

`php artisan storage:link` 

## I'm still not sure why I can't see changes I made
If you get stuck, an easy thing to try is: 

`php artisan config:clear` - this clears your cache file. If you corrected something, but the cache isn't cleared, you might not be able to see your update. 

## The route I want isn't displaying
The order of routes in your **web.php** file matters! If you put routes that include variables first, it can mess up the flow of your application. Try to put concrete routes first, and then routes with flexible components after. 

## My controllers aren't found
In Laravel 8, the automatic namespace is turned off. If you want the same functionality as earlier versions of Laravel back, go to **RouteServiceProvider.php** and make it so `protected $namespace = 'App\\Http\\Controllers';` is no longer commented out.

## Conclusion 
When working with Laravel, there are lots of small details to remember. Updating and refreshing various aspects of your application can help correct a lot of problems you may encounter. If you want to try building something with api.video and Laravel, check out our post [Create your own version of Instagram using api.video and Laravel](https://api.video/blog/tutorials/create-your-own-version-of-instagram-using-api-video-and-laravel/).

Troubleshooting tips for your Laravel 8 project

medium_laravel8logo.png

small_laravel8logo.png

thumbnail_laravel8logo.png

laravel8logo.png

If you've ever wanted to take the time to learn how to build your own social media platform, this tutorial will get you started. Using the incredible [Laravel PHP framework tutorial](https://youtube.com/watch?v=lmtZ5yENzgE) from Victor Gonzalez, you can set up the basics for Instagram. However, his tutorial doesn't include video support. That's the tweak I'm providing today with this tutorial. 

If you want a complete version of Instagram, things you'll need to add yourself are: 
* More robust population for a person's page when it opens, for example linking to their profile instead of typing the number (which you'll know since there won't be many users when you set it up) to go to your profile or someone else's. 
* Ability to delete images and videos. 
* Search capability. 
* Algorithm for what to prioritize showing someone in their feed if there's lots of followers. 
* More robust database. 
* Move email out of test mode to actual email that's sent. 

Let's get started! 

## Installation 

For this project, you should be familiar with Laravel already, or willing to go through Victor's 4 hour tutorial to learn everything you'll need. Make sure you have these things ready:

* Composer - [https://getcomposer.org/](https://getcomposer.org/)
* Node.js - [https://nodejs.org/en/](https://nodejs.org/en/) 
* NPM - this is installed for you with Node.js 
* Laravel - [https://laravel.com/docs/8.x](https://laravel.com/docs/8.x) - this project uses 

To get the tutorial version of the code to work with, go to [https://github.com/coderstape/freeCodeGram](https://github.com/coderstape/freeCodeGram). If you want the code with the api.video tweaks included, and the tutorial completely put together, then go here: [https://github.com/apivideo/freeCodeGram](https://github.com/apivideo/freeCodeGram).

The next part of installation will require you to clone the github repository and then configure the project. There is a great walkthrough here: [How to Setup a Laravel Project You Cloned from Github.com](https://devmarketer.io/learn/setup-laravel-project-cloned-github-com/). There are some steps you won't need, the steps you need to follow are: 1, 2, 4, 5 (I recommend not using yarn), 6, 7, 8, 9 and 10. 

For step 8, this project uses a flat SQLite file for the database. To set this up, go into your project and type: 

```vim database/database.sqlite``` 

After it's created, save it without typing anything into the file. 

Then go to step 9, and make sure the information is filled out appropriately for the database (it should be). The correct set up is just to have DB_CONNECTION=sqlite. There should be no other DB_ items listed. 

Follow step 10. You're done with the walkthrough! There's just a couple more configuration things to do. 

### Authentication 

You'll need to go into php artisan and run the ui:auth command: 

```php artisan ui:auth``` 

### Storage 

You will need to go into freeCodeGram/storage/public and add an uploads folder. 

You may need to run the storage:link command as well: 

```php artisan storage:link``` 


### Set up your php.ini file 

If you want to handle videos that are 10 MB or more, you have to change the settings for what you can and can't upload. To do this, check the status and location of your file first: 

```php --ini``` 

This will bring back the location of the file, in the line: 
```Configuration File (php.ini) Path: /etc```  
or something similar. 

It'll also bring back the line: 
```Loaded Configuration File:``` 
with details after it. The details will either list the configuration file that's loaded, or it will show that there isn't one at all. 

It's recommended that you use a virtual environment like homestead or similar. 

**If you don't have a php.ini file**

You need to add one. An easy way to do that is to use the available default. The command would look like this if you use a virtual environment:
```cp /etc/php.ini/default /etc/php.ini``` 

If you add it and don't have a virtual environment, you may be denied installation privileges unless you use sudo to install. The command would look like this: 
```sudo cp /etc/php.ini/default /etc/php.ini``` 

Then provide your credentials to complete installation. 

Next, you'll need to go into the file to modify it. If you're in a virtual environment, you won't need sudo, but otherwise you may need sudo included in the command to make the modifications. Type:
```sudo nano /etc/php.ini```

Leave sudo off for virtual environments, or if you're able to leave it off. Once in the php.ini file, you need to look for two variables: 
* upload_max_filesize
* post_max_size 

Don't make these too big, or it will cause you problems, but you can increase **upload_max_filesize** up to 20M and **post_max_size** can be increased to 21M. **post_max_size** is the size of your video file plus anything else you're sending in the form with the video. In our case, a caption, so not too much extra data. 

Save your file when you're done making the changes. 

## Set up .env file
You're going to use api.video, so you'll want to add your API key to your .env file. Open the file and where it says APP_APIVIDEO=yourkeyhere, remove yourkeyhere and put your key instead. You don't need to add quotes to show it's a string. You can find your API key in your dashboard here: https://my.api.video after you log in. If you need a new account, then click **Get Started** to sign up.

## What we'll be doing
The project is designed to teach you many of the key features of Laravel. It shows you how to store images, and then retrieve them with the help of an image repository and a database containing details about each image that can be used for retrieval. We are going to tweak things so that when you upload a video, it's sent to api.video. Then an embed link is stored in your database. This information is pulled from the database and displayed in your profile feed in an iframe. 

You'll need to have these things:

* api.video account
* api.video PHP client - [https://github.com/apivideo/php-api-client](https://github.com/apivideo/php-api-client)

The client can be installed by going into your project and typing the command:
```composer require api-video/php-api-client```

Make sure you also have the symfony http-client:
``` composer require symfony/http-client```

Run `composer update` to make sure everything ends up in your project.

You can then add the API as needed. We're going to modify the following files in the project: 

* PostsController.php
* posts/index.blade.php
* posts/show.blade.php
* profiles/index.blade.php

Everything is already set up for you in the repository. This walkthrough just shows you the modifications. The big change is setting things up so you can accept videos as well as images. It's limited to .mp4 and .mov files. The way the demo works before tweaks, is you upload an image and store it in storage/app/public. Then you reference it in a table in your database and retrieve images for displays as needed. 

We change things so that you can upload a video to api.video, then store a link to the mp4 in the database. When you retrieve a link, you'll check if it starts with http or not. If it doesn't, it's an image file in the storage/app/public folder. If it does, it's a video. 

What follows are the code samples for the different files. 

## PostsController.php
This controller handles everything to do with posts, from creating to displaying to storing them. We're going to modify the store() function. The code sample shows everything added into the file - you'll also need the rest of the file as it's set up. I've just pulled out the relevant section for our discussion.

Here, we're modifying the code for 'image'. We check 'image' to see if it has a .mp4 or .mov extension. If so, we run validation checking it that's to do with video. If everything checks out with the file, we send a request to api.video to upload a new video. We create a video container and upload our file into the container. Then we retrieve the embed link for the mp4 and send that path to be saved in the database for posts. Finally, we return the profile page, where the new post will be displayed. 

## posts/index.blade.php
For this section, inside the @foreach statement we update the display tags to handle image or video, depending on what we retrieve from our database.

Here we can see that if we have a link that starts 'http' we choose to display with an iframe because we know it will be a video. If we have a link that starts with anything else, we know it's an image and display with an image tag. 

## posts/show.blade.php
When we show a post, we want to make sure we display it with an iframe for a video, and an img tag for an image. 

Here, using an @if statement in blade, we set up a way to handle a post if it's video or if it's an image. Videos only use half the space of an image.

## profiles/index.blade.php
This is more of the same tweak. We want to be able to handle and display an image or a video properly. The code looks about the same:

## More tweaks 
There's a lot more you can add to this project. You can make it so you can navigate to your profile without having to know what number you are. You could consider learning to add a search bar, so you can hunt for users. You can add tagging and ways to display pictures that match certain tags. There's a lot of ways to build on what we have here, but this will get you started! 

Create your version of Instagram using api.video and Laravel

thumbnail_apividstagram-1.png

apividstagram-1.png

Create your own version of Instagram using api.video and Laravel

Video update

This script is part of a collection of scripts from Hervé Pita that help with bulk video uploads. Everything is available in our [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository on Github. In each part of this series, we'll walk through how to set up one of the scripts. What you'll find includes:

* [Ingest Videos from Google Drive](https://api.video/blog/tutorials/helpful-php-scripts-upload-videos-from-google-drive-to-api-video/) - You can transfer all your videos from a folder in Google Drive to your api.video account with this CLI script.
* [Ingest Videos from an FTP Server](https://api.video/blog/tutorials/helpful-php-scripts-pt-2-upload-videos-from-an-ftp-server/) - Transfer all your videos from the FTP server of your choice to your api.video account.
* [Export All Your Video Data to .csv](https://api.video/blog/tutorials/helpful-php-scripts-pt-3-export-all-your-video-details-to-a-csv/) - With this script you can grab details about each video in your api.video account and gather it in one .csv spreadsheet.
* [Update Metadata for api.video Videos Using CSV](https://api.video/blog/tutorials/helpful-php-scripts-pt-4-update-metadata-for-api-video-videos-using-csv/) - You can update your metadata in bulk with this script.
* [Update Video Settings in Bulk Without a CSV File](https://api.video/blog/tutorials/helpful-php-scripts-pt-5-bulk-update-without-a-csv-file/) - Update videos to all be public or private or offer an mp4 download or disable an mp4 download.

Today we're going to learn how to use the script that lets you do a bulk update without a CSV file. Rather than choosing custom fields, these are preset. You'll be able to quickly update your videos to all:
* Be public 
* Be private
* Support an mp4 download
* Not support an mp4 download

## Prerequisites

For this project you'll need:

* PHP 5.4 or greater with the command-line interface (CLI) and JSON extension installed
* The [Composer](https://getcomposer.org/) dependency management tool (or another way to manage your dependency management). See the Composer website for installation options.
* A GitHub account
* An api.video [account](https://my.api.video)
* Your API key for either production or sandbox

## Installation

1. Navigate to the [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository.
2. Click **Code** and from the drop-down click **Download ZIP**. (You can also install from the CLI if you prefer.)
3. Put the contents of your new .zip file in a folder you want to work from.
4. Navigate to the folder containing the contents of your zip file in the terminal.
5. In the terminal, type ```composer require api-video/php-sdk```

## Try the Script

1. In the terminal, type ```php bulk_scripts.php```
2. You're asked what environment you want to use, prod or sandbox (p or s). Choose **p**. 
3. Provide your API key. Make sure it matches the environment choice you made in the last step. You can get your key by navigating to [my.api.video](https://my.api.video) and copying the appropriate key.
4. Next, you choose what operation to apply to all your videos. The options are private - this makes all your videos private. public - this makes all your videos public. mp4on - this makes all videos offer an mp4 download. mp4off - this makes all videos disable the option of an mp4 download. 
5. The script runs and when it's done, you can check to see the settings are updated. If you made a mistake, you can bulk update again to correct, or if you need to change only some videos, try the script that lets you update some files that you list in a .tsv - [Update Metadata for api.video Videos Using CSV](https://api.video/blog/tutorials/helpful-php-scripts-pt-4-update-metadata-for-api-video-videos-using-csv/)

And that's it for today! 

PHP Scripts: Update Video Settings in Bulk Without  CSV File

large_pat-whelen-xsswba4rb6e-unsplash.jpg

medium_pat-whelen-xsswba4rb6e-unsplash.jpg

small_pat-whelen-xsswba4rb6e-unsplash.jpg

thumbnail_pat-whelen-xsswba4rb6e-unsplash.jpg

pat-whelen-xsswba4rb6e-unsplash.jpg

Helpful PHP Scripts Pt 5: Update Video Settings in Bulk Without a CSV File

This script is part of a collection of scripts from Hervé Pita that help with bulk video uploads. Everything is available in our [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository on Github. In each part of this series, we'll walk through how to set up one of the scripts. What you'll find includes:

* [Ingest Videos from Google Drive](https://api.video/blog/tutorials/helpful-php-scripts-upload-videos-from-google-drive-to-api-video/) - You can transfer all your videos from a folder in Google Drive to your api.video account with this CLI script.
* [Ingest Videos from an FTP Server](https://api.video/blog/tutorials/helpful-php-scripts-pt-2-upload-videos-from-an-ftp-server/) - Transfer all your videos from the FTP server of your choice to your api.video account.
* [Export All Your Video Data to .csv](https://api.video/blog/tutorials/helpful-php-scripts-pt-3-export-all-your-video-details-to-a-csv/) - With this script you can grab details about each video in your api.video account and gather it in one .csv spreadsheet.
* [Update Metadata for api.video Videos Using CSV](https://api.video/blog/tutorials/helpful-php-scripts-pt-4-update-metadata-for-api-video-videos-using-csv/) - You can update your metadata in bulk with this script.
* [Update Video Settings in Bulk Without a CSV File](https://api.video/blog/tutorials/helpful-php-scripts-pt-5-bulk-update-without-a-csv-file/) - Update videos to all be public or private or offer an mp4 download or disable an mp4 download.

Today we're going to learn how to use the script for updating custom you choose using a CSV file. This will allow you to make updates in bulk, so be careful! With great power comes great responsibility. 

## Prerequisities

For this project you'll need:
* PHP 5.4 or greater with the command-line interface (CLI) and JSON extension installed
* The [Composer](https://getcomposer.org) dependency management tool (or another way to manage your dependency management). See the Composer website for installation options.
* A GitHub account
* An api.video [account](https://my.api.video)
* Your API key for either production or sandbox (the script will update video metadata based on your API key - if you choose production your production videos are updated, if you choose sandbox, your sandbox videos are updated)

## Installation

1. Navigate to the Helpful PHP Scripts repository.
2. Click **Code** and from the ddrop-down click **Download ZIP**. (You can also install from the CLI if you prefer.)
3. Put the contents of your new .zip file in a folder you want to work from.
4. Navigate to the folder containing the contents of your zip file in the terminal.
5. In the terminal, type: ```composer require api-video/php-sdk```

## Prepare Your .csv File 
You're going to need a .csv file containing the information you want to update. The script is designed to be flexible, so you can include any three fields for the columns after the first column, which you must label **id**. In this column you place your videoId. The script can handle legacy video IDs beginning 'vi' or the new ones beginning 'video_'. The next three columns can be the parameters you decide on. In this walkthrough, I picked **title**, **description**, and **public**. I can use these to set the title of my video, provide a description of the video, and choose whether it will be public or private. 

Make sure the top of your file has the field headings, and they correspond to exactly how they are presented in the api.video API. If you need a refresher, check out [docs.api.video](https://docs.api.video/reference) to make sure you're setting up your file correctly. 

Set up all the files you want to edit, one row per video file. Then save your file as **.csv** or **.tsv**. Hervé's script will accept either ending, but be aware that you MUST set up your file so that the separator is a tab, or the script won't run. The easiest way to do this is to save it as **.tsv**.

After you set up your file, place it in the same folder that you run your script from. The script will expect to be able to retrieve your file from this location. 

NOTE: Double and triple check your rows! You don't want to accidentally upload mistake updates if you don't have to. 

## Try the Script

1. In the terminal, type ```php update_metadata.php``` 
2. You're asked what environment you want to use, prod or sandbox. For our walkthrough, choose **prod**.
3. Provide your API key when prompted. You can get this by navigating to [my.api.video](https://my.api.video) and copying the appropriate key.
4. You're asked to provide the name of the file you want to use. Provide the full name of the file, including the ending. 
5. You're asked if you're ready to have your file checked to make sure it has the right headings. Put **y**.
6. If all goes well, the metadata you provided is added! Go check your videos to see if they list the information you wanted to provide. 

Thanks for checking out the latest installment of helpful PHP scripts for bulk video uploads! 

PHP Scripts: Update Metadata for api.video Videos Using CSV

small_pexels-negative-space-34600.jpg

thumbnail_pexels-negative-space-34600.jpg

pexels-negative-space-34600.jpg

Helpful PHP Scripts Pt 4: Update Metadata for api.video Videos Using CSV

In our 3rd installment of helpful PHP scripts for bulk video uploads, we'll take a look at how to export all your video data to a .csv file. This script is part of a collection of scripts that help with bulk video uploads. All are available in our [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository on GitHub. In each part of this series, we'll walk through how to set up one of them. The scripts you'll find include:

* [Ingest Videos from Google Drive](https://api.video/blog/tutorials/helpful-php-scripts-upload-videos-from-google-drive-to-api-video/) - You can transfer all your videos from a folder in Google Drive to your api.video account with this CLI script.
* [Ingest Videos from an FTP Server](https://api.video/blog/tutorials/helpful-php-scripts-pt-2-upload-videos-from-an-ftp-server/) - Transfer all your videos from the FTP server of your choice to your api.video account.
* [Export All Your Video Data to .csv](https://api.video/blog/tutorials/helpful-php-scripts-pt-3-export-all-your-video-details-to-a-csv/) - With this script you can grab details about each video in your api.video account and gather it in one .csv spreadsheet.
* [Update Metadata for api.video Videos Using CSV](https://api.video/blog/tutorials/helpful-php-scripts-pt-4-update-metadata-for-api-video-videos-using-csv/) - You can update your metadata in bulk with this script.
* [Update Video Settings in Bulk Without a CSV File](https://api.video/blog/tutorials/helpful-php-scripts-pt-5-bulk-update-without-a-csv-file/) - Update videos to all be public or private or offer an mp4 download or disable an mp4 download.

medium_pexels-negative-space-97077.jpg

small_pexels-negative-space-97077.jpg

thumbnail_pexels-negative-space-97077.jpg

pexels-negative-space-97077.jpg

We'll be talking about Export All Your Video Data to .csv today! You'll be able to see: 
* **videoId** - the unique identifier for referencing the video in API calls
* **title** - the title of the video
* **publishedAt** - when a video was published, in ISO-8601 format
* **iframe code** - the code for embedding your video as an iframe 
* **thumbnail** - the thumbnail image for the video if one was set 
* **mp4Support** - the URL for the mp4 of the video if one is available
* **metadata** - all key value pairs you set to describe the video (if you didn't set any you won't have them) 

You can check out the API reference documentation for listing videos, which is what we'll use to export our content to a .csv file. The API reference content is here: [List all videos](https://docs.api.video/reference/api/Videos#list-all-video-objects) 

You can use the videoId to associate the video with a custom player you created. 

Now that you know what kind of data you'll receive, let's get started! 

## Prerequisites

For this project you'll need:

* PHP 5.4 or greater with the command-line interface (CLI) and JSON extension installed
* The [Composer](https://getcomposer.org/) dependency management tool (or another way to manage your dependency management). See the Composer website for installation options.
* A GitHub account
* An api.video [account](https://dashboard.api.video/register)
* Your API key for either production or sandbox 

## Installation 

1. Navigate to the [Helpful PHP Scripts](https://github.com/apivideo/helpful-scripts) repository. 
2. Click **Code** and from the drop-down click **Download ZIP**. (You can also install from the CLI if you prefer.)
3. Put the contents of your new .zip file in a folder you want to work from.
4. Navigate to the folder containing the contents of your zip file in the terminal.
5. In the terminal, type: ```composer require api-video/php-sdk```

## Try the Script

1. In the terminal, type ```php create_csv.php```
2. You're asked what environment you want to use, prod or sandbox. For our walkthrough, choose **prod**. NOTE: You should choose the environment you have videos for. If you choose one of these environments and don't have videos stored there, you won't get any data to review.
3. Provide your API key. You can get this by navigating to [my.api.video](https://dashboard.api.video) and copying the appropriate key.
4. Your .csv file will build and be output to **project_details.csv**. 

You can also view the documentation for listing all videos in our API reference content here: [List all videos](https://docs.api.video/reference/api/Videos#list-all-video-objects)
Thanks for checking out our latest installment of Helpful PHP scripts! If you have any question or suggestions, please share them on our [community forum](https://community.api.video/). 


PHP scripts - Export all your video details to a .csv file

<a href="https://www.pexels.com/photo/office-working-app-computer-97077/">Photo by Negative Space from Pexels</a>

Helpful PHP scripts Pt. 3 - Export all your video details to a .csv file

codec

small_cedric.jpeg

thumbnail_cedric.jpeg

cedric.jpeg

Cédric Montet

At api.video, our goal is for video to be easy and affordable for anyone to build, be it individuals or organizations. We understand that achieving this goal means reducing costs at some stage of the video streaming process. That’s why, we now offer adaptive bitrate encoding for your videos at zero cost. 

&nbsp;

Yes, you heard me right. 

&nbsp;

**Encoding videos will be absolutely free for all video qualities (1080p or 4K) at [api.video](https://api.video/) - no hidden calculations, footer notes or tricks.**

(Check out this [video](https://www.youtube.com/watch?v=ouosgLbW7Ts) for more details) 


## A step towards making video streaming affordable

Video encoding is crucial as it makes it possible for videos to be shared and played smoothly on the internet. It is why we are easily able to consume various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Video encoding basically makes the world go around in regards to anything related to video and video content.

&nbsp;

We at api.video recognize that. From [increasing the transcoding and playback speed ](https://api.video/blog/product-updates/2021-in-review/)to building [specialized hardware like ASICs](https://api.video/blog/video-trends/the-comeback-of-specialized-hardware/) cards to increase our transcoding capacities, we've been working to make video streaming easier for you every day. And after dedicating ample time to engaging with our customers and learning about their concerns, free encoding seemed to be the next step in this direction. 

&nbsp;

So, we worked tirelessly behind the scenes to give you what no one else will - free encoding for all video qualities, be it 360p or 4K. 

## How does free video encoding benefit you as a customer

The benefit is straightforward: you save a LOT of money!

&nbsp;

- With free video encoding, you will have one less thing to worry about. As you know, you pay for three things for streaming videos — encoding, hosting, and delivery – out of which encoding is the most expensive, especially if you have a lot of videos. Free video encoding will allow you to focus your attention and resources to what is most important.

&nbsp;

- As the video needs of your app users grow, you might need to scale up your encoding capacity. Free video encoding services will give you the power to scale without any additional costs, meaning your users can handle more videos without increasing your expenses.

&nbsp;

- You can [migrate from your previous provider to api.video](https://api.video/compare/azure-media-services/) without paying an ‘entry tax’ to us. With free video encoding, you no longer need to spend money on encoding videos with a new provider when you have already paid for encoding with an older one.

&nbsp;

Now with all the saved cost, you can allocate your resources and money to a place where it is actually important – building your product and delighting your users. 

## How to get started

To use the free video encoding benefit, getting started is easy. 

&nbsp;

- If you’re a new user, [sign-up](https://dashboard.api.video/register) for a free sandbox account and start uploading your videos
- If you are looking to migrate from another vendor, [import](https://import.api.video/) your videos from your current vendor
- If you have any questions, [talk to us](https://meetings.hubspot.com/diego398/cc-talk-to-us?__hstc=54467703.754940701eda85e3c99a902d8ab0b988.1687266643206.1694417789132.1694427271479.149&__hssc=54467703.3.1694427271479&__hsfp=3654297906) by booking a slot in our calendar

&nbsp;

To know more about our[ features](https://api.video/features/), [pricing](https://api.video/pricing/) or ask any other questions, [talk to our team ](https://meetings.hubspot.com/diego398/cc-talk-to-us?__hstc=54467703.754940701eda85e3c99a902d8ab0b988.1687266643206.1694162373815.1694167498585.144&__hssc=54467703.1.1694167498585&__hsfp=3654297906)and we will help you out. 

&nbsp;

Or, you can straightaway [sign-up](https://dashboard.api.video/register) for a free sandbox account and check our product out for yourself. 


Huge pricing update: Introducing video encoding at no cost

large_Blog_Zero Cost (2).png

medium_Blog_Zero Cost (2).png

small_Blog_Zero Cost (2).png

thumbnail_Blog_Zero Cost (2).png

Blog_Zero Cost (2).png

api.video

Video trends

Modern technology has been helpful for an increasingly fast and simple method of consuming various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Despite the relative ease of doing anything related to video, a few complex processes take place behind the scenes, away from public view. One such process is video encoding.

Video encoding basically makes the world go around in regards to anything related to video and video content. Thanks to the technologies behind the video encoding process, it has become much easier for people and companies to share video content on the internet. But what exactly is video encoding, and what happens during the process? We’ll take a closer look at this and much more in this handy guide to video encoding.

## What is video encoding?

In a nutshell, video encoding occurs when you take raw video footage, either from a digital camera or an analog film camera, and digitally compress it to make it a more manageable file size. Video encoding happens daily in both professional and personal capacities, and many people don’t realize it.

But, without encoding, services like Netflix and YouTube would not exist – or, at least, not in the same way that it does today. Without it, we couldn’t send videos of our beloved pets to our friends and family as easily as we can today.

## Why is video encoding used?

There are a variety of reasons why video encoding is used, but all factors point to the single function of video encoding – **compression**.

This is done to ensure optimal performance and compatibility with a selected suite of software and hardware, be it for DVD/Blu-ray playback, mobile viewing, online video streaming, or general video editing. A file's video and audio information undergo transformation and compression during the encoding process, all in accordance with the requirements of the selected encoding standard.

On a professional level, the ability to compress raw video into more manageable sizes makes it easier to transmit video content such as training, promotion, presentation, and so on over the internet. 

On a personal level, video encoding makes it much easier to send videos taken from your phone directly to friends and family. Most modern-day personal devices have built-in video encoding capabilities to allow for this to happen without a second thought.

To put things in perspective, uncompressed or unencoded video can have a data rate that’s as low as 3,000 Mbps and as high as 12,000 Mbps, depending on the length and quality of the video recorded. 

**Without encoding, it would take up to days for anyone to not just transmit video, but to be able to consume it, too.**

## Differences between video encoding and video transcoding

You need to be familiar with two more [essential terms related to video encoding](https://api.video/what-is/) – transcoding and codecs.

Transcoding relates to the conversion from one digital encoding format to another. It takes the already encoded video file, decompresses it, and then alters it before re-encoding or compressing it into a different codec. Codecs are what allow encoding to occur in the first place. They are software or hardware that gives us the ability to compress video to make them more easily stored and delivered tightly.

While you may hear “encoding” and “transcoding” used interchangeably, the two terms actually mean different things. Putting it succinctly, encoding is the initial process of compressing a video from a source – such as a camera – into a codec, while transcoding takes an already encoded video file to convert it into a different codec.

## Examples of video codecs

In order to understand video encoding, you must first be familiar with two interrelated terms: [video codecs and video formats](https://api.video/blog/product-updates/every-video-format-codec-and-container-explained/). These also tend to be used interchangeably, but much like the terms encoding and transcoding, they refer to two different things.

Video formats are the type of files in which the compressed video/audio is stored. Also known as a “container”, you can tell what a video format is by looking at the file’s extension — the three to four characters that sit after a period in a file name. Here are some of the most common video formats used today:

* MP4
* FLV
* MOV
* MKV
* LXF
* MXF
* AVI
* WebM
* QT

On the other hand, **the codec is short for “Coder / Decoder” (compression / decompression)** and relates to the video compression algorithms that allow encoding to happen. Over the years, codecs have gone through multiple iterations as it coincides with the increasing sophistication and rise in the quality of filmmaking. 

If you’re a content creator, you might be aware of some of the video codecs that exist today:

- **H.264 – also known as AVC, this is the most widely-used video codec available on every platform and mobile device.**
- H.265 – also known as HEVC, stands for High-Efficiency Video Coding, and it’s slowly overtaking H.264 as the standard. This codec can compress video much more efficiently than its predecessor.
- **VP9 – is an open-source, royalty-free codec developed by Google and is considered the direct competitor of H.265. The video compression codec VP9 was created to reduce file sizes, making streaming videos simpler.**
- **AV1 – is another royalty-free, open-source codec released in 2019 by the non-profit Alliance for Open Media. It was developed to become the successor to Google’s VP9 and contend with HEVC more directly.**

## How do different technologies handle video encoding

As you may have suspected, there are a majority of ways that different technologies handle the video encoding process. Let’s take a look at the most common technologies that use video and how video encoding works on each of them:

### Video editing software

When it comes to video content creation, a majority of people will use one of two video editing software — Adobe Premiere Pro or Apple’s Final Cut Pro. Both of these video editing software handle video encoding in very similar ways: when exporting the finished video.

Depending on which device the video content is recorded on, it will already be encoded and formatted according to the settings of the device. For those using iPhones recording 1080p video at 25 frames per second (FPS), for example, the iPhone will automatically encode the video using H.264 and contain it in a .mov file format. The video editing software will “open up” the container to get to the encoded, compressed video file within so the editing process can begin.

After editing the footage is complete, it will need to be exported, which typically concerns video encoding. The edited raw media taken from a recording device such as a camera will be encoded via the codec of the person’s choosing before being put into a .mp4 container once they’ve hit “export”. As we’ve mentioned before, the most common codec used in video content creation is H.264 for HD videos, with 4K videos using H.265. 

### Websites

Different websites utilize different techniques to handle video encoding – with a majority of the major sites like YouTube, Netflix, and so on using their own technologies to handle the process. A majority of social media websites allow you to upload video files directly onto the site to share, although most of them require the files to be saved in specific containers. 

These websites will take your video file and transcode it before using their own systems and serves to re-encode it to match multiple display resolutions. This process will happen regardless of your video file's original codec and settings. Different websites have different processes, but companies that don’t have the capacity to build their own video encoding systems can use a third-party application programming interface (or API) to handle this process. These APIs act as [dedicated video encoder](https://api.video/encoding/) that allows companies to add on-demand videos to their websites more efficiently.

Using [api.video](http://api.video) as an example, all of the videos submitted to the platform will be transformed into H.264 codec in an MP4 container. This may be done using transmuxing and/or transcoding.

We expect the video bitrate to be lower than 16 Mbps for up to 1080p resolution and 50 Mbps for up to 4K resolution. We accept any bitrates, however, we will scale them down to the limits mentioned because anything above is usually challenging for most viewers’ connection to watch.

### API

The ability to generate, store, and distribute video is made possible via a video API. [api.video](http://api.video)’s solution can be tailored to suit any specific need. 

The backend process of video on demand (VOD) is exceptionally complex, even if you’re a software programmer specializing in video. It is necessary to encode, package, and typically transcode the data before sending it to any of several possible destinations. All of these things, and more, may be done with minimal fuss using api.video.

Our API basically keeps the complexities of streaming media hidden from view, so you can rapidly develop apps with as much control as you need. This saves time and effort so developers can concentrate on making the product.

## Conclusion

As you can see through this video encoding guide, a lot of work goes into making the video you watch and the video you share possible. Without video encoding compressing raw video footage, it could take days to upload and transmit video content over the internet and perhaps even longer to be able to download and enjoy them. 

The best part about encoding at api.video is that is offered at ZERO cost. You will only be charged for delivery and hosting of your videos, and the encoding will be free. Now integrate your videos in minutes with api.video or [contact us](https://api.video/contact) for more information.

Video on demand

Live streaming

Analytics

Video infrastructure

See all features

Online learning

Short-form videos

Marketplace & E-commerce

Video messaging and recording

Quickstart guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Help center

Blog

Huge pricing update! Introducing video encoding at zero cost