Getting error in integration of Chainlink VRF

Hello everyone, I am integrating Chainlink VRF into my smart contract but I am facing an error called:

The transaction has been reverted to the initial state.
Note: The called function should be payable if you send value and the value you send should be less than your current balance.
Debug the transaction to get more information.

while calling the callRequestRandomWords function from the Marketplace contract.
Could you please check the below code?

NFT.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";

contract NFT is ERC721, VRFConsumerBaseV2{
    uint256 private _tokenIdCounter;
    bytes32 public keyHash;
    uint32 public callbackGasLimit = 300000;
    uint16 public requestConfirmations = 3;
    uint32 public numWords = 1;
    uint256 public immutable interval;
    uint256 public lastTimeStamp;
    uint256 public winnerPercentage;
    uint64 s_subscriptionId;
    VRFCoordinatorV2Interface COORDINATOR;

    event RequestSent(uint256 requestId, uint32 numWords);
    event RequestFulfilled(uint256 requestId, uint256[] randomWords);

     struct RequestStatus {
        bool fulfilled; // whether the request has been successfully fulfilled
        bool exists; // whether a requestId exists
        uint256[] randomWords;
    }
    mapping(uint256 => RequestStatus)
        public s_requests; /* requestId --> requestStatus */

    mapping(address => uint256) public addressToRequestId;
     // past requests Id.
    uint256[] public requestIds;
    uint256 public lastRequestId;
    
      constructor(
        string memory _name,
        string memory _symbol,
        uint256 updateInterval,
        uint256 _winnerPercentage,
        address vrfCoordinator,
        bytes32 vrfKeyHash,
        uint64 subscriptionId
        )
        ERC721(_name, _symbol)
        VRFConsumerBaseV2(vrfCoordinator) 
    {
        interval = updateInterval;
        lastTimeStamp = block.timestamp;
        winnerPercentage = _winnerPercentage;
        keyHash = vrfKeyHash;
        s_subscriptionId = subscriptionId;
        COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
    }
    
   function safeMint (address to) public returns (uint256) {
        uint256 tokenId = _tokenIdCounter;
           _safeMint(to, tokenId);    
          _tokenIdCounter++;
          return tokenId;
    }

     function getRandomnessRequestState(address requester)
        public
        view
        returns (RequestStatus memory)
    {
        return s_requests[addressToRequestId[requester]];
    }
           function requestRandomWords()
        external
        returns (uint256 requestId)
    {
        requestId = COORDINATOR.requestRandomWords(
            keyHash,
            s_subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
        s_requests[requestId] = RequestStatus({
            randomWords: new uint256[](0),
            exists: true,
            fulfilled: false
        });
        requestIds.push(requestId);
        lastRequestId = requestId;
        emit RequestSent(requestId, numWords);
        return requestId;
    }
  function fulfillRandomWords(
        uint256 _requestId,
        uint256[] memory _randomWords
    ) internal override {
        require(s_requests[_requestId].exists, "request not found");
        s_requests[_requestId].fulfilled = true;
        s_requests[_requestId].randomWords = _randomWords;
        emit RequestFulfilled(_requestId, _randomWords);
    }
}

Marketplace. sol

 address vrfCoordinator = 0x7a1BaC17Ccc5b313516C5E16fb24f7659aA5ebed;
    bytes32 vrfKeyHash = 0x4b09e658ed251bcafeebbc69400383d49f344ace09b9576fe248bb02c003fe9f;
    uint64 subscriptionId = '6...';   

   function createToken(string memory name, string memory symbol, uint256 updateInterval, uint256 winnerPercentage) public {
address _address = address(new NFT(name, symbol, updateInterval,winnerPercentage, vrfCoordinator, vrfKeyHash, subscriptionId));   
        uint256 count = 0;
       tokens[msg.sender].push(_address);
       CollectionAddresses.push(_address);
       count++;       
        emit TokenCreated(msg.sender, _address);
    }

function callRequestRandomWords(address tokenAddress) public onlyOwner returns(uint256) {
return NFT(tokenAddress).requestRandomWords();       
    }

Ps: I have created a subscription, added a consumer, and also funded the subscription. Tried sending LINK tokens to the contract as well but it is not working. I am using the polygon Mumbai network