If you ever need to modify the ajax url dynamically or add extra query parameters, you can follow this method:

Simply use the following code snippet:

var dataTable = $('#example').DataTable({...});    
dataTable.ajax.url('/new-ajax-url?someParam=1').load();

This technique is compatible with version v1.10.16 of the library.

$('#example').dataTable({
  "ajax": {
    "url": "data.json",
    "data": function (d) {
        d.custom_search = $('#custom').val();
    }
  }
});

finally execute:

table.ajax.reload();

My goal was to send new parameters with each request without the need to constantly rebuild the datatable. As a heavy user of datatables on my website, I needed a simpler method to handle my use case, which led me to develop this solution. Perhaps it will benefit others as well.

buildDT.js :

        ;(function (){ 
        
    'use strict';
    
    /**
     * dtReload is a function used for setting new parameters 
     * to send to the server without requiring 
     * the table to be reloaded
     */
    var dtReload = {};
    /**
     * This object holds the parameters to be sent to the server 
     */
    dtReload.param = {};
    /**
     * Adds the parameters to the object used by datatables
     * for the request
     * @param param object datatables object
     * @param extra object extra params to send to the server
     * @return object
     */
    dtReload.proccParam = (param, extra) => {
      $.each(extra, function(i,e){
        param[i] = e;
      })
      return param;
    }
    
    class buildDataTable {
        
        #url = '';
        #method = 'POST';
        
        #dtOptions = {};
        #responsive = true;
        #pageLength = 10;
        #lengthMenu = [5, 10, 20];
        #processing = true;
        #serverSide = true;
        #language = {}; 
        #initComplete;
        #columns = [];
        #columnDefs = [];

        ajaxParam;
        
        constructor(){}
        
        setURL(url){
            this.#url = url
        }
        
        setPageLength(pageLengthInt){
            if(pageLengthInt == 'undeinfed'){
              this.#pageLength = 10;
            }else if(typeof pageLengthInt == "number"){
              this.#pageLength = pageLengthInt;
            }else{
              console.log('Colums should be of type Array');
            }
        }
        
        setColumns(columnsArray){
            if(columnsArray == 'undefined'){
              this.#columns = [];
            }else if(typeof columnsArray == "object" && true == Array.isArray(columnsArray)){
              this.#columns = columnsArray;
            }else{
              console.log('Colums should be of type Array');
            }
        }
        
        setColumnDefs(columnDefsArray){
            if(language == 'undefined'){    
                this.#columnDefs = [
                  { targets: 'no-sort', orderable: false }
                ]   
            }else if(typeof columnDefsArray == "object" && true == Array.isArray(columnDefsArray)){
                this.#columnDefs = columnDefsArray;
            }else{
                console.log('Coulmn Definitions should be of type Array');
            }
        }
        
        setLanguage(language){
            if(language == 'undefined'){
              this.#language = {
                infoEmpty: "No Data To Display",
                emptyTable: "No Data To Display",
                zeroRecords: "No Data To Display"
              }
            }else if(typeof language == "object" && false == Array.isArray(language)){
                this.#language = language;
            }else{
                console.log('Language should be of type object');
            }
        }
        
        setInitComplete(func){              
            this.#initComplete = function(settings, json){
                if(typeof func == "function"){
                  func(settings,json);
                }
            }
        }
        
        setParam(param){ 
          this.ajaxParam = param;
        }
        
        getParam(){     
            return this.ajaxParam;
        }
        
        makeAjax(param){
          dtReload.param = param;
          return {
            url:this.#url,
            dataSrc:'data.result',
            data:function(d){   
              dtReload.proccParam(d, dtReload.param)
            },
            method:this.#method
          }
        }   
        
        #setOptions(){      
            this.#dtOptions = {         
                responsive:this.#responsive,
                pageLength:this.#pageLength,
                lengthMenu:this.#lengthMenu,
                processing:this.#processing,
                serverSide:this.#serverSide,
                language:this.#language,
                ajax:this.makeAjax(this.getParam()),
                initComplete:this.#initComplete,
                columns:this.#columns,
                columnDef:this.#columnDefs          
            }   
        }
        
        getOptions(){
          this.#setOptions();
          return this.#dtOptions;
        }   
    }
    
    window.dtReload = dtReload;
    window.buildDataTable = buildDataTable;
    
    
    })();

Usage

    var builder = new buildDataTable();
    var myDTableObject;
    
    function doSomething(id){
    
      // Pass the param 
      builder.setParam({
         someParam : 'doSomething',
         id:id,
         token : token_value
      });
    
      // Set the server url
      builder.setURL('http://your/url')
      // Setup your columns
      builder.setColumns([
        { "data": function(data){return columnProcess(data).id} },
        { "data": "name" },
        { "data": function(data){return columnProcess(data).status} },
        { "data": "date" },
        { "data": "options" }   
      ])
      
      // Check if datatables is loaded and setup
      if($.fn.dataTable.isDataTable('#yourTable')){
          // Set the new param
          dtReload.param = builder.getParam();
          // Reload the table
          myDTableObject.ajax.reload();
      }else{
        // Init table setup
        myDTableObject = $('#yourTable').DataTable(
          builder.getOptions()
        );
      } 
    }

Special thanks to @sraxi for the idea of using the function in the ajax request to process the parameters.

I have created a GitHub repository for this solution: DataTableReload