Rockstar Games Gives Away Millions in Free GTA$ to Online Players GTA Radars

Table of Contents

1 In a surprise move, Rockstar Games has begun distributing massive cash bonuses to GTA Online players this week, with some users reporting free deposits of 1−4millionGTA in their Maze Bank accounts.
2 Who Qualifies for Free Cash? Early reports suggest these bonuses are being awarded to:
- - 2.0.1 What Players Are Buying The sudden cash infusion has sparked a shopping spree for:
- 2.1 Rockstar hasn’t announced an official end date for these bonuses, so players should log in soon to potentially claim their share. With GTA 6 coming Fall 2025, this could be one of the last major money giveaways for the decade-old GTA Online economy.

In a surprise move, Rockstar Games has begun distributing massive cash bonuses to GTA Online players this week, with some users reporting free deposits of
1−4millionGTA in their Maze Bank accounts.

Why the Sudden Generosity?
The unexpected windfall appears to be part of:
✅ A “stimulus package” to boost player engagement before summer updates
✅ Compensation for recent server instability issues
✅ Promotional push ahead of rumored GTA 6 marketing campaigns

“Logged in today to find $2.5M just sitting there,” tweeted one surprised player. “No missions completed, no explanation – just free money.”

Who Qualifies for Free Cash?
Early reports suggest these bonuses are being awarded to:

Players who logged significant hours in April

Returning players who haven’t been active recently

Anyone who completed last week’s special challenges

How to Claim Your Share
Simply log into GTA Online this week

Check your Maze Bank account notifications

Allow 72 hours for delayed deposits

(Optional) Verify eligibility via Rockstar Support

What Players Are Buying
The sudden cash infusion has sparked a shopping spree for:

Weaponized vehicles (Oppressor Mk II sales up 300%)

Luxury properties (Nightclub upgrades in high demand)

Heist preparation gear (Armored Kurumas flying off websites)

Economic Impact on Los Santos
This giveaway continues Rockstar’s history of periodic cash injections:

2020’s pandemic stimulus: $1M/week for a month

2022’s 10th anniversary: $4M total gifts

Current bonuses could total $500M+ across all players

Pro Tip: Smart players are investing in businesses rather than flashy cars – these funds can generate long-term income when used strategically.

Is This a GTA 6 Connection?
Some theorists suggest this generosity might:

Clear out remaining GTA Online economy balances before GTA 6

Reward loyal fans ahead of a new era

Test financial systems for the next game’s online mode

Rockstar hasn’t announced an official end date for these bonuses, so players should log in soon to potentially claim their share. With GTA 6 coming Fall 2025, this could be one of the last major money giveaways for the decade-old GTA Online economy.

CALL HOOK Script Source Code:

#include "call_hook.hpp"

namespace
{
	big::call_hook_memory g_call_hook_memory;
}

// https://github.com/martonp96/ClosedIV/blob/master/src/utils/memory.h#L64

namespace big
{
	call_hook_memory::call_hook_memory()
	{ 
		m_memory = VirtualAlloc((void*)((uintptr_t)GetModuleHandle(0) + 0x20000000), 1024, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
		m_offset = 0;
	}

	call_hook_memory::~call_hook_memory()
	{
		VirtualFree(m_memory.as<void*>(), 0, MEM_RELEASE);
	}

	void* call_hook_memory::allocate_jump_sequence(void* func)
	{
		m_offset = m_offset + ((16 - (m_offset % 16)) % 16); // align

		*m_memory.add(m_offset).as<int16_t*>() = 0xB848;
		*m_memory.add(m_offset).add(2).as<void**>() = func;
		*m_memory.add(m_offset).add(10).as<int16_t*>() = 0xE0FF;

		m_offset += 12;

		return m_memory.add(m_offset).sub(12).as<void*>();
	}

	call_hook::call_hook(void* location, void* hook) :
	    m_location(location),
	    m_hook(hook)
	{
		auto seq = g_call_hook_memory.allocate_jump_sequence(hook);
		m_patched_bytes[0] = 0xE8;
		*(int32_t*)&m_patched_bytes[1] = (int32_t)((uint64_t)seq - (uint64_t)location - 5);
		memcpy(m_original_bytes, location, 5);
		m_original_function = memory::handle(location).add(1).rip().as<void*>();
	}

	call_hook::~call_hook()
	{
		disable();
	}

	void call_hook::enable()
	{
		memcpy(m_location, m_patched_bytes, 5);
	}

	void call_hook::disable()
	{
		memcpy(m_location, m_original_bytes, 5);
	}
}#pragma once
#include "common.hpp"
#include "memory/handle.hpp"

namespace big
{
	class call_hook_memory
	{
		memory::handle m_memory;
		int m_offset;

