> ## Documentation Index
> Fetch the complete documentation index at: https://fruitstand.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# How to Run Sentiment Analysis on Earnings Calls in Snowflake

> Earnings call sentiment analysis with Snowflake Cortex SQL: score each paragraph, split management from analysts, compare the functions, and see the real cost.

*By [Fruit Stand Team](https://fruitstand.dev/about.md) · November 18, 2026 · Guides*

To run sentiment analysis on earnings calls in Snowflake, score each
paragraph with `SNOWFLAKE.CORTEX.SENTIMENT`, which returns −1 to 1, then
average by speaker and section. On 1,174 calls from October 1 to November
13, 2026, management averaged 0.59 in prepared remarks and 0.37 in Q\&A, and
analysts 0.32. Scoring 130,457 paragraphs cost about \$2.24.

Don't score a whole call in one go: `SENTIMENT` reads only the start of
long text, and `AI_SENTIMENT` rejects it. Below are the queries, what the
scores show, how they lined up with the stock's move, and what each Cortex
function costs.

> [!NOTE]
>
> The transcripts come from Fruit Stand's [Earnings Call Transcripts
> listing](https://app.snowflake.com/marketplace/listing/GZTYZ40XYU5) and
> the prices from our [Historical Stock Prices
> listing](https://app.snowflake.com/marketplace/listing/GZTYZTG3LNFA), both
> of which we publish. Every query was run on November 18, 2026, in AWS US
> West 2. Rates are from Snowflake's Service Consumption Table effective
> November 17, 2026, at the on-demand price of \$2.00 per AI credit.

## Which Cortex function to use

Snowflake has three ways to get sentiment from text in SQL:

| Function | Returns | Longest input | AI credits per million tokens |
| - | - | - | - |
| `SNOWFLAKE.CORTEX.SENTIMENT` | A score from −1 to 1 | Reads only the start, about 550 tokens in our test | 0.09 |
| `AI_SENTIMENT` | positive, negative, neutral or mixed, overall and for up to 10 topics you name | 2,048 tokens; longer input returns an error | 1.60, plus a prompt added to every row |
| `AI_COMPLETE` | Whatever you ask the model for, such as a score and a reason in JSON | The model's context window | Depends on the model; `claude-haiku-4-5` is 0.60 in and 3.00 out |

An earnings call runs about 12,000 tokens, so it's too long for the first
two in one piece. In the transcripts listing each row is one paragraph,
which fits: since April 2026 only 0.06% of paragraphs are longer than
2,000 characters.

## Why you can't score a whole call at once

This test takes Coca-Cola's October 27, 2026 call and adds a block of bad
news at the end, then at the start:

```sql theme={null}
with call as (
    select listagg(content, ' ') within group (order by paragraph_number) as transcript
    from earning_call_transcripts_flat_vw
    where symbol = 'KO' and fiscal_year = 2026 and fiscal_quarter = 3
),
bad_news as (
    select repeat('Demand collapsed, we missed every target and we are withdrawing guidance. ', 30) as txt
)
select round(snowflake.cortex.sentiment(txt), 3) as bad_news_only,
       round(snowflake.cortex.sentiment(transcript), 3) as call_only,
       round(snowflake.cortex.sentiment(transcript || ' ' || txt), 3) as call_then_bad_news,
       round(snowflake.cortex.sentiment(txt || ' ' || transcript), 3) as bad_news_then_call
from call, bad_news;
```

| Bad news only | Call only | Call, then bad news | Bad news, then call |
| -: | -: | -: | -: |
| −0.786 | 0.664 | 0.664 | −0.676 |

The call ends with 2,200 characters of bad news and its score doesn't
change. Put the same text first and the score flips. In a second test,
the bad news stopped making any difference once it came after about 3,000
characters of the call, roughly 550 tokens. A whole-call score is a score of the operator's welcome and the
first minute of prepared remarks. `SENTIMENT` gives no warning, so the
mistake is easy to miss.

## Score every paragraph

This scores each paragraph of the calls held from October 1 to November
13, 2026, by companies that traded at least \$50 million a day on average
in September. The filter keeps the sample to the stocks most people follow;
drop it to score all 3,867 calls in that window.

```sql theme={null}
create or replace table call_paragraph_sentiment as
select symbol, fiscal_year, fiscal_quarter, report_date, paragraph_number, speaker,
       snowflake.cortex.sentiment(content) as score
from earning_call_transcripts_flat_vw
where report_date between '2026-10-01' and '2026-11-13'
  and symbol in (
      select code
      from security_price_history_vw
      where exchange_code = 'US' and date between '2026-09-01' and '2026-09-30'
      group by code
      having avg(close * volume) >= 50e6
  );
```

It scored 130,457 paragraphs from 1,211 calls in under a minute on an
X-Small warehouse. Snowflake billed 12,467,377 tokens: 1.12 AI credits, or
\$2.24. This is the only query in the post that costs much; everything after
it reads the table.

## Label management, analysts and the operator

The listing gives each speaker's name, not their role. The operator opens
the Q\&A, so anyone who speaks before that is management, and anyone new
after it is an analyst. (The same idea is in [How to Query Earnings Call
Transcripts in Snowflake SQL](https://fruitstand.dev/blog/query-earnings-call-transcripts-sql.md).)

```sql theme={null}
create or replace table call_paragraph_roles as
with qa as (
    select symbol, fiscal_year, fiscal_quarter,
           min(iff(speaker = 'Operator' and paragraph_number > first_speaker,
                   paragraph_number, null)) as qa_start
    from (
        select *,
               min(iff(speaker <> 'Operator', paragraph_number, null))
                   over (partition by symbol, fiscal_year, fiscal_quarter) as first_speaker
        from call_paragraph_sentiment
    )
    group by all
    having qa_start is not null
),
management as (
    select distinct s.symbol, s.fiscal_year, s.fiscal_quarter, s.speaker
    from call_paragraph_sentiment s
    join qa using (symbol, fiscal_year, fiscal_quarter)
    where s.paragraph_number < qa.qa_start and s.speaker <> 'Operator'
)
select s.*,
       case when s.speaker = 'Operator' then 'Operator'
            when m.speaker is not null then 'Management'
            else 'Analyst' end as role,
       iff(s.paragraph_number < qa.qa_start, 'Prepared remarks', 'Q&A') as section
from call_paragraph_sentiment s
join qa using (symbol, fiscal_year, fiscal_quarter)
left join management m using (symbol, fiscal_year, fiscal_quarter, speaker);
```

The `having` drops calls with no operator, such as Netflix's and Tesla's,
which take questions another way; that leaves 1,174 of the 1,211 calls. An
executive who speaks only during the Q\&A is counted as an analyst, so for
close work map names to titles yourself.

## What the scores look like

```sql theme={null}
select section, role,
       count(*) as paragraphs,
       round(avg(score), 2) as avg_score,
       round(avg(iff(score >= 0.5, 1, 0)), 3) as positive_share,
       round(avg(iff(score <= -0.5, 1, 0)), 4) as negative_share
from call_paragraph_roles
group by section, role
order by section, role;
```

| Section | Speaker | Paragraphs | Average score | Score 0.5 or more | Score −0.5 or less |
| - | - | -: | -: | -: | -: |
| Prepared remarks | Management | 28,589 | 0.59 | 69.5% | 0.07% |
| Prepared remarks | Operator | 1,242 | 0.45 | 49.9% | 0.08% |
| Q\&A | Analyst | 33,919 | 0.32 | 27.4% | 0.38% |
| Q\&A | Management | 49,208 | 0.37 | 36.9% | 0.59% |
| Q\&A | Operator | 13,285 | 0.08 | 4.8% | 0.24% |

Three things stand out:

* **Almost nothing is negative.** Snowflake's docs call −0.5 or lower
  negative, and under 1% of paragraphs reach it. None of Intel's did, on a
  call after which the stock fell 31%. Executives and analysts don't talk in negative words.
  Compare scores between calls, or against a company's own history; don't
  rely on the docs' cutoffs.
* **Management sounds different in the Q\&A.** The same people average 0.59
  reading prepared remarks and 0.37 answering questions.
* **Leave the operator out.** "Our next question comes from…" scores near
  zero and pulls a call's average toward neutral.

## Did tone line up with the stock's move?

To compare tone with the market's reaction, join each call to the
[Historical Stock Prices listing](https://fruitstand.dev/datasets/historical-stock-prices.md). The
return runs from the close before the call date to the close after it, so
it covers calls held before the open and after the close alike, minus
SPY's return over the same days:

```sql theme={null}
create or replace table call_tone as
with calls as (
    select symbol, report_date, 'SPY' as benchmark,
           avg(iff(role = 'Management' and section = 'Prepared remarks', score, null)) as prepared_tone,
           avg(iff(role = 'Management' and section = 'Q&A', score, null)) as answer_tone,
           avg(iff(role = 'Analyst', score, null)) as analyst_tone
    from call_paragraph_roles
    group by symbol, report_date
),
px as (
    select code, date, adjusted_close
    from security_price_history_vw
    where exchange_code = 'US' and date >= '2026-09-15'
)
select c.*,
       a.adjusted_close / b.adjusted_close - (sa.adjusted_close / sb.adjusted_close) as excess_return
from calls c
asof join px b  match_condition (c.report_date > b.date)  on c.symbol = b.code
asof join px a  match_condition (c.report_date < a.date)  on c.symbol = a.code
asof join px sb match_condition (c.report_date > sb.date) on c.benchmark = sb.code
asof join px sa match_condition (c.report_date < sa.date) on c.benchmark = sa.code;
```

Then split the calls into fifths by how positive the analysts sounded:

```sql theme={null}
with q as (
    select ntile(5) over (order by analyst_tone) as quintile, analyst_tone, excess_return
    from call_tone
    where analyst_tone is not null and excess_return is not null
)
select quintile, count(*) as calls,
       round(min(analyst_tone), 2) || ' to ' || round(max(analyst_tone), 2) as analyst_tone,
       round(avg(excess_return), 4) as avg_excess_return,
       round(median(excess_return), 4) as median_excess_return
from q
group by quintile
order by quintile;
```

| Analyst tone | Calls | Score range | Average return vs. SPY | Median return vs. SPY |
| - | -: | - | -: | -: |
| Least positive fifth | 234 | 0.08 to 0.26 | −0.44% | +0.89% |
| 2 | 234 | 0.26 to 0.30 | +0.23% | +0.68% |
| 3 | 234 | 0.30 to 0.34 | +1.37% | +1.40% |
| 4 | 233 | 0.34 to 0.39 | +1.96% | +1.95% |
| Most positive fifth | 233 | 0.39 to 0.58 | +3.33% | +3.62% |

The most positive fifth beat the least positive by 3.8 points on average.
Analyst tone tracked the move more closely than management's did: its
correlation with the return was 0.14, against 0.07 for prepared remarks and
0.04 for management's answers. Management reads prepared remarks from a
script; analysts react to the numbers.

Intel's October 29 call shows it. Third-quarter revenue rose 21% to $16.5
billion, but Intel's [release](https://www.intc.com/news-events/press-releases/detail/1786/intel-reports-third-quarter-2026-financial-results)
guided fourth-quarter revenue to $15.0 to $16.0 billion. Management's
prepared remarks scored 0.58, about average. The analysts scored 0.12, in
the least positive fifth. The stock fell from $95.53 on October 28 to
\$65.76 on October 30, 29.0 points worse than SPY.

Read this as a description, not a trading signal:

* **It's one earnings season.** 1,174 calls over six weeks.
* **It isn't a forecast.** The return window includes the call, so the
  analysts were reacting to the same results the market was.
* **Compare the rows, not the zero line.** Most rows beat SPY because SPY
  fell over many of the busiest windows, including 4.1% from November 4
  to 6.

To test tone as a signal, measure returns that start after the call and
compare each company's tone with its own past calls. [How to Calculate
Stock Returns From Daily Prices in SQL](https://fruitstand.dev/blog/calculate-stock-returns-sql.md)
has the return queries.

## Tone by topic with AI\_SENTIMENT

`AI_SENTIMENT` labels the paragraph overall and for topics you name. This
runs it on the management and analyst paragraphs of Intel's call, with five
topics:

```sql theme={null}
create or replace table intel_aspects as
select r.role, t.paragraph_number, t.content,
       ai_sentiment(t.content, ['guidance', 'demand', 'margins', 'supply', 'pricing']) as result
from earning_call_transcripts_flat_vw t
join call_paragraph_roles r using (symbol, fiscal_year, fiscal_quarter, paragraph_number)
where t.symbol = 'INTC' and t.fiscal_year = 2026 and t.fiscal_quarter = 3
  and r.role <> 'Operator';
```

Snowflake's docs say a topic the text doesn't mention comes back as
`unknown`. On these 141 paragraphs it rarely did. This counts each topic's
labels, split by whether the paragraph mentions it:

```sql theme={null}
with labels as (
    select a.role, c.value:name::string as aspect, c.value:sentiment::string as sentiment,
           regexp_instr(a.content,
               decode(aspect, 'guidance', 'guid|outlook|forecast', 'demand', 'demand',
                      'margins', 'margin', 'supply', 'suppl|capacity|shortage', 'pricing', 'pric'),
               1, 1, 0, 'i') > 0 as mentioned
    from intel_aspects a,
         lateral flatten(a.result:categories) c
    where c.value:name::string <> 'overall'
)
select aspect,
       count_if(mentioned) as paragraphs_mentioning,
       count_if(mentioned and sentiment = 'positive') as positive,
       count_if(mentioned and sentiment = 'negative') as negative,
       count_if(not mentioned and sentiment <> 'unknown') as labeled_without_mention
from labels
group by aspect
order by aspect;
```

| Topic | Paragraphs that mention it | Positive | Negative | Labeled anyway, without a mention |
| - | -: | -: | -: | -: |
| demand | 24 | 20 | 2 | 117 |
| guidance | 19 | 6 | 4 | 119 |
| margins | 15 | 9 | 5 | 121 |
| pricing | 6 | 0 | 5 | 132 |
| supply | 32 | 18 | 10 | 109 |

Pricing comes up in 6 paragraphs, but `AI_SENTIMENT` labeled it in 132
others too. Count only the paragraphs that mention a topic, as the
`mentioned` flag does. On those, Intel's call reads as you'd expect from the
release: demand mostly positive, while supply drew 10 negative paragraphs
and pricing 5 of 6.

## Score a whole call with AI\_COMPLETE

To score a whole call at once, or ask for a reason as well as a score, send
the full transcript to a model with `AI_COMPLETE`. `response_format` makes
it return JSON, and a temperature of 0 makes reruns repeatable:

```sql theme={null}
with calls as (
    select symbol,
           listagg(speaker || ': ' || content, '\n\n') within group (order by paragraph_number) as transcript
    from earning_call_transcripts_flat_vw
    where fiscal_year = 2026 and fiscal_quarter = 3 and symbol in ('INTC', 'KO')
    group by symbol
)
select symbol,
       ai_complete(
           model => 'claude-haiku-4-5',
           prompt => 'Score the tone of this earnings call from -1 (very negative) to 1 (very positive), '
                  || 'separately for management and for the analysts asking questions. '
                  || 'Give the single biggest concern raised, in under 15 words.\n\n' || transcript,
           model_parameters => {'temperature': 0},
           response_format => {'type': 'json', 'schema': {'type': 'object',
               'properties': {'management_tone': {'type': 'number'},
                              'analyst_tone': {'type': 'number'},
                              'top_concern': {'type': 'string'}},
               'required': ['management_tone', 'analyst_tone', 'top_concern']}}
       ) as result
from calls
order by symbol;
```

| Company | Management tone | Analyst tone | Top concern, in the model's words |
| - | -: | -: | - |
| Intel | 0.40 | −0.20 | Supply constraints limiting ability to meet unprecedented AI infrastructure demand |
| Coca-Cola | 0.75 | 0.35 | Cycling strong prior-year volume comparisons and sustaining growth momentum into 2027 |

The model rated Intel's analysts negative, which `SENTIMENT` never did.
It's more expensive per call and its scale is the model's own judgment, so
keep the prompt and model fixed if you compare calls over time. Snowflake's
[quant research guide](https://www.snowflake.com/en/developers/guides/quantitative-research-with-ai-functions-and-coco/)
uses the same approach with a 1 to 10 scale on the Dow 30.

## Older calls: split long paragraphs first

Before April 2026, the listing's transcripts used longer paragraphs: 7.7%
of 2025's are over 2,000 characters, and the longest runs to 71,684. Split
those into chunks with `SPLIT_TEXT_RECURSIVE_CHARACTER` and average the
chunks' scores:

```sql theme={null}
with paras as (
    select paragraph_number, speaker, content
    from earning_call_transcripts_flat_vw
    where symbol = 'KO' and fiscal_year = 2025 and fiscal_quarter = 2
      and length(content) > 2000
),
chunks as (
    select p.paragraph_number, p.speaker, c.value::string as chunk_text
    from paras p,
         lateral flatten(snowflake.cortex.split_text_recursive_character(p.content, 'none', 1500, 0)) c
)
select paragraph_number, speaker, count(*) as chunks,
       round(avg(snowflake.cortex.sentiment(chunk_text)), 2) as score
from chunks
group by paragraph_number, speaker
order by paragraph_number;
```

Coca-Cola's July 2025 call has five paragraphs over 2,000 characters; the
longest, from the CEO's prepared remarks, splits into 8 chunks. Chunks of
1,500 characters stay under `SENTIMENT`'s limit and well under
`AI_SENTIMENT`'s.

## What it costs

| Run | Rate (AI credits per million tokens) | Tokens billed | AI credits | Cost at \$2.00 |
| - | - | -: | -: | -: |
| `SENTIMENT` on every paragraph of 1,211 calls | 0.09 | 12,467,377 | 1.122 | \$2.24 |
| `AI_SENTIMENT`, 5 topics, Intel's 141 paragraphs | 1.60 | 35,329 | 0.057 | \$0.11 |
| `AI_COMPLETE` with `claude-haiku-4-5`, Intel's whole call | 0.60 in, 3.00 out | 12,925 in, 88 out | 0.008 | \$0.016 |

`AI_SENTIMENT` billed three times the 11,832 tokens in those paragraphs, because
it adds a prompt and the topic list to every paragraph. At that rate, the
1,211 calls would cost about $120 with `AI_SENTIMENT`, about $16 with
`claude-haiku-4-5`, and \$2.24 with `SENTIMENT`. The warehouse is billed on
top; Snowflake recommends nothing larger than Medium, since a bigger one
doesn't make these functions faster.

Each call shows up in `snowflake.account_usage.cortex_ai_functions_usage_history`,
within a few hours:

```sql theme={null}
select function_name, model_name, query_id, metrics, credits
from snowflake.account_usage.cortex_ai_functions_usage_history
where start_time >= dateadd(day, -1, current_timestamp())
order by credits desc;
```

## Things to know

* **English.** `SENTIMENT` is documented for English text.
  `AI_SENTIMENT` also handles French, German, Hindi, Italian, Portuguese and
  Spanish.
* **Region.** `AI_SENTIMENT` runs in a list of regions, plus cross-region
  inference; check [Snowflake's
  docs](https://docs.snowflake.com/en/sql-reference/functions/ai_sentiment)
  for yours. All three need the `SNOWFLAKE.CORTEX_USER` database role.
* **Scores are relative.** Different functions, models and prompts give
  different scales. Pick one and keep it.
* **Speaker roles are inferred.** The listing has names, not titles, so the
  management and analyst labels come from the operator pattern above.

## F.A.Q.

> [accordion] Which Snowflake function is best for earnings call sentiment?
>
> For scoring many calls, `SNOWFLAKE.CORTEX.SENTIMENT` on each paragraph: it's about 18 times cheaper per token than `AI_SENTIMENT` and gives a number you can average. Use `AI_SENTIMENT` for tone on specific topics, and `AI_COMPLETE` when you want a reason with the score.

> [accordion] Can I run SENTIMENT on a whole transcript?
>
> It runs, but it reads only roughly the first 550 tokens and ignores the rest without a warning. Score paragraphs or chunks and average them.

> [accordion] Why are almost no paragraphs negative?
>
> Earnings calls use careful, mostly upbeat language. Under 1% of paragraphs scored −0.5 or lower, even on calls followed by a 30% drop. Compare scores between calls instead of using fixed cutoffs.

> [accordion] How much does it cost to score a quarter of earnings calls?
>
> Scoring every paragraph of 1,211 calls with `SENTIMENT` billed 12.5 million tokens, 1.12 AI credits or about $2.24, plus warehouse time. The same calls would cost about $120 with `AI_SENTIMENT`.

> [accordion] Does call sentiment predict stock returns?
>
> In this sample it lined up with the two-day move: calls where analysts sounded most positive beat SPY by 3.8 points more than the least positive ones. That window includes the call itself, so it's not a forecast. Test returns that start after the call before trading on it.

To run these queries on calls from 4,500+ companies since 2005, start a
free 30-day trial of the [Earnings Call Transcripts listing on the Snowflake
Marketplace](https://app.snowflake.com/marketplace/listing/GZTYZ40XYU5).
The schema is in the [dataset docs](https://fruitstand.dev/datasets/earnings-call-transcripts.md).
For the price data in the reaction queries, see the [Historical Stock Prices
listing](https://app.snowflake.com/marketplace/listing/GZTYZTG3LNFA).
Questions? Reach out at [contact@fruitstand.dev](mailto:contact@fruitstand.dev).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.