diff --git a/crates/common/src/error.rs b/crates/common/src/error.rs
index c5964cf..a3c5283 100644
--- a/crates/common/src/error.rs
+++ b/crates/common/src/error.rs
@@ -42,6 +42,10 @@ pub enum TrustedServerError {
     #[display("Invalid UTF-8 data: {message}")]
     InvalidUtf8 { message: String },
 
+    /// Serialization error.
+    #[display("Serialization error: {message}")]
+    Serialization { message: String },
+
     /// HTTP header value creation failed.
     #[display("Invalid HTTP header value: {message}")]
     InvalidHeaderValue { message: String },
@@ -100,6 +104,7 @@ impl IntoHttpResponse for TrustedServerError {
             Self::GdprConsent { .. } => StatusCode::BAD_REQUEST,
             Self::InsecureSecretKey => StatusCode::INTERNAL_SERVER_ERROR,
             Self::InvalidHeaderValue { .. } => StatusCode::BAD_REQUEST,
+            Self::Serialization { .. } => StatusCode::INTERNAL_SERVER_ERROR,
             Self::InvalidUtf8 { .. } => StatusCode::BAD_REQUEST,
             Self::KvStore { .. } => StatusCode::SERVICE_UNAVAILABLE,
             Self::Prebid { .. } => StatusCode::BAD_GATEWAY,
diff --git a/crates/common/src/geo.rs b/crates/common/src/geo.rs
index a903c31..b0e210e 100644
--- a/crates/common/src/geo.rs
+++ b/crates/common/src/geo.rs
@@ -8,7 +8,7 @@ use fastly::Request;
 
 use crate::constants::{
     HEADER_X_GEO_CITY, HEADER_X_GEO_CONTINENT, HEADER_X_GEO_COORDINATES, HEADER_X_GEO_COUNTRY,
-    HEADER_X_GEO_INFO_AVAILABLE, HEADER_X_GEO_METRO_CODE,
+    HEADER_X_GEO_METRO_CODE, HEADER_X_GEO_REGION,
 };
 
 /// Geographic information extracted from a request.
@@ -81,72 +81,54 @@ impl GeoInfo {
     pub fn has_metro_code(&self) -> bool {
         self.metro_code > 0
     }
+
+    /// Sets the geographic information headers on the given request.
+    ///
+    /// This sets the following headers:
+    /// - `x-geo-city`
+    /// - `x-geo-country`
+    /// - `x-geo-continent`
+    /// - `x-geo-coordinates`
+    /// - `x-geo-metro-code`
+    /// - `x-geo-region` (if available)
+    pub fn set_headers(&self, req: &mut Request) {
+        req.set_header(HEADER_X_GEO_CITY, &self.city);
+        req.set_header(HEADER_X_GEO_COUNTRY, &self.country);
+        req.set_header(HEADER_X_GEO_CONTINENT, &self.continent);
+        req.set_header(HEADER_X_GEO_COORDINATES, self.coordinates_string());
+        req.set_header(HEADER_X_GEO_METRO_CODE, self.metro_code.to_string());
+        if let Some(region) = &self.region {
+            req.set_header(HEADER_X_GEO_REGION, region);
+        }
+    }
 }
 
-/// Extracts the DMA (Designated Market Area) code from the request's geolocation data.
+/// Returns the geographic information for the request as a JSON response.
 ///
-/// This function:
-/// 1. Checks if running in Fastly environment
-/// 2. Performs geo lookup based on client IP
-/// 3. Sets various geo headers on the request
-/// 4. Returns the metro code (DMA) if available
+/// Use this endpoint to get the client's location data (City, Country, DMA, etc.)
+/// without making a third-party API call.
 ///
-/// # Arguments
+/// # Errors
 ///
-/// * `req` - The request to extract DMA code from
-///
-/// # Returns
-///
-/// The DMA/metro code as a string if available, None otherwise
-pub fn get_dma_code(req: &mut Request) -> Option<String> {
-    // Debug: Check if we're running in Fastly environment
-    log::info!("Fastly Environment Check:");
-    log::info!(
-        "  FASTLY_POP: {}",
-        std::env::var("FASTLY_POP").unwrap_or_else(|_| "not in Fastly".to_string())
-    );
-    log::info!(
-        "  FASTLY_REGION: {}",
-        std::env::var("FASTLY_REGION").unwrap_or_else(|_| "not in Fastly".to_string())
-    );
-
-    // Get detailed geo information using geo_lookup
-    if let Some(geo) = req.get_client_ip_addr().and_then(geo_lookup) {
-        log::info!("Geo Information Found:");
+/// Returns a 500 error if JSON serialization fails (unlikely).
+pub fn handle_first_party_geo(
+    req: &Request,
+) -> Result<fastly::Response, error_stack::Report<crate::error::TrustedServerError>> {
+    use crate::error::TrustedServerError;
+    use error_stack::ResultExt;
+    use fastly::http::{header, StatusCode};
+    use fastly::Response;
 
-        // Set all available geo information in headers
-        let city = geo.city();
-        req.set_header(HEADER_X_GEO_CITY, city);
-        log::info!("  City: {}", city);
+    let geo_info = GeoInfo::from_request(req);
 
-        let country = geo.country_code();
-        req.set_header(HEADER_X_GEO_COUNTRY, country);
-        log::info!("  Country: {}", country);
-
-        req.set_header(HEADER_X_GEO_CONTINENT, format!("{:?}", geo.continent()));
-        log::info!("  Continent: {:?}", geo.continent());
-
-        req.set_header(
-            HEADER_X_GEO_COORDINATES,
-            format!("{},{}", geo.latitude(), geo.longitude()),
-        );
-        log::info!("  Location: ({}, {})", geo.latitude(), geo.longitude());
-
-        // Get and set the metro code (DMA)
-        let metro_code = geo.metro_code();
-        req.set_header(HEADER_X_GEO_METRO_CODE, metro_code.to_string());
-        log::info!("Found DMA/Metro code: {}", metro_code);
-        return Some(metro_code.to_string());
-    } else {
-        log::info!("No geo information available for the request");
-        req.set_header(HEADER_X_GEO_INFO_AVAILABLE, "false");
-    }
-
-    // If no metro code is found, log all request headers for debugging
-    log::info!("No DMA/Metro code found. All request headers:");
-    for (name, value) in req.get_headers() {
-        log::info!("  {}: {:?}", name, value);
-    }
+    // Create a JSON response
+    let body =
+        serde_json::to_string(&geo_info).change_context(TrustedServerError::Serialization {
+            message: "Failed to serialize geo info".to_string(),
+        })?;
 
-    None
+    Ok(Response::from_body(body)
+        .with_status(StatusCode::OK)
+        .with_header(header::CONTENT_TYPE, "application/json")
+        .with_header("Cache-Control", "private, no-store"))
 }
diff --git a/crates/common/src/html_processor.rs b/crates/common/src/html_processor.rs
index fb161e0..d62ead7 100644
--- a/crates/common/src/html_processor.rs
+++ b/crates/common/src/html_processor.rs
@@ -24,6 +24,7 @@ struct HtmlWithPostProcessing {
     request_host: String,
     request_scheme: String,
     document_state: IntegrationDocumentState,
+    geo_info: Option<crate::geo::GeoInfo>,
 }
 
 impl StreamProcessor for HtmlWithPostProcessing {
@@ -42,6 +43,7 @@ impl StreamProcessor for HtmlWithPostProcessing {
             request_scheme: &self.request_scheme,
             origin_host: &self.origin_host,
             document_state: &self.document_state,
+            geo: self.geo_info.as_ref(),
         };
 
         // Preflight to avoid allocating a `String` unless at least one post-processor wants to run.
@@ -90,6 +92,7 @@ pub struct HtmlProcessorConfig {
     pub request_host: String,
     pub request_scheme: String,
     pub integrations: IntegrationRegistry,
+    pub geo_info: Option<crate::geo::GeoInfo>,
 }
 
 impl HtmlProcessorConfig {
@@ -101,12 +104,14 @@ impl HtmlProcessorConfig {
         origin_host: &str,
         request_host: &str,
         request_scheme: &str,
+        geo_info: Option<&crate::geo::GeoInfo>,
     ) -> Self {
         Self {
             origin_host: origin_host.to_string(),
             request_host: request_host.to_string(),
             request_scheme: request_scheme.to_string(),
             integrations: integrations.clone(),
+            geo_info: geo_info.cloned(),
         }
     }
 }
@@ -116,6 +121,7 @@ impl HtmlProcessorConfig {
 pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcessor {
     let post_processors = config.integrations.html_post_processors();
     let document_state = IntegrationDocumentState::default();
+    let geo_info = config.geo_info.clone();
 
     // Simplified URL patterns structure - stores only core data and generates variants on-demand
     struct UrlPatterns {
@@ -194,6 +200,7 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
             let integrations = integration_registry.clone();
             let patterns = patterns.clone();
             let document_state = document_state.clone();
+            let geo_info = geo_info.clone();
             move |el| {
                 if !injected_tsjs.get() {
                     let mut snippet = String::new();
@@ -202,6 +209,7 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
                         request_scheme: &patterns.request_scheme,
                         origin_host: &patterns.origin_host,
                         document_state: &document_state,
+                        geo: geo_info.as_ref(),
                     };
                     // First inject the unified TSJS bundle (defines tsjs.setConfig, etc.)
                     snippet.push_str(&tsjs::unified_script_tag());
@@ -466,6 +474,7 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
         request_host: config.request_host,
         request_scheme: config.request_scheme,
         document_state,
+        geo_info: config.geo_info,
     }
 }
 
@@ -488,6 +497,7 @@ mod tests {
             request_host: "test.example.com".to_string(),
             request_scheme: "https".to_string(),
             integrations: IntegrationRegistry::default(),
+            geo_info: None,
         }
     }
 
@@ -665,6 +675,7 @@ mod tests {
             "origin.test-publisher.com",
             "proxy.example.com",
             "https",
+            None,
         );
 
         assert_eq!(config.origin_host, "origin.test-publisher.com");
diff --git a/crates/common/src/integrations/nextjs/mod.rs b/crates/common/src/integrations/nextjs/mod.rs
index 549e420..7483423 100644
--- a/crates/common/src/integrations/nextjs/mod.rs
+++ b/crates/common/src/integrations/nextjs/mod.rs
@@ -121,6 +121,7 @@ mod tests {
             "origin.example.com",
             "test.example.com",
             "https",
+            None,
         )
     }
 
diff --git a/crates/common/src/integrations/prebid.rs b/crates/common/src/integrations/prebid.rs
index 6313281..c98cfd2 100644
--- a/crates/common/src/integrations/prebid.rs
+++ b/crates/common/src/integrations/prebid.rs
@@ -54,6 +54,12 @@ pub struct PrebidIntegrationConfig {
         deserialize_with = "crate::settings::vec_from_seq_or_map"
     )]
     pub script_patterns: Vec<String>,
+    #[serde(default)]
+    pub auto_configure: bool,
+
+    /// Ad Units configuration
+    #[serde(default)]
+    pub ad_units: Vec<serde_json::Value>,
 }
 
 impl IntegrationConfig for PrebidIntegrationConfig {
@@ -192,15 +198,107 @@ fn build(settings: &Settings) -> Option<Arc<PrebidIntegration>> {
     Some(PrebidIntegration::new(config))
 }
 
+pub struct PrebidHtmlInjector {
+    config: PrebidIntegrationConfig,
+}
+
+impl PrebidHtmlInjector {
+    fn new(config: PrebidIntegrationConfig) -> Arc<Self> {
+        Arc::new(Self { config })
+    }
+}
+
+impl crate::integrations::IntegrationHtmlPostProcessor for PrebidHtmlInjector {
+    fn integration_id(&self) -> &'static str {
+        PREBID_INTEGRATION_ID
+    }
+
+    fn should_process(
+        &self,
+        html: &str,
+        _ctx: &crate::integrations::IntegrationHtmlContext<'_>,
+    ) -> bool {
+        // Only inject if there's a head tag (to be safe) and we haven't already injected
+        html.contains("<head")
+    }
+
+    fn post_process(
+        &self,
+        html: &mut String,
+        ctx: &crate::integrations::IntegrationHtmlContext<'_>,
+    ) -> bool {
+        // Construct the Prebid configuration object
+        let mut config = json!({
+            "accountId": "trusted-server",
+            "enabled": true,
+            "bidders": self.config.bidders,
+            "timeout": self.config.timeout_ms,
+            "adapter": "prebidServer",
+            "endpoint": format!("{}://{}/openrtb2/auction", ctx.request_scheme, ctx.request_host),
+            "syncEndpoint": format!("{}://{}/cookie_sync", ctx.request_scheme, ctx.request_host),
+            "cookieSet": true,
+            "cookiesetUrl": format!("{}://{}/setuid", ctx.request_scheme, ctx.request_host),
+            "adUnits": self.config.ad_units,
+            "debug": self.config.debug,
+        });
+
+        // Inject Geo information if available
+        if let Some(geo) = ctx.geo {
+            config["geo"] = json!({
+                "city": geo.city,
+                "country": geo.country,
+                "continent": geo.continent,
+                "lat": geo.latitude,
+                "lon": geo.longitude,
+                "metroCode": geo.metro_code,
+                "region": geo.region,
+            });
+        }
+
+        // Script to inject configuration and initialize Prebid via tsjs
+        let script = format!(
+            r#"<script>
+            window.__tsjs_prebid = {};
+            if (window.tsjs && window.tsjs.modules && window.tsjs.modules.prebid) {{
+                window.tsjs.modules.prebid.init();
+            }}
+            </script>"#,
+            config
+        );
+
+        // Inject after <head>
+        if let Some(idx) = html.find("<head>") {
+            let insert_point = idx + 6;
+            html.insert_str(insert_point, &script);
+            true
+        } else if let Some(idx) = html.find("<head") {
+            // Handle case with attributes like <head class="...">
+            if let Some(close_idx) = html[idx..].find('>') {
+                let insert_point = idx + close_idx + 1;
+                html.insert_str(insert_point, &script);
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+}
+
 #[must_use]
 pub fn register(settings: &Settings) -> Option<IntegrationRegistration> {
     let integration = build(settings)?;
-    Some(
-        IntegrationRegistration::builder(PREBID_INTEGRATION_ID)
-            .with_proxy(integration.clone())
-            .with_attribute_rewriter(integration)
-            .build(),
-    )
+    let mut builder = IntegrationRegistration::builder(PREBID_INTEGRATION_ID)
+        .with_proxy(integration.clone())
+        .with_attribute_rewriter(integration.clone());
+
+    if integration.config.auto_configure {
+        builder =
+            builder.with_html_post_processor(PrebidHtmlInjector::new(integration.config.clone()));
+    }
+
+    Some(builder.build())
 }
 
 #[async_trait(?Send)]
@@ -753,7 +851,10 @@ pub fn register_auction_provider(settings: &Settings) -> Vec<Arc<dyn AuctionProv
 mod tests {
     use super::*;
     use crate::html_processor::{create_html_processor, HtmlProcessorConfig};
-    use crate::integrations::{AttributeRewriteAction, IntegrationRegistry};
+    use crate::integrations::{
+        AttributeRewriteAction, IntegrationDocumentState, IntegrationHtmlContext,
+        IntegrationHtmlPostProcessor, IntegrationRegistry,
+    };
     use crate::settings::Settings;
     use crate::streaming_processor::{Compression, PipelineConfig, StreamingPipeline};
     use crate::test_support::tests::crate_test_settings_str;
@@ -774,6 +875,8 @@ mod tests {
             debug: false,
             debug_query_params: None,
             script_patterns: default_script_patterns(),
+            auto_configure: false,
+            ad_units: vec![],
         }
     }
 
@@ -787,6 +890,7 @@ mod tests {
             "origin.example.com",
             "test.example.com",
             "https",
+            None,
         )
     }
 
@@ -1117,4 +1221,96 @@ server_url = "https://prebid.example"
         // Should have 0 routes when no script patterns configured
         assert_eq!(routes.len(), 0);
     }
+
+    #[test]
+    fn test_prebid_html_injector_injection_logic() {
+        let config = PrebidIntegrationConfig {
+            enabled: true,
+            server_url: "http://localhost:8080".to_string(),
+            timeout_ms: 2000,
+            bidders: vec!["bidderA".to_string(), "bidderB".to_string()],
+            debug: false,
+            debug_query_params: None,
+            script_patterns: vec![],
+            auto_configure: true,
+            ad_units: vec![],
+        };
+        let injector = PrebidHtmlInjector::new(config);
+        let params = IntegrationDocumentState::default();
+        let ctx = IntegrationHtmlContext {
+            request_host: "pub.example",
+            request_scheme: "https",
+            origin_host: "origin.example",
+            document_state: &params,
+            geo: None,
+        };
+
+        // Case 1: Simple <head>
+        let mut html = "<html><head><title>Test</title></head><body></body></html>".to_string();
+        assert!(injector.post_process(&mut html, &ctx));
+        assert!(html.starts_with("<html><head><script>"));
+        assert!(html.contains("window.__tsjs_prebid ="));
+        assert!(html.contains("window.tsjs.modules.prebid.init()"));
+
+        // Case 2: Head with attributes
+        let mut html =
+            r#"<html><head lang="en"><title>Test</title></head><body></body></html>"#.to_string();
+        assert!(injector.post_process(&mut html, &ctx));
+        assert!(html.starts_with(r#"<html><head lang="en"><script>"#));
+
+        // Case 3: No head
+        let mut html = "<html><body></body></html>".to_string();
+        assert!(!injector.post_process(&mut html, &ctx));
+        assert!(!html.contains("window.__tsjs_prebid ="));
+    }
+
+    #[test]
+    fn test_prebid_html_injector_config_content() {
+        let config = PrebidIntegrationConfig {
+            enabled: true,
+            server_url: "http://localhost:8080".to_string(),
+            timeout_ms: 2000,
+            bidders: vec!["bidderA".to_string(), "bidderB".to_string()],
+            debug: false,
+            debug_query_params: None,
+            script_patterns: vec![],
+            auto_configure: true,
+            ad_units: vec![],
+        };
+        let injector = PrebidHtmlInjector::new(config);
+        let params = IntegrationDocumentState::default();
+        let ctx = IntegrationHtmlContext {
+            request_host: "pub.example",
+            request_scheme: "https",
+            origin_host: "origin.example",
+            document_state: &params,
+            geo: None,
+        };
+
+        let mut html = "<html><head></head></html>".to_string();
+        injector.post_process(&mut html, &ctx);
+
+        // Extract the JSON config from the injected script
+        // Script pattern: window.__tsjs_prebid = { ... };
+        let start_marker = "window.__tsjs_prebid = ";
+        let start_idx = html
+            .find(start_marker)
+            .expect("should find window.__tsjs_prebid =")
+            + start_marker.len();
+        let end_idx = html[start_idx..]
+            .find(";")
+            .expect("should find closing semicolon")
+            + start_idx;
+
+        let json_str = &html[start_idx..end_idx];
+        let json: serde_json::Value =
+            serde_json::from_str(json_str).expect("should parse valid JSON config");
+
+        assert_eq!(json["timeout"], 2000);
+        assert_eq!(json["bidders"][0], "bidderA");
+        assert_eq!(json["bidders"][1], "bidderB");
+        assert_eq!(json["endpoint"], "https://pub.example/openrtb2/auction");
+        assert_eq!(json["accountId"], "trusted-server");
+        assert_eq!(json["enabled"], true);
+    }
 }
diff --git a/crates/common/src/integrations/registry.rs b/crates/common/src/integrations/registry.rs
index adc77e4..e57e281 100644
--- a/crates/common/src/integrations/registry.rs
+++ b/crates/common/src/integrations/registry.rs
@@ -345,6 +345,8 @@ pub trait IntegrationScriptRewriter: Send + Sync {
     fn rewrite(&self, content: &str, ctx: &IntegrationScriptContext<'_>) -> ScriptRewriteAction;
 }
 
+use crate::geo::GeoInfo;
+
 /// Context for HTML post-processors.
 #[derive(Debug)]
 pub struct IntegrationHtmlContext<'a> {
@@ -352,6 +354,7 @@ pub struct IntegrationHtmlContext<'a> {
     pub request_scheme: &'a str,
     pub origin_host: &'a str,
     pub document_state: &'a IntegrationDocumentState,
+    pub geo: Option<&'a GeoInfo>,
 }
 
 /// Trait for integration-provided HTML post-processors.
@@ -885,6 +888,7 @@ mod tests {
             request_scheme: "https",
             origin_host: "origin.example.com",
             document_state: &document_state,
+            geo: None,
         };
 
         assert!(
diff --git a/crates/common/src/publisher.rs b/crates/common/src/publisher.rs
index fb160f3..a017907 100644
--- a/crates/common/src/publisher.rs
+++ b/crates/common/src/publisher.rs
@@ -5,7 +5,11 @@ use fastly::{Body, Request, Response};
 use crate::backend::BackendConfig;
 use crate::http_util::{serve_static_with_etag, RequestInfo};
 
-use crate::constants::{COOKIE_SYNTHETIC_ID, HEADER_X_COMPRESS_HINT, HEADER_X_SYNTHETIC_ID};
+use crate::constants::{
+    COOKIE_SYNTHETIC_ID, HEADER_X_COMPRESS_HINT, HEADER_X_GEO_CITY, HEADER_X_GEO_CONTINENT,
+    HEADER_X_GEO_COORDINATES, HEADER_X_GEO_COUNTRY, HEADER_X_GEO_METRO_CODE, HEADER_X_GEO_REGION,
+    HEADER_X_SYNTHETIC_ID,
+};
 use crate::cookies::create_synthetic_cookie;
 use crate::error::TrustedServerError;
 use crate::integrations::IntegrationRegistry;
@@ -52,6 +56,7 @@ struct ProcessResponseParams<'a> {
     settings: &'a Settings,
     content_type: &'a str,
     integration_registry: &'a IntegrationRegistry,
+    geo_info: Option<&'a crate::geo::GeoInfo>,
 }
 
 /// Process response body in streaming fashion with compression preservation
@@ -86,6 +91,7 @@ fn process_response_streaming(
             params.request_scheme,
             params.settings,
             params.integration_registry,
+            params.geo_info,
         )?;
 
         let config = PipelineConfig {
@@ -147,6 +153,7 @@ fn create_html_stream_processor(
     request_scheme: &str,
     settings: &Settings,
     integration_registry: &IntegrationRegistry,
+    geo_info: Option<&crate::geo::GeoInfo>,
 ) -> Result<impl StreamProcessor, Report<TrustedServerError>> {
     use crate::html_processor::{create_html_processor, HtmlProcessorConfig};
 
@@ -156,6 +163,7 @@ fn create_html_stream_processor(
         origin_host,
         request_host,
         request_scheme,
+        geo_info,
     );
 
     Ok(create_html_processor(config))
@@ -222,6 +230,32 @@ pub fn handle_publisher_request(
     )?;
     let origin_host = settings.publisher.origin_host();
 
+    // Extract GeoInfo from request before it is consumed
+    use crate::geo::GeoInfo;
+    let geo_info = GeoInfo::from_request(&req);
+
+    // Inject Geo headers for the backend request if available
+    if let Some(geo) = &geo_info {
+        geo.set_headers(&mut req);
+    }
+
+    // Capture Geo headers to copy to response
+    let geo_headers: Vec<(header::HeaderName, String)> = [
+        HEADER_X_GEO_CITY,
+        HEADER_X_GEO_COUNTRY,
+        HEADER_X_GEO_CONTINENT,
+        HEADER_X_GEO_COORDINATES,
+        HEADER_X_GEO_METRO_CODE,
+        HEADER_X_GEO_REGION,
+    ]
+    .iter()
+    .filter_map(|h| {
+        req.get_header(h)
+            .and_then(|v| v.to_str().ok())
+            .map(|v| (h.clone(), v.to_string()))
+    })
+    .collect();
+
     log::debug!(
         "Proxying to dynamic backend: {} (from {})",
         backend_name,
@@ -235,6 +269,11 @@ pub fn handle_publisher_request(
             message: "Failed to proxy request to origin".to_string(),
         })?;
 
+    // Copy Geo headers to response
+    for (name, value) in geo_headers {
+        response.set_header(name, value);
+    }
+
     // Log all response headers for debugging
     log::debug!("Response headers:");
     for (name, value) in response.get_headers() {
@@ -279,6 +318,7 @@ pub fn handle_publisher_request(
             settings,
             content_type: &content_type,
             integration_registry,
+            geo_info: geo_info.as_ref(),
         };
         match process_response_streaming(body, &params) {
             Ok(processed_body) => {
diff --git a/crates/common/src/settings.rs b/crates/common/src/settings.rs
index 6b2d4ca..4b337b6 100644
--- a/crates/common/src/settings.rs
+++ b/crates/common/src/settings.rs
@@ -320,6 +320,35 @@ pub struct Settings {
     pub auction: AuctionConfig,
     #[serde(default)]
     pub proxy: Proxy,
+    #[serde(default)]
+    #[validate(nested)]
+    pub geo: Geo,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, Validate)]
+pub struct Geo {
+    #[serde(default = "default_geo_inject")]
+    pub inject: bool,
+    #[serde(default = "default_geo_cache_key")]
+    #[validate(length(min = 1))]
+    pub cache_key: String,
+}
+
+impl Default for Geo {
+    fn default() -> Self {
+        Self {
+            inject: default_geo_inject(),
+            cache_key: default_geo_cache_key(),
+        }
+    }
+}
+
+fn default_geo_inject() -> bool {
+    false
+}
+
+fn default_geo_cache_key() -> String {
+    "geo".to_string()
 }
 
 #[allow(unused)]
diff --git a/crates/fastly/src/main.rs b/crates/fastly/src/main.rs
index 0112bd9..e6d22e9 100644
--- a/crates/fastly/src/main.rs
+++ b/crates/fastly/src/main.rs
@@ -103,6 +103,10 @@ async fn route_request(
         (Method::POST, "/first-party/proxy-rebuild") => {
             handle_first_party_proxy_rebuild(settings, req).await
         }
+        // Geo info endpoint
+        (Method::GET, "/first-party/geo") => {
+            trusted_server_common::geo::handle_first_party_geo(&req)
+        }
         (m, path) if integration_registry.has_route(&m, path) => integration_registry
             .handle_proxy(&m, path, settings, req)
             .await
diff --git a/crates/js/lib/src/integrations/prebid/index.ts b/crates/js/lib/src/integrations/prebid/index.ts
new file mode 100644
index 0000000..8716899
--- /dev/null
+++ b/crates/js/lib/src/integrations/prebid/index.ts
@@ -0,0 +1,97 @@
+/**
+ * Prebid.js integration module.
+ * Handles initialization and configuration injection.
+ */
+
+interface GeoConfig {
+  lat?: number;
+  lon?: number;
+  country?: string;
+  region?: string;
+  metroCode?: string;
+  city?: string;
+  zip?: string;
+}
+
+interface PrebidConfig {
+  accountId: string;
+  enabled: boolean;
+  bidders: string[];
+  timeout: number;
+  adapter: string;
+  endpoint: string;
+  syncEndpoint: string;
+  cookieSet: boolean;
+  cookiesetUrl: string;
+  debug: boolean;
+  adUnits?: unknown[];
+  geo?: GeoConfig;
+}
+
+interface Pbjs {
+  que: (() => void)[];
+  setConfig: (config: {
+    s2sConfig?: unknown;
+    debug?: boolean;
+    ortb2?: { device: { geo: GeoConfig } };
+  }) => void;
+  addAdUnits: (units: unknown[]) => void;
+}
+
+declare global {
+  interface Window {
+    __tsjs_prebid?: PrebidConfig;
+    pbjs?: Pbjs;
+    __trustedServerPrebid?: boolean;
+  }
+}
+
+export function init() {
+  const config = window.__tsjs_prebid;
+  if (!config) {
+    return;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const pbjs: Pbjs = (window.pbjs as any) || {};
+  pbjs.que = pbjs.que || [];
+
+  pbjs.que.push(() => {
+    // Configure S2S (Server-to-Server)
+    const s2sConfig = {
+      accountId: config.accountId,
+      enabled: config.enabled,
+      bidders: config.bidders,
+      timeout: config.timeout,
+      adapter: config.adapter,
+      endpoint: config.endpoint,
+      syncEndpoint: config.syncEndpoint,
+      cookieSet: config.cookieSet,
+      cookiesetUrl: config.cookiesetUrl,
+    };
+
+    pbjs.setConfig({
+      s2sConfig,
+      debug: config.debug,
+    });
+
+    // Configure Geo/Device data if available
+    if (config.geo) {
+      pbjs.setConfig({
+        ortb2: {
+          device: {
+            geo: config.geo,
+          },
+        },
+      });
+    }
+
+    // Add Ad Units if provided
+    if (config.adUnits && Array.isArray(config.adUnits)) {
+      pbjs.addAdUnits(config.adUnits);
+    }
+  });
+
+  window.pbjs = pbjs;
+  window.__trustedServerPrebid = true;
+}
diff --git a/trusted-server.toml b/trusted-server.toml
index cdad1f5..0da9fa0 100644
--- a/trusted-server.toml
+++ b/trusted-server.toml
@@ -33,6 +33,11 @@ enabled = false  # Set to true to enable request signing
 config_store_id = "<fastly-config-store-id>" # set config/secret store ids for key rotation
 secret_store_id = "<fastly-secret-store-id>"
 
+# Geo configuration
+[geo]
+inject = false
+cache_key = "geo"
+
 [integrations.prebid]
 enabled = true
 server_url = "http://68.183.113.79:8000"