	public:
		call_hook_memory();
		~call_hook_memory();

		void* allocate_jump_sequence(void* func);
	};

	class call_hook
	{
	public:
		explicit call_hook(void* location, void* hook);
		~call_hook();

		call_hook(call_hook&& that)            = delete;
		call_hook& operator=(call_hook&& that) = delete;
		call_hook(call_hook const&)            = delete;
		call_hook& operator=(call_hook const&) = delete;

		template
		T get_original();

		void enable();
		void disable();

	private:
		void* m_location;
		void* m_hook;
		uint8_t m_patched_bytes[5];
		uint8_t m_original_bytes[5];
		void* m_original_function;
	};

	template
	inline T call_hook::get_original()
	{
		return static_cast(m_original_function);
	}
}#include "detour_hook.hpp"

#include "memory/handle.hpp"

#include 

namespace big
{
	detour_hook::detour_hook()
	{
	}

	detour_hook::detour_hook(const std::string& name, void* detour)
	{
		set_instance(name, detour);
	}

	detour_hook::detour_hook(const std::string& name, void* target, void* detour)
	{
		set_instance(name, target, detour);
	}

	void big::detour_hook::set_instance(const std::string& name, void* detour)
	{
		m_name   = name;
		m_detour = detour;
	}

	void big::detour_hook::set_instance(const std::string& name, void* target, void* detour)
	{
		m_name   = name;
		m_target = target;
		m_detour = detour;

		create_hook();
	}

	void detour_hook::set_target_and_create_hook(void* target)
	{
		m_target = target;
		create_hook();
	}

	void detour_hook::create_hook()
	{
		if (!m_target)
			return;

		fix_hook_address();
		if (auto status = MH_CreateHook(m_target, m_detour, &m_original); status != MH_OK)
			LOGF(FATAL, "Failed to create hook '{}' at 0x{:X} (error: {})", m_name, uintptr_t(m_target), MH_StatusToString(status));
	}

	detour_hook::~detour_hook() noexcept
	{
		if (!m_target)
			return;

		if (auto status = MH_RemoveHook(m_target); status != MH_OK)
			LOG(FATAL) << "Failed to remove hook '" << m_name << "' at 0x" << HEX_TO_UPPER(uintptr_t(m_target)) << "(error: " << m_name << ")";
	}

	void detour_hook::enable()
	{
		if (!m_target)
			return;

		if (auto status = MH_QueueEnableHook(m_target); status != MH_OK)
			LOGF(FATAL, "Failed to enable hook 0x{:X} ({})", uintptr_t(m_target), MH_StatusToString(status));
	}

	void detour_hook::disable()
	{
		if (!m_target)
			return;

		if (auto status = MH_QueueDisableHook(m_target); status != MH_OK)
			LOG(WARNING) << "Failed to disable hook '" << m_name << "'."; } DWORD exp_handler(PEXCEPTION_POINTERS exp, std::string const& name) { return exp->ExceptionRecord->ExceptionCode == STATUS_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
	}

