diff --git a/docs/docs/en.md b/docs/docs/en.md
index 04615c2..aaba42c 100644
--- a/docs/docs/en.md
+++ b/docs/docs/en.md
@@ -209,6 +209,67 @@ Use the `handler` parameter to use a different Handler
  }
 ```
 
+##### Extending the handler using callbacks properties
+
+Another option for extending handler is possible with below dedicated peperties:
+ * chunk-enabled - must be `true`
+ * chunk-callbacks-enabled - must be `true`
+ * chunk-callbacks - nust be `Object` with interface based on `DefaultChunkUploadCallbacks`
+
+###### How to use calbacks in Vue template and script
+
+```html
+  <file-upload
+    :chunk-enabled="true"
+    :chunk-callbacks-enabled="true"
+    :chunk-callbacks="chunkCallbacksClassInstance"
+    ></file-upload>
+
+<script>
+    // ...
+
+    class ExampleChunkUploadCallbacks {
+        async startPhaseSuccessResponse(sessionId) {
+            console.info('CALL startPhaseSuccessResponseCallback - sessionId: ', sessionId)
+        }
+
+        async uploadPhaseBeforeRequestCallback (sessionId, uploadBody) {
+            console.info('CALL uploadPhaseBeforeRequestCallback - sessionId: ', sessionId, ', uploadBody: ', uploadBody)
+            return uploadBody
+        }
+
+        async uploadPhaseSuccessResponse(sessionId, data) {
+            console.info('CALL uploadPhaseSuccessResponseCallback - sessionId: ', sessionId, ', data:', data)
+        }
+
+        async finishPhaseBeforeRequest(sessionId, finishBody) {
+            console.info('CALL finishPhaseBeforeRequestCallback - sessionId: ', sessionId, ', finishBody: ', finishBody)
+            return finishBody
+        }
+
+        async finishPhaseSuccessResponse(sessionId) {
+            console.info('CALL finishPhaseSuccessResponseCallback - sessionId: ', sessionId)
+        }
+    }
+
+    export default {
+        name: 'ComponentName',
+        components: {
+            // ...
+            FileUpload
+        },
+        data: () => {
+            return {
+                chunkCallbacks: new ExampleChunkUploadCallbacks()
+            }
+        }
+
+        // ...
+
+     }
+
+```
+
 ### SSR (Server isomorphism)
 
 
@@ -650,6 +711,45 @@ All the options to handle chunk uploads
 }
 ```
 
+### chunk-callbacks-enabled
+
+Whether chunk uploads callbacks is enabled or not
+
+* **Type:** `Boolean`
+
+* **Default:** `false`
+
+* **Usage:**
+  ```html
+  <file-upload :chunk-callbacks-enabled="true"></file-upload>
+  <file-upload chunk-callbacks-enabled></file-upload>
+  ```
+
+### chunk-callbacks
+
+Ready to use only when chunk-callbacks-enabled property is enabled or set true.
+Chunk callbacks it is class based on `DefaultChunkUploadCallbacks` example.
+Extend behaviours in few specific chunked upload phases by dedicated functions/callbacks:
+ startPhaseSuccessResponse (called in success response start phase),
+ uploadPhaseSuccessResponse (called in success response upload phase),
+ finishPhaseBeforeRequest (MUST returns optional modified or original body for finish phase request),
+ finishPhaseSuccessResponse (called in success response finished phase).
+
+
+* **Type:** `Object`
+
+* **Default:** `undefined`
+
+* **Usage:**
+  ```html
+  <file-upload
+    :chunk-enabled="true"
+    :chunk-callbacks-enabled="true"
+    :chunk-callbacks="chunkCallbacksClassInstance"
+    ></file-upload>
+  ```
+
+
 ### drop
 
 Drag and drop upload
diff --git a/src/FileUpload.vue b/src/FileUpload.vue
index d47f681..5938b51 100644
--- a/src/FileUpload.vue
+++ b/src/FileUpload.vue
@@ -157,6 +157,17 @@ export default {
       default: false
     },
 
