Well first let me clarify if i understand your idea right:

1. You have custom object object
2. On the insert of that object you have trigger
3. in that trigger you have future call
4. In Future call you are again inserting object(point 1) which in theory run recursively.

No, This will not work!

Why?

You can not call future method from another feature method in your case you are calling trigger and that is calling future method.

It will fail at second iteration as it will realize that you are calling future from future.

You cannot call a method annotated with future from a method that also has the future annotation. Nor can you call a trigger from an annotated method that calls another annotated method.

Best option is follow the advise given by cropredy in comment

There's a number of ways to exceed 100 callouts per transaction using asynchronous code, but trying to call a batch from a future method doesn't even make sense, given all the sanctioned ways we've been given to do so. Here's a few things you could do:

Use @future methods

Break up your lists into batches of about 50 or so, and every 50 callouts just call your future method. You need to use callout=true to allow callouts, like this:

@future(callout=true) public static void doCallouts(Id[] recordIds) {
    ...
}

Use Queueable classes

Break up your lists into batches of about 50 or so, and every 50 callouts just call a Queueable. It'd look like this:

System.enqueueJob(new CalloutQueueable(Id[] recordIds));

Use Batchable classes... Responsibly

Dan Appleman made mention of using a retryable mechanism, and I've built one personally. The general idea is that you create a custom object that stores details about each callout you want to perform asynchronously. Then, you set up a scheduler that runs hourly, checks to see if any new integrations need to be processed, and if so, kicks off the batchable process. You can adjust the scheduler to be as frequent as you'd like, but by allowing a bit of pooling of the requests before trying to process them results in more efficient use of system resources. Other systems may not be able to handle this type of batching though, so smaller/more frequent batches may be required.