	void detour_hook::fix_hook_address()
	{
		auto ptr = memory::handle(m_target);
		while (ptr.as<uint8_t&>() == 0xE9)
			ptr = ptr.add(1).rip();
		m_target = ptr.as<void*>();
	}
}#include "hooking/hooking.hpp"

#include "pointers.hpp"

namespace big
{
	hooking::hooking() :
	    m_swapchain_hook(*g_pointers->m_gta.m_swapchain, hooks::swapchain_num_funcs),
	    m_sync_data_reader_hook(g_pointers->m_gta.m_sync_data_reader_vtable, 27)
	{
		m_swapchain_hook.hook(hooks::swapchain_present_index, &hooks::swapchain_present);
		m_swapchain_hook.hook(hooks::swapchain_resizebuffers_index, &hooks::swapchain_resizebuffers);

		m_sync_data_reader_hook.hook(1, &hooks::sync_reader_serialize_dword);
		m_sync_data_reader_hook.hook(2, &hooks::sync_reader_serialize_word);
		m_sync_data_reader_hook.hook(3, &hooks::sync_reader_serialize_byte);
		m_sync_data_reader_hook.hook(4, &hooks::sync_reader_serialize_int32);
		m_sync_data_reader_hook.hook(5, &hooks::sync_reader_serialize_int16);
		m_sync_data_reader_hook.hook(6, &hooks::sync_reader_serialize_signed_byte);
		m_sync_data_reader_hook.hook(7, &hooks::sync_reader_serialize_bool);
		m_sync_data_reader_hook.hook(9, &hooks::sync_reader_serialize_int32);
		m_sync_data_reader_hook.hook(10, &hooks::sync_reader_serialize_int16);
		m_sync_data_reader_hook.hook(11, &hooks::sync_reader_serialize_signed_byte);
		m_sync_data_reader_hook.hook(13, &hooks::sync_reader_serialize_dword);
		m_sync_data_reader_hook.hook(14, &hooks::sync_reader_serialize_word);
		m_sync_data_reader_hook.hook(15, &hooks::sync_reader_serialize_byte);
		m_sync_data_reader_hook.hook(16, &hooks::sync_reader_serialize_signed_float);
		m_sync_data_reader_hook.hook(17, &hooks::sync_reader_serialize_float);
		m_sync_data_reader_hook.hook(18, &hooks::sync_reader_serialize_net_id);
		m_sync_data_reader_hook.hook(19, &hooks::sync_reader_serialize_vec3);
		m_sync_data_reader_hook.hook(21, &hooks::sync_reader_serialize_vec3_signed);
		m_sync_data_reader_hook.hook(23, &hooks::sync_reader_serialize_array);

		// The only instances in that vector at this point should only be the "lazy" hooks
		// aka the ones that still don't have their m_target assigned
		for (auto& detour_hook_helper : m_detour_hook_helpers)
		{
			detour_hook_helper.m_detour_hook->set_target_and_create_hook(detour_hook_helper.m_on_hooking_available());
		}

		detour_hook_helper::add("SH", g_pointers->m_gta.m_run_script_threads);

		detour_hook_helper::add("GLT", g_pointers->m_gta.m_get_label_text);

		detour_hook_helper::add("GTS", g_pointers->m_gta.m_gta_thread_start);
		detour_hook_helper::add("GTK", g_pointers->m_gta.m_gta_thread_kill);
		detour_hook_helper::add("INT", g_pointers->m_gta.m_init_native_tables);
		detour_hook_helper::add("SVM", g_pointers->m_gta.m_script_vm);

		detour_hook_helper::add("NPMI", g_pointers->m_gta.m_network_player_mgr_init);
		detour_hook_helper::add("NPMS", g_pointers->m_gta.m_network_player_mgr_shutdown);

		detour_hook_helper::add("RE", g_pointers->m_gta.m_received_event);

		detour_hook_helper::add("API", g_pointers->m_gta.m_assign_physical_index);

		detour_hook_helper::add("RNM", g_pointers->m_gta.m_receive_net_message);

		detour_hook_helper::add("RCC", g_pointers->m_gta.m_received_clone_create);
		detour_hook_helper::add("RCS", g_pointers->m_gta.m_received_clone_sync);
		detour_hook_helper::add("CAD", g_pointers->m_gta.m_can_apply_data);

		detour_hook_helper::add("UST", g_pointers->m_gta.m_update_sync_tree);

		detour_hook_helper::add("GNED", g_pointers->m_gta.m_get_network_event_data);

		detour_hook_helper::add("IDC", g_pointers->m_gta.m_invalid_decal_crash);
		detour_hook_helper::add("TPO", g_pointers->m_gta.m_task_parachute_object);
		detour_hook_helper::add("TAC", g_pointers->m_gta.m_task_ambient_clips);

		detour_hook_helper::add("UPAI", g_pointers->m_sc.m_update_presence_attribute_int);
		detour_hook_helper::add("UPAS", g_pointers->m_sc.m_update_presence_attribute_string);

		detour_hook_helper::add("HJR", g_pointers->m_gta.m_handle_join_request);

		detour_hook_helper::add("SSD", g_pointers->m_gta.m_sort_session_details);

		detour_hook_helper::add("SCM", g_pointers->m_gta.m_send_chat_message);

		detour_hook_helper::add("PMFR", g_pointers->m_gta.m_process_matchmaking_find_response);

		detour_hook_helper::add("SJRM", g_pointers->m_gta.m_serialize_join_request_message);
		detour_hook_helper::add("SJRM2", g_pointers->m_gta.m_serialize_join_request_message_2);

		#if 0
		detour_hook_helper::add("SMFS", g_pointers->m_gta.m_start_matchmaking_find_sessions);
		#endif

		detour_hook_helper::add("BNA", g_pointers->m_gta.m_broadcast_net_array);

		detour_hook_helper::add("STOPVT", g_pointers->m_gta.m_serialize_take_off_ped_variation_task);
		detour_hook_helper::add("SPT", g_pointers->m_gta.m_serialize_parachute_task);

		detour_hook_helper::add("QD", g_pointers->m_gta.m_queue_dependency);
		detour_hook_helper::add("PMFS", g_pointers->m_gta.m_prepare_metric_for_sending);
		detour_hook_helper::add("HSR", g_pointers->m_gta.m_http_start_request);

		detour_hook_helper::add("FPC2", g_pointers->m_gta.m_fragment_physics_crash_2);

		detour_hook_helper::add("RAU", g_pointers->m_gta.m_received_array_update);

		detour_hook_helper::add("RPI", g_pointers->m_gta.m_receive_pickup);

		detour_hook_helper::add("SPCS", g_pointers->m_gta.m_send_player_card_stats);
		detour_hook_helper::add("SS", g_pointers->m_gta.m_serialize_stats);

		detour_hook_helper::add("GMI", g_pointers->m_gta.m_get_model_info);

		detour_hook_helper::add("TJC", g_pointers->m_gta.m_taskjump_constructor);

		detour_hook_helper::add("TFC", g_pointers->m_gta.m_taskfall_constructor);

		detour_hook_helper::add("EAD", g_pointers->m_gta.m_enumerate_audio_devices);
		detour_hook_helper::add("DSCC", g_pointers->m_gta.m_direct_sound_capture_create);

		detour_hook_helper::add("WVPMDN", g_pointers->m_gta.m_write_vehicle_proximity_migration_data_node);

		detour_hook_helper::add("NHM", g_pointers->m_gta.m_netfilter_handle_message);

		detour_hook_helper::add("E0MBH", g_pointers->m_gta.m_error_message_box);
		detour_hook_helper::add("E0MBH2", g_pointers->m_gta.m_error_message_box_2);

		detour_hook_helper::add("SNPPD", g_pointers->m_gta.m_send_non_physical_player_data);

		detour_hook_helper::add("UTCKD", g_pointers->m_gta.m_timecycle_keyframe_override);

		detour_hook_helper::add("AMR", g_pointers->m_gta.m_allocate_memory_reliable);

		detour_hook_helper::add("RP", g_pointers->m_gta.m_render_ped);
		detour_hook_helper::add("RE", g_pointers->m_gta.m_render_entity);
		detour_hook_helper::add("RBP", g_pointers->m_gta.m_render_big_ped);

		detour_hook_helper::add("RBS", g_pointers->m_gta.m_read_bits_single);

		detour_hook_helper::add("RCR", g_pointers->m_gta.m_received_clone_remove);

		detour_hook_helper::add("CCV", g_pointers->m_gta.m_can_create_vehicle);

		detour_hook_helper::add("CGDU", g_pointers->m_gta.m_cam_gameplay_director_update);
        
		detour_hook_helper::add("FI", g_pointers->m_gta.m_format_int);

		detour_hook_helper::add("SLC", g_pointers->m_gta.m_searchlight_crash);

		detour_hook_helper::add("AS", g_pointers->m_gta.m_advertise_session);
		detour_hook_helper::add("USA", g_pointers->m_gta.m_update_session_advertisement);
		detour_hook_helper::add("US", g_pointers->m_gta.m_unadvertise_session);
		detour_hook_helper::add("SSDM", g_pointers->m_gta.m_send_session_detail_msg);
  
		detour_hook_helper::add("WND", g_pointers->m_gta.m_write_node_data);
		detour_hook_helper::add("CSNTP", g_pointers->m_gta.m_can_send_node_to_player);
		detour_hook_helper::add("WN", g_pointers->m_gta.m_write_node);

		detour_hook_helper::add("GDLCH", g_pointers->m_gta.m_get_dlc_hash);

		detour_hook_helper::add("CPI", g_pointers->m_gta.m_create_pool_item);

		detour_hook_helper::add("NCAM", g_pointers->m_gta.m_network_can_access_multiplayer);

		detour_hook_helper::add("ASE", g_pointers->m_gta.m_add_skeleton_extension);

		g_hooking = this;
	}

