Vue.js

This is a quick start guide to show you how to integrate ImageKit in the Vue.js application. The code samples covered here are hosted on Github -  https://github.com/imagekit-samples/quickstart/tree/master/vuejs.
This guide walks you through the following topics:
​Setting up ImageKit Vue.js SDK​
​Rendering images​
​Applying common image manipulations​
​Adding overlays to images​
​Lazy loading images​
​Blurred image placeholder​
​Client-side file uploading​
Setup ImageKit Vue.js SDK
Install Vue CLI
1
npm install -g @vue/cli
2
# OR
3
yarn global add @vue/cli
Copied!
Create a project
Let's create a dummy project called vuejs using vue CLI.
1
vue create vuejs
Copied!
It will prompt the vue version and a few other options, select default by pressing enter. It will create a dummy project like this:
Install imagekitio-vue 
1
npm install imagekitio-vue
2
# OR
3
yarn add imagekitio-vue
Copied!
Initialize SDK
1
import ImageKit from "imagekitio-vue"
2
Vue.use(ImageKit, {
3
  urlEndpoint: "your_url_endpoint",
4
  // publicKey: "your_public_api_key",
5
  // authenticationEndpoint: "https://www.your-server.com/auth"
6
})
Copied!
urlEndpoint is the required parameter. You can get the value of URL-endpoint from your ImageKit dashboard - https://imagekit.io/dashboard#url-endpoints.
publicKey and authenticationEndpoint parameters are optional and only needed if you want to use the SDK for client-side file upload. You can get these parameters from the developer section in your ImageKit dashboard - https://imagekit.io/dashboard#developers.
Let's modify src/components/HelloWorld.vue to import and initialize ImageKit as a plugin. Replace your_url_endpoint etc, with actual values.
src/components/HelloWorld.vue
1
<template>
2
  <div>
3
    <h1>ImageKit Vuejs quick start</h1>
4
  </div>
5
</template>
6
​
7
<script>
8
import Vue from "vue"
9
import ImageKit from "imagekitio-vue"
10
Vue.use(ImageKit, {
11
  urlEndpoint: "your_url_endpoint", // Required. Default URL-endpoint is https://ik.imagekit.io/your_imagekit_id
12
  publicKey: "your_public_api_key", // optional
13
  authenticationEndpoint: "https://www.your-server.com/auth" // optional
14
})
15
​
16
export default {
17
  name: 'HelloWorld',
18
  props: {
19
    msg: String
20
  }
21
}
22
</script>
Copied!
This SDK provides 3 global components when registered as a plugin:
ik-image for image resizing. The output is a <img> tag.
ik-upload for file uploading. The output is a <input type="file"> tag.
​ik-context for defining urlEndpoint, publicKey and authenticationEndpoint to all children elements.
You can also import components individually.
1
import { IKImage, IKContext, IKUpload } from "imagekitio-vue"
2
​
3
export default {
4
  components: {
5
    IKImage,
6
    IKContext,
7
    IKUpload
8
  }
9
}
Copied!
Rendering images in Vue.js
Loading image using a relative path
Let's render an image at path /default-image.jpg.
src/components/HelloWorld.vue
1
<template>
2
  <div>
3
    <h1>ImageKit Vuejs quick start</h1>
4
    <ik-image width="400" path="/default-image.jpg">
5
    </ik-image>
6
  </div>
7
</template>
8
​
9
<script>
10
import Vue from "vue"
11
import ImageKit from "imagekitio-vue"
12
Vue.use(ImageKit, {
13
  urlEndpoint: "https://ik.imagekit.io/demo"
14
})
15
​
16
export default {
17
  name: 'HelloWorld',
18
  props: {
19
    msg: String
20
  }
21
}
22
</script>
Copied!
1
<ik-image width="400" path="/default-image.jpg">
Copied!
renders to:
1
<img src="https://ik.imagekit.io/demo/default-image.jpg?ik-sdk-version=vuejs-1.0.6" 
2
     class="ik-image"
3
     width="400">
Copied!
The final result looks like this:
Loading image from an absolute path
If you have an absolute image path coming from the backend API e.g. https://www.custom-domain.com/default-image.jpg then you can use src prop to load the image.
For example:
1
<ik-image 
2
    width="400" 
3
    src="https://ik.imagekit.io/demo/default-image.jpg" />
Copied!
The output looks like this:
Common image manipulation in Vue.js
This section covers the basics:
​Resizing images ​
​Quality manipulation​
​Chained transformation​
The Vuejs SDK gives a name to each transformation parameter e.g. height for h and width for w parameter. It makes your code more readable. If the property does not match any of the available options, it is added as it is. See the full list of supported transformations in Vuejs SDK on Github.
​👉
 Note that you can also use h and w parameter instead of height and width. See the complete list of transformations supported in ImageKit here.