+    // Chunk upload callbacks enabled
+    chunkCallbacksEnabled: {
+      type: Boolean,
+      default: false
+    },
+
+    // Chunk upload callbacks (optional)
+    chunkCallbacks: {
+      type: Object
+    },
+
     // Chunk upload properties
     chunk: {
       type: Object,
@@ -264,7 +275,10 @@ export default {
     },
 
     chunkOptions () {
-      return Object.assign(CHUNK_DEFAULT_OPTIONS, this.chunk)
+      return Object.assign(CHUNK_DEFAULT_OPTIONS, this.chunk, {
+        chunkCallbacksEnabled: this.chunkCallbacksEnabled,
+        chunkCallbacks: this.chunkCallbacks
+      })
     },
 
     className() {
diff --git a/src/chunk/ChunkUploadHandler.js b/src/chunk/ChunkUploadHandler.js
index 97f21de..1efe4da 100644
--- a/src/chunk/ChunkUploadHandler.js
+++ b/src/chunk/ChunkUploadHandler.js
@@ -1,8 +1,24 @@
-import {
-  default as request,
-  createRequest,
-  sendFormRequest
-} from '../utils/request'
+import axios from 'axios'
+
+export class DefaultChunkUploadCallbacks {
+  async startPhaseSuccessResponse (sessionId, filename) {
+  }
+
+  async uploadPhaseSuccessResponse (sessionId, data) {
+  }
+
+  async uploadPhaseBeforeRequestCallback (sessionId, uploadBody) {
+    return uploadBody
+  }
+
+  async finishPhaseBeforeRequest (sessionId, finishBody) {
+    return finishBody
+  }
+
+  async finishPhaseSuccessResponse (sessionId) {
+  }
+}
+
 
 export default class ChunkUploadHandler {
   /**
@@ -14,6 +30,8 @@ export default class ChunkUploadHandler {
   constructor (file, options) {
     this.file = file
     this.options = options
+    this.chunkCallbacksEnabled = this.options.chunkCallbacksEnabled || null
+    this.chunkCallbacks = this.options.chunkCallbacks || null
   }
 
   /**
@@ -45,7 +63,7 @@ export default class ChunkUploadHandler {
   }
 
   /**
-   * Gets the file size
+   * Gets the file name
    */
   get fileName () {
     return this.file.name
@@ -220,32 +238,46 @@ export default class ChunkUploadHandler {
    * Sends a request to the backend to initialise the chunks
    */
   start () {
-    request({
-      method: 'POST',
-      headers: Object.assign({}, this.headers, {
-        'Content-Type': 'application/json'
-      }),
-      url: this.action,
-      body: Object.assign(this.startBody, {
+    axios.post(
+      this.action,
+      Object.assign(this.startBody, {
         phase: 'start',
         mime_type: this.fileType,
         size: this.fileSize,
         name: this.fileName
-      })
-    }).then(res => {
+      }),
+      {
+        headers: Object.assign({}, this.headers, {
+          'Content-Type': 'application/json'
+        })
+      }
+    ).then(response => {
+      const res = response.data
       if (res.status !== 'success') {
         this.file.response = res
         return this.reject('server')
       }
 
-      this.sessionId = res.data.session_id
+      this.sessionId = res.data.upload_id
       this.chunkSize = res.data.end_offset
 
-      this.createChunks()
-      this.startChunking()
-    }).catch(res => {
+      this.startPhaseSuccessResponseCallback(
+        this.sessionId,
+        this.fileName
+      ).then(() => {
+        console.debug('[vue-upload-component] ChunkUploadHandler -- START createChunks')
+        this.createChunks()
+        console.debug('[vue-upload-component] ChunkUploadHandler -- START startChunking')
+        this.startChunking()
+      }).catch(ex => {
+        this.reject('server')
+        console.error('[vue-upload-component] ChunkUploadHandler -- START reject server - startPhaseSuccessResponseCallback exception:', ex)
+      })
+    }).catch(response => {
+      const res = response.data
       this.file.response = res
       this.reject('server')
+      console.error('[vue-upload-component] ChunkUploadHandler -- START reject server - response:', response)
     })
   }
 
@@ -284,46 +316,92 @@ export default class ChunkUploadHandler {
    *
    * @param {Object} chunk
    */
-  uploadChunk (chunk) {
+  async uploadChunk (chunk) {
     chunk.progress = 0
     chunk.active = true
     this.updateFileProgress()
-    chunk.xhr = createRequest({
-      method: 'POST',
-      headers: this.headers,
-      url: this.action
-    })
-
-    chunk.xhr.upload.addEventListener('progress', function (evt) {
-      if (evt.lengthComputable) {
-        chunk.progress = Math.round(evt.loaded / evt.total * 100)
-      }
-    }, false)
 
-    sendFormRequest(chunk.xhr, Object.assign(this.uploadBody, {
+    let uploadBody = Object.assign(this.uploadBody, {
       phase: 'upload',
       session_id: this.sessionId,
       start_offset: chunk.startOffset,
       chunk: chunk.blob
-    })).then(res => {
-      chunk.active = false
-      if (res.status === 'success') {
-        chunk.uploaded = true
-      } else {
+    })
+
+    this.uploadPhaseBeforeRequestCallback(
+      this.sessionId,
+      uploadBody
+    ).then(newBody => {
+      console.info('[vue-upload-component] ChunkUploadHandler -- UPLOAD uploadPhaseBeforeRequestCallback then - newBody:', newBody)
+      const formData = new FormData()
+      for (var name in newBody) {
+        formData.append(name, newBody[name])
+      }
+
+      console.info('[vue-upload-component] ChunkUploadHandler -- UPLOAD formData:', formData)
+
+      axios.post(
+        this.action,
+        formData,
+        {
+          headers: Object.assign({}, this.headers, {
+            'Content-Type': 'multipart/form-data'
+          }),
+          onUploadProgress: function(progressEvent) {
+            if (progressEvent.lengthComputable) {
+              chunk.progress = Math.round(progressEvent.loaded / progressEvent.total * 100)
+            }
+          }
+        }
+      ).then(response => {
+        console.info('[vue-upload-component] ChunkUploadHandler -- UPLOAD response:', response)
+        const res = response.data
+        chunk.active = false
+        if (res.status === 'success') {
+          this.uploadPhaseSuccessResponseCallback(
+            this.sessionId,
+            res
+          ).then(() => {
+            console.info('[vue-upload-component] ChunkUploadHandler -- UPLOAD success')
+            chunk.uploaded = true
+          }).catch(ex => {
+            this.reject('server')
+            chunk.active = false
+            if (chunk.retries-- <= 0) {
+              this.stopChunks()
+              console.error('[vue-upload-component] ChunkUploadHandler -- UPLOAD stopChunks if (chunk.retries-- <= 0) { - reject upload - exception:', ex)
+              return this.reject('upload')
+            }
+          })
+        } else {
+          chunk.active = false
+          if (chunk.retries-- <= 0) {
+            this.stopChunks()
+            console.error('[vue-upload-component] ChunkUploadHandler -- UPLOAD stopChunks if (chunk.retries-- <= 0) { - reject upload')
+            return this.reject('upload')
+          }
+        }
+        console.warn('[vue-upload-component] ChunkUploadHandler -- UPLOAD uploadNextChunk')
+        this.uploadNextChunk()
+      }).catch((response) => {
+        console.error('[vue-upload-component] ChunkUploadHandler -- UPLOAD catch - response:', response)
+        chunk.active = false
         if (chunk.retries-- <= 0) {
           this.stopChunks()
+          console.error('[vue-upload-component] ChunkUploadHandler -- UPLOAD stopChunks - reject upload')
           return this.reject('upload')
         }
-      }
-
-      this.uploadNextChunk()
-    }).catch(() => {
+        console.warn('[vue-upload-component] ChunkUploadHandler -- UPLOAD uploadNextChunk')
+        this.uploadNextChunk()
+      })
+    }).catch((ex) => {
       chunk.active = false
       if (chunk.retries-- <= 0) {
         this.stopChunks()
+        console.error('[vue-upload-component] ChunkUploadHandler -- UPLOAD stopChunks - reject upload')
         return this.reject('upload')
       }
-
+      console.warn('[vue-upload-component] ChunkUploadHandler -- UPLOAD uploadPhaseBeforeRequestCallback - exception:', ex)
       this.uploadNextChunk()
     })
   }
@@ -332,29 +410,90 @@ export default class ChunkUploadHandler {
    * Finish phase
    * Sends a request to the backend to finish the process
    */
-  finish () {
+  async finish () {
     this.updateFileProgress()
 
-    request({
-      method: 'POST',
-      headers: Object.assign({}, this.headers, {
-        'Content-Type': 'application/json'
-      }),
-      url: this.action,
-      body: Object.assign(this.finishBody, {
-        phase: 'finish',
-        session_id: this.sessionId
-      })
-    }).then(res => {
-      this.file.response = res
-      if (res.status !== 'success') {
-        return this.reject('server')
-      }
+    let finishBody = Object.assign(this.finishBody, {
+      phase: 'finish',
+      session_id: this.sessionId
+    })
 
-      this.resolve(res)
-    }).catch(res => {
-      this.file.response = res
+    this.finishPhaseBeforeRequestCallback(
+      this.sessionId,
+      finishBody
+    ).then(newBody => {
+      axios.post(
+        this.action,
+        newBody,
+        {
+          headers: Object.assign({}, this.headers, {
+            'Content-Type': 'application/json'
+          })
+        }
+      ).then(response => {
+        const res = response.data
+        this.file.response = res
+        if (res.status !== 'success') {
+          console.error('[vue-upload-component] ChunkUploadHandler -- FINISH reject server ' +
+                        '- IF res.status !== "success"- response:', response)
+          return this.reject('server')
+        }
+
+        this.finishPhaseSuccessResponseCallback(
+          this.sessionId
+        ).then(() => {
+          this.resolve(res)
+        }).catch(ex => {
+          console.error('[vue-upload-component] ChunkUploadHandler ' +
+                        '-- FINISH reject server - exception:', ex)
+          this.reject('server')
+        })
+      }).catch(response => {
+        const res = response.data
+        this.file.response = res
+        this.reject('server')
+        console.error('[vue-upload-component] ChunkUploadHandler ' +
+                      '-- FINISH reject server - response:', response)
+      })
+    }).catch(ex => {
       this.reject('server')
+      console.error('[vue-upload-component] ChunkUploadHandler ' +
+                    '-- FINISH reject server - exception:', ex)
     })
   }
+
+  async startPhaseSuccessResponseCallback (sessionId, fileName) {
+    if (!this.chunkCallbacksEnabled || this.chunkCallbacks.startPhaseSuccessResponse instanceof Function === false) {
+      return false
+    }
+    return this.chunkCallbacks.startPhaseSuccessResponse(sessionId, fileName)
+  }
+
+  async uploadPhaseBeforeRequestCallback (sessionId, uploadBody) {
+    if (!this.chunkCallbacksEnabled || this.chunkCallbacks.uploadPhaseBeforeRequest instanceof Function === false) {
+      return uploadBody
+    }
+    return this.chunkCallbacks.uploadPhaseBeforeRequest(sessionId, uploadBody)
+  }
+
+  async uploadPhaseSuccessResponseCallback (sessionId, data) {
+    if (!this.chunkCallbacksEnabled || this.chunkCallbacks.uploadPhaseSuccessResponse instanceof Function === false) {
+      return false
+    }
+    return this.chunkCallbacks.uploadPhaseSuccessResponse(sessionId, data)
+  }
+
+  async finishPhaseBeforeRequestCallback (sessionId, finishBody) {
+    if (!this.chunkCallbacksEnabled || this.chunkCallbacks.finishPhaseBeforeRequest instanceof Function === false) {
+      return finishBody
+    }
+    return this.chunkCallbacks.finishPhaseBeforeRequest(sessionId, finishBody)
+  }
+
+  async finishPhaseSuccessResponseCallback (sessionId) {
+    if (!this.chunkCallbacksEnabled || this.chunkCallbacks.finishPhaseSuccessResponse instanceof Function === false) {
+      return false
+    }
+    return this.chunkCallbacks.finishPhaseSuccessResponse(sessionId)
+  }
 }
diff --git a/src/utils/request.js b/src/utils/request.js
deleted file mode 100644
index f63b44e..0000000
--- a/src/utils/request.js
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * Creates a XHR request
- *
- * @param {Object} options
- */
-export const createRequest = (options) => {
-  const xhr = new XMLHttpRequest()
-  xhr.open(options.method || 'GET', options.url)
-  xhr.responseType = 'json'
-  if (options.headers) {
-    Object.keys(options.headers).forEach(key => {
-      xhr.setRequestHeader(key, options.headers[key])
-    })
-  }
-
-  return xhr
-}
-
-/**
- * Sends a XHR request with certain body
- *
- * @param {XMLHttpRequest} xhr
- * @param {Object} body
- */
-export const sendRequest = (xhr, body) => {
-  return new Promise((resolve, reject) => {
-    xhr.onload = () => {
-      if (xhr.status >= 200 && xhr.status < 300) {
-        var response
-        try {
-          response = JSON.parse(xhr.response)
-        } catch (err) {
-          response = xhr.response
-        }
-        resolve(response)
-      } else {
-        reject(xhr.response)
-      }
-    }
-    xhr.onerror = () => reject(xhr.response)
-    xhr.send(JSON.stringify(body))
-  })
-}
-
-/**
- * Sends a XHR request with certain form data
- *
- * @param {XMLHttpRequest} xhr
- * @param {Object} data
- */
-export const sendFormRequest = (xhr, data) => {
-  const body = new FormData()
-  for (var name in data) {
-    body.append(name, data[name])
-  }
-
-  return new Promise((resolve, reject) => {
-    xhr.onload = () => {
-      if (xhr.status >= 200 && xhr.status < 300) {
-        var response
-        try {
-          response = JSON.parse(xhr.response)
-        } catch (err) {
-          response = xhr.response
-        }
-        resolve(response)
-      } else {
-        reject(xhr.response)
-      }
-    }
-    xhr.onerror = () => reject(xhr.response)
-    xhr.send(body)
-  })
-}
-
-/**
- * Creates and sends XHR request
- *
- * @param {Object} options
- *
- * @returns Promise
- */
-export default function (options) {
-  const xhr = createRequest(options)
-
-  return sendRequest(xhr, options.body)
-}