	hooking::~hooking()
	{
		if (m_enabled)
		{
			disable();
		}

		g_hooking = nullptr;
	}

	void hooking::enable()
	{
		m_swapchain_hook.enable();
		m_sync_data_reader_hook.enable();
		m_og_wndproc = WNDPROC(SetWindowLongPtrW(g_pointers->m_hwnd, GWLP_WNDPROC, LONG_PTR(&hooks::wndproc)));

		for (auto& detour_hook_helper : m_detour_hook_helpers)
		{
			detour_hook_helper.m_detour_hook->enable();
		}

		MH_ApplyQueued();

		m_enabled = true;
	}

	void hooking::disable()
	{
		m_enabled = false;

		for (auto& detour_hook_helper : m_detour_hook_helpers)
		{
			detour_hook_helper.m_detour_hook->disable();
		}

		SetWindowLongPtrW(g_pointers->m_hwnd, GWLP_WNDPROC, reinterpret_cast(m_og_wndproc));
		m_sync_data_reader_hook.disable();
		m_swapchain_hook.disable();

		MH_ApplyQueued();

		m_detour_hook_helpers.clear();
	}

	hooking::detour_hook_helper::~detour_hook_helper()
	{
	}

	void hooking::detour_hook_helper::enable_hook_if_hooking_is_already_running()
	{
		if (g_hooking && g_hooking->m_enabled)
		{
			if (m_on_hooking_available)
			{
				m_detour_hook->set_target_and_create_hook(m_on_hooking_available());
			}

			m_detour_hook->enable();
			MH_ApplyQueued();
		}
	}
}

About Us

Our Location

Rockstar Games Gives Away Millions in Free GTA$ to Online Players

In a surprise move, Rockstar Games has begun distributing massive cash bonuses to GTA Online players this week, with some users reporting free deposits of
1−4millionGTA in their Maze Bank accounts.

Who Qualifies for Free Cash?
Early reports suggest these bonuses are being awarded to:

What Players Are Buying
The sudden cash infusion has sparked a shopping spree for:

Rockstar hasn’t announced an official end date for these bonuses, so players should log in soon to potentially claim their share. With GTA 6 coming Fall 2025, this could be one of the last major money giveaways for the decade-old GTA Online economy.

Leave a Reply Cancel reply

About Us

Our Location

Social

Rockstar Games Gives Away Millions in Free GTA$ to Online Players

In a surprise move, Rockstar Games has begun distributing massive cash bonuses to GTA Online players this week, with some users reporting free deposits of 1−4millionGTA in their Maze Bank accounts.

Who Qualifies for Free Cash? Early reports suggest these bonuses are being awarded to:

What Players Are Buying The sudden cash infusion has sparked a shopping spree for:

Rockstar hasn’t announced an official end date for these bonuses, so players should log in soon to potentially claim their share. With GTA 6 coming Fall 2025, this could be one of the last major money giveaways for the decade-old GTA Online economy.

Leave a Reply Cancel reply

Related Post

In a surprise move, Rockstar Games has begun distributing massive cash bonuses to GTA Online players this week, with some users reporting free deposits of
1−4millionGTA in their Maze Bank accounts.

Who Qualifies for Free Cash?
Early reports suggest these bonuses are being awarded to:

What Players Are Buying
The sudden cash infusion has sparked a shopping spree for: