Financial markets are influenced not only by price movements and technical indicators but also by corporate actions and cryptocurrency-related developments. Events such as stock splits, exchange integrations, strategic partnerships, regulatory announcements, security breaches, and major technological developments can affect market expectations and trading behavior.
Stock splits represent corporate actions that change the number of outstanding shares and the corresponding share price without necessarily changing the overall economic value of an investor's ownership. Meanwhile, cryptocurrency events can introduce market-moving information related to adoption, technological development, regulation, security, and institutional participation.
Monitoring these events manually can be challenging because financial information is distributed across different sources and presented in inconsistent formats. Traders must identify relevant events, determine their timing, assess source reliability, and prioritize information that may deserve further investigation.
Python provides an effective environment for automating these activities. Through financial APIs and data processing libraries, different event datasets can be retrieved, standardized, analyzed, and transformed into structured outputs.
This article introduces MarketFlow Events Trader Analyzer, a Python-based system developed using the MarketFlow All-in-One Market Finance API through RapidAPI. The system integrates two primary datasets: stock split events and cryptocurrency events.
The analysis covers November 2–9, 2025. The stock split dataset is retrieved through the /splits-events endpoint, while cryptocurrency information is collected through /crypto-events. Both datasets are subsequently combined into a unified event database.
The analytical framework applies keyword-based sentiment classification, event timing calculations, source reliability evaluation, and a weighted priority scoring mechanism. Each event is classified into HIGH, MEDIUM, or LOW priority categories. The system also aggregates event information by ticker to generate a trading watchlist based on maximum priority, average priority, and sentiment distribution.
The final output consists of a financial event intelligence dashboard, data quality report, API status report, event analysis dataset, and trading watchlist.
The primary objective is to demonstrate how Python and financial APIs can be integrated into an automated event intelligence system that supports structured market monitoring and trading research.
2. Methodology
The MarketFlow Events Trader Analyzer consists of five computational cells. Each cell performs a specific function in the analytical workflow.
Cell | Main function |
|---|---|
Cell 1 | Library installation, API authentication, configuration, and request management. |
Cell 2 | Retrieval of stock split and cryptocurrency events. |
Cell 3 | JSON extraction, data normalization, ticker identification, and data quality evaluation. |
Cell 4 | Sentiment classification, event priority scoring, temporal analysis, and trading watchlist generation. |
Cell 5 | Dashboard visualization, CSV export, and executive summary generation. |
2.1. System Configuration and API Authentication
The system uses Python libraries including Requests, NumPy, Pandas, and Matplotlib.
Requests manages API communication, NumPy supports numerical operations, Pandas handles data processing, and Matplotlib generates financial visualizations.
The analysis period is configured from November 2, 2025, to November 9, 2025. All outputs are stored in the MarketFlow_Events_Analysis directory.
API authentication is performed through a RapidAPI key. The program first checks the RAPIDAPI_KEY environment variable and, if unavailable, requests the key interactively using getpass.
A reusable api_request() function manages HTTP requests, timeout handling, retry mechanisms, and rate-limit responses.
Code — Cell 1: Configuration and API Authentication
Code — Cell 1: Full Configuration and API Authentication
# CELL 1 — CONFIGURATION & API AUTHENTICATION
import os
import json
import time
import getpass
import requests
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timezone
from pathlib import Path
warnings.filterwarnings("ignore")
# MARKETFLOW API
BASE_URL = "https://marketflow-all-in-one-market-finance-api.p.rapidapi.com"
API_HOST = "marketflow-all-in-one-market-finance-api.p.rapidapi.com"
API_KEY = os.getenv("RAPIDAPI_KEY") or getpass.getpass("Masukkan RapidAPI Key: ")
HEADERS = {
"x-rapidapi-key": API_KEY,
"x-rapidapi-host": API_HOST
}
# ANALYSIS PERIOD
START_DATE = "2025-11-02"
END_DATE = "2025-11-09"
# OUTPUT DIRECTORY
OUTPUT_DIR = Path("MarketFlow_Events_Analysis")
OUTPUT_DIR.mkdir(exist_ok=True)
# REQUEST SESSION
session = requests.Session()
session.headers.update(HEADERS)
def api_request(endpoint, params=None, retries=3):
url = f"{BASE_URL}{endpoint}"
for attempt in range(retries):
try:
response = session.get(
url,
params=params,
timeout=40
)
if response.status_code == 429:
wait = 5 * (attempt + 1)
print(f"Rate limit. Waiting {wait}s...")
time.sleep(wait)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.HTTPError:
if response.status_code in [401, 403]:
raise RuntimeError(
f"Authentication/access error: {response.status_code}"
)
if attempt == retries - 1:
raise
except (requests.exceptions.RequestException, ValueError) as error:
if attempt == retries - 1:
raise RuntimeError(f"API request failed: {error}")
time.sleep(3 * (attempt + 1))
return None
print("MarketFlow Trader Analyzer initialized.")
print(f"Analysis period: {START_DATE} to {END_DATE}")
print("Output directory:", OUTPUT_DIR.resolve())
2.2. Data Collection: Stock Splits and Cryptocurrency Events
The second computational cell retrieves two categories of financial events.
The first dataset contains stock split announcements retrieved through /splits-events. The second dataset contains cryptocurrency events retrieved through /crypto-events.
The stock split request uses the configured reporting period, while the cryptocurrency request additionally applies source reliability and importance filters.
The system records the retrieval status and timestamp of each endpoint. This makes it possible to identify successful requests and API failures independently.
Original responses are preserved as JSON files for further inspection and data verification.
Code — Cell 2: Full Data Collection
# CELL 2 — DATA COLLECTION
from IPython.display import display
# 1. STOCK SPLITS EVENTS
splits_params = {
"skip": 0,
"start_date": START_DATE,
"end_date": END_DATE
}
# 2. CRYPTO EVENTS
crypto_params = {
"skip": 0,
"source_reliable": "true",
"important": "false",
"start_date": START_DATE,
"end_date": END_DATE
}
api_results = {}
api_status = []
# Fetch stock splits
try:
api_results["splits"] = api_request(
"/splits-events",
splits_params
)
api_status.append({
"endpoint": "splits-events",
"status": "SUCCESS",
"retrieved_at": datetime.now().isoformat()
})
print("Stock splits data successfully retrieved.")
except Exception as e:
api_results["splits"] = None
api_status.append({
"endpoint": "splits-events",
"status": f"FAILED: {str(e)}",
"retrieved_at": datetime.now().isoformat()
})
# Fetch crypto events
try:
api_results["crypto"] = api_request(
"/crypto-events",
crypto_params
)
api_status.append({
"endpoint": "crypto-events",
"status": "SUCCESS",
"retrieved_at": datetime.now().isoformat()
})
print("Crypto events successfully retrieved.")
except Exception as e:
api_results["crypto"] = None
api_status.append({
"endpoint": "crypto-events",
"status": f"FAILED: {str(e)}",
"retrieved_at": datetime.now().isoformat()
})
# Save original API responses
for name, data in api_results.items():
if data is not None:
with open(
OUTPUT_DIR / f"{name}_raw.json",
"w",
encoding="utf-8"
) as file:
json.dump(
data,
file,
indent=4,
ensure_ascii=False
)
status_df = pd.DataFrame(api_status)
display(status_df)
print("\nAPI COLLECTION COMPLETED")
2.3. Data Cleaning and Normalization
The third computational cell converts the original API responses into structured financial event datasets.
Because API responses may contain nested JSON objects, the system uses a recursive extract_records() function to identify the largest available list of event records.
The normalize_event() function converts each record into a standardized dictionary structure. Nested objects and lists are preserved as JSON strings, while the original record is retained in the raw_record field.
The stock split and cryptocurrency datasets are subsequently combined into a unified DataFrame.
The framework also implements flexible field detection to identify ticker symbols, event dates, event titles, and information sources even when the API uses different field names.
Data cleaning includes date conversion, ticker standardization, missing-value handling, and duplicate removal.
Finally, a data quality report is generated to evaluate the completeness of the retrieved event information.
Code — Cell 3: Full Data Cleaning and Normalization
# CELL 2 — DATA COLLECTION
from IPython.display import display
# 1. STOCK SPLITS EVENTS
splits_params = {
"skip": 0,
"start_date": START_DATE,
"end_date": END_DATE
}
# 2. CRYPTO EVENTS
crypto_params = {
"skip": 0,
"source_reliable": "true",
"important": "false",
"start_date": START_DATE,
"end_date": END_DATE
}
api_results = {}
api_status = []
# Fetch stock splits
try:
api_results["splits"] = api_request(
"/splits-events",
splits_params
)
api_status.append({
"endpoint": "splits-events",
"status": "SUCCESS",
"retrieved_at": datetime.now().isoformat()
})
print("Stock splits data successfully retrieved.")
except Exception as e:
api_results["splits"] = None
api_status.append({
"endpoint": "splits-events",
"status": f"FAILED: {str(e)}",
"retrieved_at": datetime.now().isoformat()
})
# Fetch crypto events
try:
api_results["crypto"] = api_request(
"/crypto-events",
crypto_params
)
api_status.append({
"endpoint": "crypto-events",
"status": "SUCCESS",
"retrieved_at": datetime.now().isoformat()
})
print("Crypto events successfully retrieved.")
except Exception as e:
api_results["crypto"] = None
api_status.append({
"endpoint": "crypto-events",
"status": f"FAILED: {str(e)}",
"retrieved_at": datetime.now().isoformat()
})
# Save original API responses
for name, data in api_results.items():
if data is not None:
with open(
OUTPUT_DIR / f"{name}_raw.json",
"w",
encoding="utf-8"
) as file:
json.dump(
data,
file,
indent=4,
ensure_ascii=False
)
status_df = pd.DataFrame(api_status)
display(status_df)
print("\nAPI COLLECTION COMPLETED")
2.4. Event Intelligence and Trading Analysis
The fourth computational cell performs the main event intelligence analysis.
First, the system classifies event sentiment using predefined positive and negative keyword dictionaries.
Positive keywords include approval, adoption, partnership, launch, integration, growth, surge, upgrade, investment, bullish, and support.
Negative keywords include hack, exploit, lawsuit, ban, crash, fraud, liquidation, breach, outage, decline, bearish, and investigation.
Each event is assigned one of three sentiment categories: POSITIVE, NEGATIVE, or NEUTRAL.
The next stage calculates the number of days remaining until each event. This measurement is used to evaluate event proximity and contributes to the event priority score.
The priority scoring mechanism considers four main factors:
Component | Score |
|---|---|
Stock split event | 45 |
Cryptocurrency event | 30 |
Reliable cryptocurrency source | 20 |
Important cryptocurrency event | 10 |
Event within 3 days | 30 |
Event within 4–7 days | 20 |
Event within 8–30 days | 10 |
Positive or negative sentiment | 5 |
The maximum priority score is capped at 100.
Events are classified into LOW, MEDIUM, and HIGH priority categories. The system also identifies past events, upcoming events, future events, and records with unknown dates.
Finally, event records are aggregated by ticker to generate a trading watchlist. The watchlist includes the total number of events, maximum priority score, average priority score, and positive and negative event counts.
The resulting attention categories are HIGH ATTENTION, MONITOR, and LOW ATTENTION.
Code — Cell 4: Full Event Intelligence and Trading Analysis
# CELL 4 — EVENT INTELLIGENCE & TRADING ANALYSIS
ANALYSIS_DATE = pd.Timestamp.now(tz="UTC").normalize()
# Keyword-based sentiment classification
POSITIVE_WORDS = [
"approval", "adoption", "partnership", "launch",
"integration", "growth", "surge", "upgrade",
"investment", "bullish", "support"
]
NEGATIVE_WORDS = [
"hack", "exploit", "lawsuit", "ban",
"crash", "fraud", "liquidation", "breach",
"outage", "decline", "bearish", "investigation"
]
def classify_sentiment(text):
text = str(text).lower()
positive = sum(word in text for word in POSITIVE_WORDS)
negative = sum(word in text for word in NEGATIVE_WORDS)
if positive > negative:
return "POSITIVE"
elif negative > positive:
return "NEGATIVE"
return "NEUTRAL"
def parse_boolean(value):
if isinstance(value, bool):
return value
return str(value).strip().lower() in [
"true", "1", "yes"
]
def calculate_priority(row):
score = 0
# Event category
if row["event_type"] == "STOCK_SPLIT":
score += 45
else:
score += 30
# Crypto source reliability
if row["event_type"] == "CRYPTO_EVENT":
if parse_boolean(row.get("source_reliable", False)):
score += 20
if parse_boolean(row.get("important", False)):
score += 10
# Event proximity
days = row["days_to_event"]
if pd.notna(days):
if 0 <= days <= 3:
score += 30
elif 3 < days <= 7:
score += 20
elif 7 < days <= 30:
score += 10
# Event sentiment
if row["sentiment"] == "POSITIVE":
score += 5
elif row["sentiment"] == "NEGATIVE":
score += 5
return min(score, 100)
if not events_df.empty:
# Calculate event timing
events_df["days_to_event"] = (
events_df["event_date"] - ANALYSIS_DATE
).dt.total_seconds() / 86400
events_df["days_to_event"] = (
events_df["days_to_event"].round(1)
)
events_df["sentiment"] = (
events_df["event_title"].apply(classify_sentiment)
)
# Source reliability
if "source_reliable" in events_df.columns:
events_df["source_reliable_flag"] = (
events_df["source_reliable"].apply(parse_boolean)
)
else:
events_df["source_reliable_flag"] = np.where(
events_df["event_type"] == "STOCK_SPLIT",
True,
False
)
# Event priority
events_df["priority_score"] = events_df.apply(
calculate_priority,
axis=1
)
events_df["priority"] = pd.cut(
events_df["priority_score"],
bins=[-1, 39, 69, 100],
labels=["LOW", "MEDIUM", "HIGH"]
)
# Temporal classification
events_df["event_status"] = np.select(
[
events_df["days_to_event"].isna(),
events_df["days_to_event"] < 0,
events_df["days_to_event"].between(0, 7),
events_df["days_to_event"] > 7
],
[
"DATE UNKNOWN",
"PAST EVENT",
"UPCOMING - 7 DAYS",
"FUTURE EVENT"
],
default="UNKNOWN"
)
# Watchlist
watchlist_df = (
events_df.groupby("ticker")
.agg(
total_events=("event_type", "count"),
max_priority=("priority_score", "max"),
average_priority=("priority_score", "mean"),
positive_events=(
"sentiment",
lambda x: (x == "POSITIVE").sum()
),
negative_events=(
"sentiment",
lambda x: (x == "NEGATIVE").sum()
)
)
.reset_index()
.sort_values(
"max_priority",
ascending=False
)
)
watchlist_df["trader_attention"] = np.select(
[
watchlist_df["max_priority"] >= 70,
watchlist_df["max_priority"] >= 40
],
[
"HIGH ATTENTION",
"MONITOR"
],
default="LOW ATTENTION"
)
else:
watchlist_df = pd.DataFrame()
# Results
display(
events_df[
[
"ticker",
"event_type",
"event_title",
"event_date",
"sentiment",
"priority_score",
"priority",
"event_status"
]
].sort_values(
"priority_score",
ascending=False
)
)
display(watchlist_df)
print("Event intelligence analysis completed.")
2.5. Dashboard Visualization and Data Export
The fifth computational cell transforms the analytical results into a consolidated financial event dashboard.
The dashboard uses a dark-background presentation and contains four visualizations:
Event Distribution, showing the number of stock split and cryptocurrency events.
Event Priority Distribution, displaying the number of HIGH, MEDIUM, and LOW priority events.
Top 10 Tickers by Event Priority, ranking securities according to their maximum event priority score.
Event Timeline, showing the distribution of recorded events across announcement dates.
The dashboard is saved as a PNG image with 300 DPI resolution.
The system also exports four analytical CSV datasets: event analysis, trading watchlist, data quality, and API status.
Finally, an executive summary reports the total number of events, stock splits, cryptocurrency events, and priority classifications.
Code — Cell 5: Full Dashboard, Visualization, and Export
# CELL 5 — DASHBOARD & EXPORT
plt.style.use("dark_background")
fig, axes = plt.subplots(
2, 2,
figsize=(17, 11)
)
fig.suptitle(
"MARKETFLOW | CORPORATE & CRYPTO EVENTS INTELLIGENCE",
fontsize=16,
fontweight="bold"
)
if not events_df.empty:
# 1. Event distribution
event_counts = events_df["event_type"].value_counts()
axes[0, 0].bar(
event_counts.index,
event_counts.values
)
axes[0, 0].set_title("Event Distribution")
axes[0, 0].set_ylabel("Number of Events")
axes[0, 0].tick_params(axis="x", rotation=15)
# 2. Priority distribution
priority_counts = (
events_df["priority"]
.astype(str)
.value_counts()
.reindex(["HIGH", "MEDIUM", "LOW"], fill_value=0)
)
axes[0, 1].bar(
priority_counts.index,
priority_counts.values
)
axes[0, 1].set_title("Event Priority Distribution")
axes[0, 1].set_ylabel("Number of Events")
# 3. Top ticker watchlist
if not watchlist_df.empty:
top_tickers = watchlist_df.head(10)
axes[1, 0].barh(
top_tickers["ticker"].astype(str),
top_tickers["max_priority"]
)
axes[1, 0].set_title("Top 10 Tickers by Event Priority")
axes[1, 0].set_xlabel("Priority Score")
axes[1, 0].invert_yaxis()
# 4. Event timeline
timeline = (
events_df.dropna(subset=["event_date"])
.groupby(
events_df["event_date"].dt.strftime("%Y-%m-%d")
)
.size()
)
if not timeline.empty:
axes[1, 1].plot(
timeline.index,
timeline.values,
marker="o",
linewidth=2
)
axes[1, 1].set_title("Event Timeline")
axes[1, 1].set_ylabel("Number of Events")
axes[1, 1].tick_params(
axis="x",
rotation=45
)
else:
axes[1, 1].text(
0.5, 0.5,
"No valid event dates",
ha="center",
va="center"
)
else:
for ax in axes.flat:
ax.text(
0.5, 0.5,
"NO EVENT DATA",
ha="center",
va="center",
transform=ax.transAxes
)
fig.suptitle(
"MARKETFLOW | NO EVENT DATA RETURNED",
fontsize=16
)
for ax in axes.flat:
ax.grid(alpha=0.2)
plt.tight_layout()
dashboard_path = (
OUTPUT_DIR / "marketflow_events_dashboard.png"
)
plt.savefig(
dashboard_path,
dpi=300,
bbox_inches="tight"
)
plt.show()
# EXPORT CSV
events_df.to_csv(
OUTPUT_DIR / "marketflow_events_analysis.csv",
index=False
)
watchlist_df.to_csv(
OUTPUT_DIR / "marketflow_trading_watchlist.csv",
index=False
)
quality_df.to_csv(
OUTPUT_DIR / "marketflow_data_quality.csv",
index=False
)
status_df.to_csv(
OUTPUT_DIR / "marketflow_api_status.csv",
index=False
)
# SUMMARY
print("\n" + "=" * 55)
print("MARKETFLOW TRADING ANALYSIS SUMMARY")
print("=" * 55)
print(f"Total Events : {len(events_df)}")
print(f"Stock Splits : {len(splits_df)}")
print(f"Crypto Events : {len(crypto_df)}")
if not events_df.empty:
print(
"High Priority :",
(events_df["priority"] == "HIGH").sum()
)
print(
"Medium Priority :",
(events_df["priority"] == "MEDIUM").sum()
)
print(
"Low Priority :",
(events_df["priority"] == "LOW").sum()
)
print("\nOUTPUT FILES:")
for file in OUTPUT_DIR.iterdir():
print(" -", file.name)
print("\nANALYSIS COMPLETED.")
3. Results and Discussion
3.1. Financial Event Data Retrieval
The data collection module retrieves two categories of financial events through the MarketFlow API.
The stock split dataset provides corporate action information, while the cryptocurrency dataset contains event-related information associated with digital assets.
Both datasets are collected independently and subsequently combined into a unified analytical structure.
The API status report records whether each endpoint successfully returns data. This is important because incomplete API retrieval can affect subsequent event classification and dashboard generation.
3.2. Data Cleaning and Quality Assessment
The data normalization process converts the original JSON responses into structured tabular datasets.
Ticker symbols are standardized into uppercase strings, event dates are converted into UTC datetime values, and missing event titles and sources are assigned default labels.
Duplicate records are removed based on event type, ticker, event date, and event title.
The data quality report evaluates six indicators:
Total stock split records.
Total cryptocurrency event records.
Total combined events.
Missing ticker symbols.
Missing event dates.
Missing event titles.
This process provides an overview of dataset completeness before event intelligence calculations are performed.
3.3. Sentiment Classification
The sentiment classification module evaluates event titles using predefined keyword dictionaries.
Events containing more positive keywords are categorized as POSITIVE, while events containing more negative keywords are categorized as NEGATIVE.
If the positive and negative keyword counts are equal, the system assigns NEUTRAL.
This method offers a simple and computationally efficient approach to event classification.
However, keyword-based sentiment analysis does not fully understand context, sarcasm, negation, or the actual financial implications of an announcement. Therefore, the sentiment labels should be interpreted as preliminary indicators rather than definitive assessments of market impact.
3.4. Event Priority Scoring
The priority scoring module evaluates events using their category, reliability information, importance indicators, proximity to the event date, and sentiment classification.
Stock split events receive a base score of 45, while cryptocurrency events receive a base score of 30.
Additional points are assigned according to event proximity and available cryptocurrency reliability and importance fields.
The final score is converted into three priority categories:
Priority | Score |
|---|---|
LOW | 0–39 |
MEDIUM | 40–69 |
HIGH | 70–100 |
This classification helps traders distinguish events that deserve closer attention from those with relatively lower priority scores.
It is important to note that the priority score is a custom analytical ranking, not a statistically validated probability of price movement.
3.5. Trading Watchlist Analysis
The trading watchlist aggregates event information according to ticker symbols.
For each ticker, the system calculates the total number of events, maximum priority score, average priority score, positive event count, and negative event count.
The resulting attention classification consists of three categories:
HIGH ATTENTION: maximum priority score of at least 70.
MONITOR: maximum priority score of at least 40 but below 70.
LOW ATTENTION: maximum priority score below 40.
This approach provides a ticker-based summary that allows traders to identify assets with relatively higher event priority.
However, the attention classification should not be interpreted as a direct BUY or SELL recommendation. Further analysis of price movements, liquidity, volatility, and market structure is necessary before making trading decisions.
3.6. Financial Event Dashboard
The final visualization module combines four analytical components into one dashboard.
MarketFlow Events Intelligence Dashboard
Event Distribution
Stock splits versus cryptocurrency events.
Priority Distribution
HIGH, MEDIUM, and LOW classifications.
Top 10 Tickers
Assets ranked by maximum event priority.
Event Timeline
Event frequency across recorded dates.
Four dashboard components generated by the Python implementation; this is a description of the output, not an actual API result.
The dashboard provides a consolidated overview of financial event distribution, priority levels, ticker rankings, and event timing.
It is saved as marketflow_events_dashboard.png with a resolution of 300 DPI.
3.7. Exported Analytical Outputs
The program generates the following files inside the MarketFlow_Events_Analysis directory.
Output file | Description |
|---|---|
| Original stock split API response. |
| Original cryptocurrency API response. |
| Four-panel financial event dashboard. |
| Consolidated and classified event records. |
| Ticker-based event priority ranking. |
| Data completeness assessment. |
| API retrieval status report. |
These outputs provide a structured record of the data retrieval and analytical processes and can be used for further financial research.
3.8. Limitations and Future Improvements
Several limitations should be considered when interpreting the results.
First, sentiment classification uses predefined keywords. The system does not use advanced natural language processing or contextual language models.
Second, priority scoring is rule-based. The scoring mechanism is designed for event ranking and does not represent a validated measure of expected market impact.
Third, the analysis date is based on the current UTC date. Because the configured event period is November 2–9, 2025, executing the program in a later period will classify those historical events as past events when their dates are earlier than the execution date.
Fourth, source reliability is handled differently depending on the event type. The program uses the available source_reliable field for cryptocurrency records and assigns a default reliability flag to stock split events.
Fifth, the current implementation does not incorporate historical price reactions. Therefore, the system cannot establish whether an event actually caused a price increase, decrease, or change in volatility.
Future improvements could include:
NLP-based sentiment analysis.
Automatic event source verification.
Historical price reaction analysis.
Event-driven backtesting.
Integration with technical indicators.
Volatility and liquidity analysis.
Real-time event monitoring.
Machine learning-based event impact classification.
These extensions could transform the framework into a more comprehensive financial event intelligence platform.
4. Conclusion
This article presents MarketFlow Events Trader Analyzer, a Python-based financial event intelligence framework that integrates stock split information and cryptocurrency events through the MarketFlow All-in-One Market Finance API.
The system retrieves financial event records, normalizes heterogeneous JSON responses, identifies ticker symbols and event dates, evaluates data quality, and removes duplicate records.
The analytical framework further implements keyword-based sentiment classification, event proximity calculations, source reliability evaluation, and weighted priority scoring. Based on these measurements, events are categorized into HIGH, MEDIUM, and LOW priority levels.
The system also generates a ticker-based trading watchlist that summarizes event frequency, priority scores, and sentiment distribution. Its visualization module presents event distribution, priority classification, top ticker rankings, and event timelines in a consolidated dashboard.
The final outputs include JSON, CSV, and PNG files that support further financial analysis and reporting.
Overall, MarketFlow Events Trader Analyzer provides a practical foundation for automated financial event monitoring and trading intelligence research. Although the current framework does not directly predict price movements or generate validated trading recommendations, its integration of event retrieval, classification, prioritization, and visualization provides a useful starting point for developing more advanced event-driven trading systems.