Resizing images in Vue.js
Let's resize the image to width 300 and height 300.
1
<ik-image 
2
      path="/default-image.jpg" 
3
      :transformation="[{width: 300, height: 300}]" />
Copied!
The output looks like:
Quality manipulation
You can use the quality parameter to change quality like this:
1
<ik-image 
2
  path="/default-image.jpg" 
3
  :transformation="[{quality: 40}]" />
Copied!
The output is:
Chained transformation
You can pass more than one object in transformation prop to chain these transformations sequentially.
For example, the following values will first resize the image to width 300, height 300, and then rotate to 90 degrees. 
1
// It means first resize the image to 400x400 and then rotate 90 degree
2
transformation = [
3
  {
4
    height: 300,
5
    width: 300
6
  },
7
  {
8
    rotation: 90
9
  }
10
]
Copied!
So the following:
1
<ik-image 
2
      path="/default-image.jpg" 
3
      :transformation="[{width: 300, height: 300}, {rotation: 90}]" />
Copied!
renders to:
Adding overlays to images in Vue.js
ImageKit.io allows you to can add text and image overlay dynamically.
For example:
1
<ik-image 
2
  path="/default-image.jpg" 
3
  :transformation="[{
4
    width: 300, 
5
    height: 300, 
6
    overlayImage: 'default-image.jpg', 
7
    overlayWidth: 100,
8
    overlayX: 0,
9
    overlayImageBorder: '10_CDDC39' // 10px border of color CDDC39
10
  }]" />
Copied!
Renders to:
1
<img src="https://ik.imagekit.io/pshbwfiho/tr:w-300,h-300,oi-default-image.jpg,ow-100,ox-0,oib-10_CDDC39/default-image.jpg?ik-sdk-version=vuejs-1.0.8" class="ik-image">
Copied!
The output looks like:
​
Lazy-loading images in Vue.js
You can lazy load images using the loading prop in ik-image component. When you use loading="lazy", all images that are immediately viewable without scrolling load normally. Those that are far below the device viewport are only fetched when the user scrolls near them.
The SDK uses a fixed threshold based on the effective connection type to ensure that images are loaded early enough so that they have finished loading once the user scrolls near to them.
On fast connections (e.g 4G), the value of the threshold is 1250px and on slower connections (e.g 3G), it is 2500px.
You should always set the height and width of image element to avoid layout shift when lazy-loading images.
Example usage:
1
// Lazy loading images
2
<ik-image
3
  path="/default-image.jpg"
4
  :transformation="[{height:300,width:400}]"
5
  loading="lazy"
6
  height="300"
7
  width="400"
8
/>
Copied!
Blurred image placeholder
To improve user experience, you can use a low-quality blurred variant of the original image as a placeholder while the original image is being loaded in the background. Once the loading of the original image is finished, the placeholder is replaced with the original image.
1
// Loading a blurred low quality image placeholder while the original image is being loaded
2
<ik-image
3
  path="/default-image.jpg"
4
  :lqip="{active:true}"
5
/>
Copied!
By default, the SDK uses the quality:20 and blur:6. You can change this. For example:
1
<ik-image
2
  path="/default-image.jpg"
3
  :lqip="{active:true, quality: 40, blur: 5}"
4
/>
Copied!
Combining lazy loading with low-quality placeholders
You have the option to lazy-load the original image only when the user scrolls near them. Until then, only a low-quality placeholder is loaded. This saves a lot of network bandwidth if the user never scrolls further down.
1
// Loading a blurred low quality image placeholder and lazy-loading original when user scrolls near them
2
<ik-image
3
  path="/default-image.jpg"
4
  :transformation="[{height:300,width:400}]"
5
  :lqip="{active:true}"
6
  loading="lazy"
7
  height="300"
8
  width="400"
9
/>
Copied!
Uploading files in Vue.js
Vuejs SDK provides ik-upload component which can generate an input type="file" tag that you can use to upload files to the ImageKit media library directly from the client-side. 
For using upload functionality, we need to pass publicKey and authenticationEndpoint while initializing the SDK.  Replace your_url_endpoint , your_public_key, your_authentication_endpoint with actual values.
1
<script>
2
import Vue from "vue";
3
import ImageKit from "imagekitio-vue";
4
Vue.use(ImageKit, {
5
  urlEndpoint: "your_url_endpoint",
6
  publicKey: "your_public_key",
7
  authenticationEndpoint: "your_authentication_endpoint"
8
});
9
​
10
export default {
11
  name: "HelloWorld",
12
  props: {
13
    msg: String
14
  }
15
};
16
</script>
Copied!
authenticationEndpoint should be implemented in your backend. The SDK makes an HTTP GET request to this endpoint and expects a JSON response with three fields i.e. signature, token, and expire. Learn how to implement authenticationEndpoint on your server.
For this quickstart guide, we have provided a sample implementation of http://localhost:3001/auth in Node.js.
Let's create a file index.js inside server folder in the project root. It should look like this:
We will use the ImageKit Node.js SDK to implement http://localhost:3001/auth.
Let's first install all basic modules we need to run an HTTP server.
1
npm install express
2
npm install imagekit
Copied!
Let's modify index.js to implement http://localhost:3001/auth which is our authenticationEndpoint.
index.js (backend)
HelloWorld.vue (frontend)
server/index.js
1
/* 
2
    This is our backend server.
3
    Replace your_url_endpoint, your_public_key, your_private_key 
4
    with actual values
5
*/
6
const express = require('express');
7
const app = express();
8
const ImageKit = require("imagekit");
9
​
10
const imagekit = new ImageKit({
11
    urlEndpoint: "your_url_endpoint",
12
    publicKey: "your_public_key",
13
    privateKey: "your_privage_key"
14
})
15
​
16
app.get("/auth", function (req, res) {
17
    var result = imagekit.getAuthenticationParameters();
18
    res.send(result);
19
});
20
​
21
app.listen(3001, function () {
22
    console.log("Live at Port 3001");
23
});
Copied!
src/components/HelloWorld.vue
1
<script>
2
/* 
3
    This is our frontend code
4
    Replace your_url_endpoint, your_public_key with actual values
5
*/
6
import Vue from "vue";
7
import ImageKit from "imagekitio-vue";
8
Vue.use(ImageKit, {
9
  urlEndpoint: "your_url_endpoint",
10
  publicKey: "your_public_key",
11
  authencticationEndpiont: "http://localhost:3001/auth"
12
});
13
​
14
export default {
15
  name: "HelloWorld",
16
  props: {
17
    msg: String
18
  }
19
};
20
</script>
Copied!
Let's run the backend server.
1
cd server
2
node index.js
Copied!
If you GET http://localhost:3001/auth, you should see a JSON response like this. Actual values will vary.
1
{
2
    token: "5dd0e211-8d67-452e-9acd-954c0bd53a1f",
3
    expire: 1601047259,
4
    signature: "dcb8e72e2b6e98186ec56c62c9e62886f40eaa96"
5
}
Copied!
Let's include ik-upload component in the HelloWorld.vue.
1
<template>
2
  <div>
3
    <h1>ImageKit Vuejs quick start</h1>
4
​
5
    <h2>File upload</h2>
6
    <ik-upload 
7
      :onError="onError"
8
      :onSuccess="onSuccess" />
9
  </div>
10
</template>
11
<script>
12
/* 
13
    Replace your_url_endpoint, your_public_key with actual values
14
*/
15
import Vue from "vue";
16
import ImageKit from "imagekitio-vue";
17
Vue.use(ImageKit, {
18
  urlEndpoint: "your_url_endpoint",
19
  publicKey: "your_public_key",
20
  authencticationEndpiont: "http://localhost:3001/auth"
21
});
22
​
23
export default {
24
  name: "HelloWorld",
25
  props: {
26
    msg: String
27
  },
28
  methods: {
29
    onError(err) {
30
      console.log("Error");
31
      console.log(err);
32
    },
33
    onSuccess(res) {
34
      console.log("Success");
35
      console.log(res);
36
    }
37
  }
38
};
39
</script>
Copied!
The output looks like:
When you choose a file, the file is uploaded. You can pass optional onSuccess and onError callback functions as props like we have.
After successful upload, you should see the upload API response in the console like this:
What's next
The possibilities for image manipulation and optimization with ImageKit are endless. Learn more about it here: 
​Image Transformations​
​Image optimization​
​Media Library​
​Performance monitoring​

Ruby on Rails

Next - 📌Getting Started

How to use ImageKit.io?

Last modified 1yr ago

Copy link

Contents

Setup ImageKit Vue.js SDK

Rendering images in Vue.js

Common image manipulation in Vue.js

Resizing images in Vue.js

Quality manipulation

Chained transformation

Adding overlays to images in Vue.js

Lazy-loading images in Vue.js

Blurred image placeholder

Uploading files in Vue.js

What's next